Concurrency: साझा स्थिति के साथ रहने के 6 तरीके

मल्टी-थ्रेडेड प्रोग्रामिंग में कई कठिनाइयां हैं, जिनमें से मुख्य साझा स्थिति और प्रदान की गई गुठली के कुशल उपयोग के साथ काम कर रहे हैं। कोर के उपयोग पर अगले लेख में चर्चा की जाएगी।

एक बहु-थ्रेडेड वातावरण में एक साझा स्थिति के साथ, दो बिंदु हैं जो सभी कठिनाइयों का कारण बनते हैं: दौड़ की स्थिति और परिवर्तनों की दृश्यता। एक दौड़ राज्य में, धागे एक साथ राज्य बदलते हैं, गैर-नियतात्मक व्यवहार के लिए अग्रणी होते हैं। और दृश्यता के साथ समस्या यह है कि एक स्ट्रीम में डेटा बदलने का परिणाम दूसरे के लिए अदृश्य हो सकता है। लेख इन समस्याओं से निपटने के छह तरीके बताएगा।

सभी उदाहरण जावा में दिए गए हैं, लेकिन उनमें टिप्पणियां हैं और मुझे उम्मीद है कि वे जावा से परिचित नहीं प्रोग्रामरों के लिए स्पष्ट होंगे। यह लेख समीक्षा के लिए है और यह संपूर्ण नहीं है। इसी समय, यह उन लिंक्स से भरा होता है जो शब्दों और कथनों का अधिक विस्तृत विवरण प्रदान करते हैं।

साझा की गई अवस्था

मैं संख्याओं की गणना के उदाहरण पर एक साझा स्थिति के साथ काम दिखाऊंगा।
गणना का सूत्र इस प्रकार है:

f(0) = 0 f(1) = 1 f(n) = f(n - 1) + f(n - 2) , n >= 2 

सबसे पहले, हम इंटरफ़ेस को परिभाषित करते हैं:

 public interface FibonacciGenerator<T> { /** *    */ T next(); /** *     */ public T val(); } 

हमारी कक्षाएं FibonacciGenerator इंटरफेस को लागू करेंगी। यह सूत्र से देखा जा सकता है कि अगले नंबर को प्रदान करने के लिए, आपको दो पिछले वाले को स्टोर करना होगा - यह साझा स्थिति होगी जिसके लिए प्रतियोगिता होगी। हमारा कार्यान्वयन धागा सुरक्षित होना चाहिए। यही है, उपभोक्ताओं की एक साथ संख्या की परवाह किए बिना, यह अपने आक्रमणकारियों को बनाए रखेगा और अनुबंध का पालन करेगा। और इसलिए, चलो शुरू करें।

ताला

बहु-थ्रेडेड वातावरण में कक्षा के काम को सही ढंग से करने का पहला तरीका ताले का उपयोग करना और सभी विधियों को सिंक्रनाइज़ घोषित करना है। एक उदाहरण वेक्टर क्लास है।

 public class IntrinsicLock implements FibonacciGenerator<BigInteger> { private BigInteger curr = BigInteger.ONE; private BigInteger next = BigInteger.ONE; @Override public synchronized BigInteger next() { BigInteger result = curr; curr = next; next = result.add(next); return result; } @Override public synchronized BigInteger val() { return curr; } } 

हमें एक ऐसा वर्ग मिला है जो न्यूनतम प्रयास करते हुए बहु-सूत्रीय वातावरण में सही ढंग से काम करता है। सबसे पहले, हम प्रदर्शन का त्याग करते हैं। कक्षा का प्रदर्शन वैसा ही है जैसे कि इसे एकल-थ्रेडेड वातावरण में लॉन्च किया गया था। इसके अलावा, तालों के उपयोग से समस्याएं आती हैं जैसे: गतिरोध , लाइवलॉक , आदि।

ठीक-ठाक ताला लगा हुआ

अगला तरीका यह है कि हमारी संरचनाओं को भागों में तोड़ दिया जाए और केवल उन वर्गों को लॉक किया जाए जिनमें साझा स्थिति के साथ काम होता है। इस दृष्टिकोण का एक उदाहरण oncurrentHashMap है । इसमें, सभी डेटा को कई भागों में विभाजित किया गया है। प्रवेश करते समय, केवल वह भाग अवरुद्ध होता है, जिसका परिवर्तन फिलहाल हो रहा है। अधिक कार्यात्मक ताले का उपयोग करने का एक विकल्प भी है, जैसे: स्टैम्पडेलॉक (जावा 8) , रीड्राइटलॉक । सही एल्गोरिथ्म और कार्यान्वयन के साथ, हम एक उच्च स्तर की समानता प्राप्त करते हैं। ReadWriteLock का उपयोग करके उदाहरण:

 public class FineGrainedLock implements FibonacciGenerator<BigInteger> { private final ReadWriteLock lock = new ReentrantReadWriteLock(); private BigInteger curr = BigInteger.ONE; private BigInteger next = BigInteger.ONE; @Override public BigInteger next() { BigInteger result; lock.writeLock().lock(); try { //     result = curr; curr = next; next = result.add(next); return result; } finally { lock.writeLock().unlock(); } } @Override public BigInteger val() { lock.readLock().lock(); try { //   write lock // `    return curr; } finally { lock.readLock().unlock(); } } } 

हमने कक्षा में सुधार किया और उच्च पठनीय थ्रूपुट हासिल किया। इस तरह के कार्यान्वयन में ताले के सभी minuses हैं। इसके अलावा, minuses से यह जोड़ा गया कि एल्गोरिथ्म अधिक जटिल हो गया (शोर जोड़ा गया था जो काम के तर्क से संबंधित नहीं था) और गलत कार्यान्वयन की संभावना बढ़ गई।

लॉक-फ्री एल्गोरिदम

ताले का उपयोग प्रदर्शन और शुद्धता के साथ बहुत सारी समस्याओं को जन्म देता है। गैर-अवरुद्ध एल्गोरिदम के रूप में एक विकल्प है । इस तरह के एल्गोरिदम प्रोसेसर द्वारा प्रदान किए गए परमाणु संचालन पर बनाए जाते हैं। एक उदाहरण है समवर्ती हाशप में प्राप्त विधि। गैर-अवरोधक एल्गोरिदम लिखने के लिए, यह मौजूदा गैर-अवरुद्ध वर्गों का उपयोग करने के लिए समझ में आता है: समवर्तीलंकल क्यू , समवर्ती हाशपेज़, आदि। हम अपनी कक्षा के गैर-अवरोधक कार्यान्वयन को लिखेंगे।

 public class LockFree implements FibonacciGenerator<BigInteger> { //      private static class State { final BigInteger next; final BigInteger curr; public State(BigInteger curr, BigInteger next) { this.next = next; this.curr = curr; } } //     private final AtomicReference<State> atomicState = new AtomicReference<>( new State(BigInteger.ONE, BigInteger.ONE)); public BigInteger next() { BigInteger value = null; while (true) { //    State state = atomicState.get(); //         value = state.curr; //    State newState = new State(state.next, state.curr.add(state.next)); //         //   ,     , //      if (atomicState.compareAndSet(state, newState)) {break;} } return value; } @Override public BigInteger val() { return atomicState.get().curr; } } 

इस दृष्टिकोण के फायदों में से, यह अवरुद्ध एल्गोरिदम की तुलना में प्रदर्शन में वृद्धि के लायक है। और यह भी, कोई कम महत्वपूर्ण नहीं, ताले की खामियों से छुटकारा। नकारात्मक पक्ष यह है कि गैर-अवरोधक एल्गोरिथ्म के साथ आने के लिए यह बहुत कठिन है।

सॉफ्टवेयर ट्रांसेक्शनल मेमोरी

गैर-अवरोधक एल्गोरिदम का एक विकल्प सॉफ्टवेयर ट्रांसेक्शनल मेमोरी का उपयोग है। इसका उपयोग डेटाबेस के साथ काम करते समय लेनदेन के उपयोग के समान है। यह अवधारणा काफी नई है (1995) और लोकप्रिय भाषाओं के बीच, देशी समर्थन केवल क्लोजर में है। लाइब्रेरी-स्तर STM समर्थन जावा सहित कई भाषाओं में उपलब्ध है। मैं अक्का परियोजना के हिस्से के रूप में कार्यान्वित एसटीएम का उपयोग करूंगा।

 public class STM implements FibonacciGenerator<BigInteger> { //      //         private final Ref<BigInteger> curr = new Ref<>(BigInteger.ONE); private final Ref<BigInteger> next = new Ref<>(BigInteger.ONE); @Override public BigInteger next() { //   return new Atomic<BigInteger>() { //    //   I (https://en.wikipedia.org/wiki/ACID) @Override public BigInteger atomically() { //      BigInteger result = curr.get(); //      curr.set(next.get()); next.set(result.add(next.get())); //       // .  ,   ,   //      . //   ,     . return result; } //    }.execute(); } @Override public BigInteger val() { //    return curr.get(); } } 

कोड को समझना आसान है और गैर-अवरुद्ध एल्गोरिदम और तालों के उपयोग से कोई शोर पैदा नहीं होता है। लेकिन इसके लिए हम कम उत्पादकता और सीमित प्रयोज्यता के साथ भुगतान करते हैं, क्योंकि एसटीएम लेखकों की तुलना में बहुत अधिक पाठक होने पर अच्छा प्रदर्शन करता है।

अचल स्थिति

समस्याएँ इस तथ्य के साथ साझा करती हैं कि यह परिवर्तनशील है। यही है, एक वर्ग को अपरिवर्तनीय रूप से डिजाइन करके, आप प्रतिबंध के बिना बहु-थ्रेडेड वातावरण में इसके साथ काम कर सकते हैं, क्योंकि यह थ्रेड-सुरक्षित भी होगा। लेकिन अपरिवर्तनीय डेटा संरचनाओं को अक्सर कार्यात्मक दृष्टिकोण और विशेष डेटा संरचनाओं की आवश्यकता होती है, क्योंकि स्मृति की लागत बहुत अधिक हो सकती है।

 public class Immutable { private final BigInteger next; //   public final BigInteger val; private Immutable(BigInteger next, BigInteger val) { this.next = next; this.val = val; } public Immutable next() { return new Immutable(val.add(next), next); } public static Immutable first() { return new Immutable(BigInteger.ONE, BigInteger.ONE); } } 

जैसा कि आपने देखा, क्लास इंटरफ़ेस बदल गया है और इसके साथ काम करने के लिए अन्य तरीकों की आवश्यकता होगी।

पृथक उत्परिवर्तन

वस्तुओं के अलग-अलग उत्परिवर्तन का विचार यह है कि उन तक पहुंच हमेशा एक ही धागे तक सीमित होती है। इसलिए, हमारे पास मल्टीथ्रेडेड कार्यक्रमों की विशेषता समस्याएं नहीं होंगी। यह दृष्टिकोण अभिनेता मॉडल का उपयोग करता है । अभिनेता ऐसी इकाइयाँ हैं जो उन वस्तुओं के समान होती हैं जिनकी उत्परिवर्तन अवस्था और व्यवहार होता है। अभिनेताओं का परस्पर संपर्क अतुल्यकालिक संदेश के माध्यम से होता है। संदेश अपरिवर्तनीय हैं और अभिनेता एक बार में एक संदेश संसाधित करता है। किसी संदेश को संसाधित करने का परिणाम व्यवहार, स्थिति और अन्य क्रियाओं में परिवर्तन है। अभिनेताओं का उपयोग करने का एक उदाहरण अगले लेख में दिया जाएगा।

परिणाम

प्रत्येक दृष्टिकोण के अपने minuses और pluses हैं और आप सार्वभौमिक सलाह नहीं दे सकते।
जावा में सबसे अधिक उपयोग किए जाने वाले ठीक-ठीक ताले और गैर-अवरुद्ध एल्गोरिदम का संयोजन। क्लॉज्योर में, विपरीत ट्रांसएक्शनल मेमोरी और अपरिवर्तनीय डेटा संरचनाएं हैं। लेन-देन की स्मृति, मेरी राय में, एक आशाजनक उपकरण है (मैं पाठक को स्वतंत्र रूप से कचरा संग्रह के साथ एक सादृश्य आकर्षित करने का सुझाव देता हूं)। मुझे उम्मीद है कि अगली बार जब आप किसी सिस्टम, मॉड्यूल या वर्ग को डिज़ाइन करेंगे, तो आप इस लेख में वर्णित दृष्टिकोणों को याद करेंगे और जो आपको सूट करेगा उसे चुनें।

आपका ध्यान देने के लिए धन्यवाद। आपकी टिप्पणियों और सुझावों की प्रतीक्षा है।