जावा दो धागे के बीच एक चर साझा करें

Question

मेरे पास दो धागे हैं। एक वर्ग की अद्यतन विधि को आमंत्रित करता है जो एक चर को संशोधित करता है। दूसरा एक वर्ग की अद्यतन विधि को आमंत्रित करता है जो चर को पढ़ता है। केवल एक धागा लिखता है और एक (या अधिक) धागे उस चर को पढ़ते हैं। समेकन के मामले में मुझे क्या करने की ज़रूरत है, क्योंकि मैं बहु-थ्रेडिंग के लिए नया हूं?

public class A 
{ 
    public int variable; // Does this need to be volatile? 
     // Not only int, could also be boolean or float. 
    public void update() 
    { 
     // Called by one thread constantly 
     ++variable; 
     // Or some other algorithm 
     variable = complexAlgorithm(); 
    } 
} 

public class B 
{ 
    public A a; 
    public void update() 
    { 
     // Called by another thread constantly 
     // I don't care about missing an update 
     int v = a.variable; 
     // Do algorithm with v... 
    } 
} 

धन्यवाद,

Answer 1

यदि कोई और केवल एक धागा है जो variable पर लिखता है तो आप इसे volatile बनाने से दूर हो सकते हैं। अन्यथा AtomicInteger के साथ उत्तर देखें।

केवल volatile केवल एक लेखन धागे के मामले में काम करेगा क्योंकि केवल एक लेखन धागा है इसलिए यह हमेशा variable का सही मूल्य है।

Answer 2

इतना ही नहीं variablevolatile होना चाहिए, लेकिन आप भी ++variable के बाद से some sort of synchronization के साथ अपने update समारोह की रक्षा करना चाहते हैं एक परमाणु कॉल नहीं है। यह सब के बाद,

variable = variable + 1; 

variable = variable + 1; 

पर केवल वाक्य रचनात्मक चीनी है जो परमाणु नहीं है।

आपको किसी भी प्रकार के lock में चर पढ़ने वाले किसी भी कॉल को भी लपेटना चाहिए।

वैकल्पिक रूप से, AtomicInteger का उपयोग करें। यह इस तरह की चीज के लिए बनाया गया था (केवल पूर्णांक परिचालन के लिए)।

public class A 
{ 
    // initially had said volatile wouldn't affect this variable because 
    // it is not a primitive, but see correction in comments 
    public final AtomicInteger variable; // see comments on this issue of why final 
    public void update() 
    { 
     // Called by one thread constantly 
     variable.getAndIncrement(); // atomically adds one 
    } 
    public int retrieveValue() 
    { 
     return variable.get(); // gets the current int value safely 
    } 
} 

public class B 
{ 
    public A a; 
    public void update() 
    { 
     // Called by another thread constantly 
     int v = a.retrieveValue(); 
     // Do algorithm with v... 
    } 
} 

अधिक जटिल एल्गोरिदम के लिए, जैसा कि आपका हालिया संपादन मानता है, सिंक्रनाइज़ेशन या ताले का उपयोग करें।

Answer 3

इस मामले में मैं AtomicInteger का उपयोग करूंगा, हालांकि सामान्यीकृत उत्तर यह है कि परिवर्तनीय तक पहुंच को सिंक्रनाइज़ किए गए ब्लॉक द्वारा संरक्षित किया जाना चाहिए, या java.util.concurrent पैकेज के किसी अन्य भाग का उपयोग करके।

उदाहरण के एक जोड़े:

सिंक्रनाइज़ का उपयोग कर

public class A { 
    public final Object variable; 
    public void update() { 
     synchronized(variable) { 
      variable.complexAlgorithm(); 
     } 
    } 
} 

public class B { 
    public A a; 
    public void update() { 
     sychronized(a.variable) { 
      consume(a.variable); 
     } 
    } 
} 

पहुँच java.util.concurrent

public class A { 
    public final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); 
    public final Object variable; 
    public void update() { 
     lock.writeLock().lock(); 
     try { 
      variable.complexAlgorithm(); 
     } finally { 
      lock.writeLock().unlock(); 
     } 
    } 
} 

public class B { 
    public A a; 
    public void update() { 
     a.lock.readLock().lock(); 
     try { 
      consume(a.variable); 
     } finally { 
      a.lock.readLock().unlock(); 
     } 
    } 
} 

Answer 4

का उपयोग उपयोग AtomicInteger या synchronize सुरक्षित है।