thread1 से कैसे प्रतीक्षा करें थ्रेड 2

Question

द्वारा अधिसूचित किए जाने तक मैं बहु-थ्रेडिंग के लिए नया हूं और जब मैं बहु थ्रेडिंग के बारे में पढ़ रहा हूं, तो निम्नलिखित करने के लिए इस फैंसी मल्टी-थ्रेडिंग कोड को लिखने का विचार।

मेरी काउंटर क्लास निम्नानुसार है।

class Counter { 
    private int c = 0; 

    public void increment() { 
    System.out.println("increment value: "+c); 
     c++; 
    } 

    public void decrement() { 
     c--; 
     System.out.println("decrement value: "+c); 
    } 

    public int value() { 
     return c; 
    } 

} 

यह काउंटर ऑब्जेक्ट दो धागे के बीच साझा किया जाता है। एक बार थ्रेड शुरू हो जाने के बाद, मुझे निम्न कार्य करने की आवश्यकता है। मैं थ्रेड 2 को तब तक प्रतीक्षा करना चाहता हूं जब तक थ्रेड 1 काउंटर ऑब्जेक्ट की गिनती को 1 द्वारा बढ़ाए जाने के बाद, थ्रेड 1 थ्रेड 2 को सूचित करता है और फिर थ्रेड 1 थ्रेड 2 के लिए 1/ द्वारा मूल्य मान के लिए प्रतीक्षा करना शुरू करता है तो थ्रेड 2 शुरू होता है और घटता है 1 तक और थ्रेड 1 को फिर से सूचित करता है और फिर थ्रेड 2 थ्रेड 1 के लिए प्रतीक्षा करना शुरू कर देता है। इस प्रक्रिया को कुछ बार दोहराएं।

मैं इसे कैसे प्राप्त कर सकता हूं। अग्रिम में बहुत धन्यवाद।

मैंने निम्नलिखित किया है।

public class ConcurrencyExample { 

    private static Counter counter; 
    private static DecrementCount t1; 
    private static IncrementCount t2; 

    public static void main(String[] args) { 
    Counter counter = new Counter(); 
    Thread t1 = new Thread(new IncrementCount(counter)); 
    t1.start(); 

    Thread t2 = new Thread(new DecrementCount(counter)); 
    t2.start(); 

    } 

} 


public class DecrementCount implements Runnable { 

    private static Counter counter; 

    public DecrementCount(Counter counter) { 
    this.counter = counter; 
    } 

    @Override 
    public void run() { 
    for (int i = 0; i < 1000; i++) { 
     counter.decrement();  
     System.out.println("decreamented"); 
    } 
    } 

} 


public class IncrementCount implements Runnable { 

    private static Counter counter; 

    public IncrementCount(Counter counter) { 
    this.counter = counter; 
    } 

    @Override 
    public void run() { 
    for (int i = 0; i < 1000; i++) { 
     counter.increment(); 
     System.out.println("Incremented"); 
    } 

    } 

} 

Answer 1

Semaphore देखें। आपको प्रत्येक थ्रेड के लिए दो, एक की आवश्यकता होगी: incSemaphore और decSemaphore। DecrementCount में कार्य करें:

for (int i = 0; i < 1000; i++) { 
    decSemaphore.acquire(); 
    counter.decrement();  
    System.out.println("decreamented"); 
    incSemaphore.release(); 
} 

संतुलित लागू IncrementCount। incSemaphore का प्रारंभिक मान 1 और 0decSemaphore के लिए होना चाहिए।

BTW अपने Counter रूप में अच्छी तरह तुल्यकालन की आवश्यकता है (synchronized कीवर्ड और AtomicInteger देखें)।

Answer 2

बूलियन ध्वज के साथ Condition का उपयोग करें।

final Lock lock = new ReentrantLock(); 
final Condition incremented= lock.newCondition(); 
final Condition decremented= lock.newCondition(); 

नीचे

स्पष्टीकरण के लिए अपने काउंटर बदलें:

हम दो स्थितियों का इस्तेमाल किया है एक वृद्धि की जाती है और एक कम कर रहा है। बुलियन ध्वज के आधार पर हम जांच करते हैं कि हमें एक शर्त पर इंतजार करना है या नहीं।

class Counter { 
private int c = 0; 
boolean increment = false; 

final Lock lock = new ReentrantLock(); 
final Condition incremented = lock.newCondition(); 
final Condition decremented = lock.newCondition(); 

public void increment() throws InterruptedException { 
    Lock lock = this.lock; 
    lock.lock(); 
    try { 
     while(increment) 
      decremented.await(); 
     increment = true;   
     c++; 
     System.out.println("increment value: " + c); 
     incremented.signal(); 
    } finally { 
     lock.unlock(); 
    } 

} 

public void decrement() throws InterruptedException { 

    Lock lock = this.lock; 
    lock.lock(); 
    try { 
     while (!increment) 
      incremented.await(); 
     c--; 
     System.out.println("decrement value: " + c); 
     increment = false; 
     decremented.signal(); 
    } finally { 
     lock.unlock(); 
    } 
} 

public int value() { 
    Lock lock = this.lock; 
    lock.lock(); 
    try { 
     return c; 
    } finally { 
     lock.unlock(); 
    } 
} 

} 

Answer 3

सिंक्रनाइज़र्स थ्रेड को एक दूसरे के लिए प्रतीक्षा करने में सक्षम बनाता है। CountDownLatch और Semaphore देखें।

See Synchronizers section in the java.util.concurrent package

Answer 4

- सबसे पहले अपने increment() और decrement() स्थिति यह ब्रायन शासन देखें

When we write a variable which has just been read by another thread, or reading a variable which is just lately written by another thread, must be using Synchronization. And those atomic statements/Methods accessing the fields' data must be also synchronized.

synchronized कीवर्ड का उपयोग दौड़ से बचने के लिए किया जाना चाहिए - इसके JVM Thread Scheduler है नियंत्रण कौन सा धागा रनिंग स्टेट में प्रवेश करेगा, यह कितना समय तक रहेगा, और इसके काम के बाद यह कहाँ जाएगा।

- एक Cannot be sure जिनमें से धागा पहले चलेंगे .....

- तुम भी java.util.concurrent से SingleThreadExecutor उपयोग कर सकते हैं, इस दूसरे पर जाने से पहले एक कार्य को पूरा करता।