सी अलग-अलग धागे के बीच एक चर

Question

मैं इस तरह से अधिक थ्रेड के बीच एक चर साझा करना चाहते हैं साझा करना:

boolean flag = true; 
T1 main = new T1(); 
T2 help = new T2(); 
main.start(); 
help.start(); 

मैं मुख्य और मदद धागा जहां इन दो अलग अलग जावा वर्गों मैं कर रहे हैं के बीच flag साझा करना चाहते हैं बनाया है ऐसा करने का कोई तरीका है? धन्यवाद!

Answer 1

T1 और T2 दोनों इस चर वाले वर्ग को संदर्भित कर सकते हैं। इसके बाद आप इस चर अस्थिर बना सकते हैं, और इसका मतलब है कि उस चर में परिवर्तन दोनों धागे में immeditately दिखाई दे रहे हैं।

अधिक जानकारी के लिए this article देखें।

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

और अस्थिर बनाम राज्य के साझा करने के अधिक जटिल साधनों का उपयोग करने के पेशेवरों/विपक्ष को नोट करें।

Answer 2

1. इसे स्थिर बनाना इस समस्या को ठीक कर सकता है।
2. अन्य सूत्र में मुख्य थ्रेड पर संदर्भ और उस चर दिखाई

Answer 3

यह T1 के उदाहरण और के बीच दृश्यमान बनाने के लिए कर रही है T2 आप कर सकते हैं दो वर्गों एक वस्तु है कि चर शामिल करने के लिए एक संदर्भ के होते हैं।

यदि थ्रेड चलने पर चर को संशोधित किया जाना है, तो आपको सिंक्रनाइज़ेशन पर विचार करना होगा। सबसे अच्छा तरीका आपकी सटीक आवश्यकताओं पर निर्भर करता है, लेकिन मुख्य विकल्प इस प्रकार हैं:

• परिवर्तनीय volatile;
• इसे AtomicBoolean में बदलें;
• इसका उपयोग करने वाले कोड के चारों ओर पूर्ण उड़ा सिंक्रनाइज़ेशन का उपयोग करें।

Answer 4

अन्य सुझावों के अलावा - आप भी एक नियंत्रण कक्षा में झंडा लपेट कर अपने माता पिता के वर्ग में इसके बारे में एक अंतिम उदाहरण बना सकते हैं:

public class Test { 
    class Control { 
    public volatile boolean flag = false; 
    } 
    final Control control = new Control(); 

    class T1 implements Runnable { 
    @Override 
    public void run() { 
     while (!control.flag) { 

     } 
    } 
    } 

    class T2 implements Runnable { 
    @Override 
    public void run() { 
     while (!control.flag) { 

     } 
    } 
    } 

    private void test() { 
    T1 main = new T1(); 
    T2 help = new T2(); 

    new Thread(main).start(); 
    new Thread(help).start(); 
    } 

    public static void main(String[] args) throws InterruptedException { 
    try { 
     Test test = new Test(); 
     test.test(); 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
    } 
} 

Answer 5

आप लॉक चर का उपयोग कर सकते हैं "एक" और "बी" और रिवर्स ऑर्डर में "महत्वपूर्ण खंड" को लॉक करने के लिए उन्हें सिंक्रनाइज़ करें। उदाहरण के लिए। "ए" को सूचित करें, फिर "बी", "प्रिंट" लॉक करें, "बी" को सूचित करें, फिर "ए" लॉक करें।

कोड नीचे देखें: -

public class EvenOdd { 

static int a = 0; 

public static void main(String[] args) { 

    EvenOdd eo = new EvenOdd(); 

    A aobj = eo.new A(); 
    B bobj = eo.new B(); 

    aobj.a = Lock.lock1; 
    aobj.b = Lock.lock2; 

    bobj.a = Lock.lock2; 
    bobj.b = Lock.lock1; 

    Thread t1 = new Thread(aobj); 
    Thread t2 = new Thread(bobj); 

    t1.start(); 
    t2.start(); 

} 

static class Lock { 
    final static Object lock1 = new Object(); 
    final static Object lock2 = new Object(); 
} 

class A implements Runnable { 

    Object a; 
    Object b; 

    public void run() { 
     while (EvenOdd.a < 10) { 
      try { 
       System.out.println(++EvenOdd.a + " A "); 
       synchronized (a) { 
        a.notify(); 
       } 
       synchronized (b) { 
        b.wait(); 
       } 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 

     } 
    } 
} 

class B implements Runnable { 

    Object a; 
    Object b; 

    public void run() { 
     while (EvenOdd.a < 10) { 

      try { 
       synchronized (b) { 
        b.wait(); 
        System.out.println(++EvenOdd.a + " B "); 
       } 
       synchronized (a) { 
        a.notify(); 
       } 
      } catch (InterruptedException e) { 
       e.printStackTrace(); 
      } 

     } 
    } 
} 

}

आउटपुट: - 1 एक 2 बी 3 एक 4 बी 5 एक 6 बी 8 बी 9 ए 10 बी