लचीला CountDownLatch?

Question

मुझे अब दो बार एक समस्या का सामना करना पड़ा है जिससे निर्माता निर्माता थ्रेड एन कार्य आइटम उत्पन्न करता है, उन्हें ExecutorService पर सबमिट करता है और फिर सभी एन आइटम संसाधित होने तक प्रतीक्षा करने की आवश्यकता होती है।

चेतावनियां

• एन अग्रिम में ज्ञात नहीं है। अगर ऐसा होता तो मैं बस CountDownLatch बनाउंगा और उसके बाद निर्माता थ्रेड await() होगा जब तक कि सभी काम पूरा नहीं हो जाते।
• का उपयोग करते हुए एक CompletionService अनुचित है क्योंकि ऐसा होने पर मेरा निर्माता धागा ब्लॉक करने के लिए की जरूरत है (अर्थात take() फोन करके) संकेत सब काम पूरा है कि का कोई रास्ता नहीं है, इंतज़ार कर बंद करने के लिए निर्माता धागा पैदा करने के लिए।

मेरे वर्तमान इष्ट समाधान एक पूर्णांक काउंटर का उपयोग करना है, और वेतन वृद्धि को यह जब भी काम के एक आइटम प्रस्तुत और घटती है यह जब एक काम मद संसाधित किया जाता है। सभी एन कार्यों के सबमिशन के बाद मेरे निर्माता थ्रेड को लॉक पर इंतजार करना होगा, यह जांच कर लें कि counter == 0 चाहे इसे अधिसूचित किया गया हो। उपभोक्ता धागा (रों) अगर यह काउंटर कम कर दिया है और नया मान 0.

इस समस्या का एक बेहतर दृष्टिकोण है है या वहाँ java.util.concurrent में एक उपयुक्त निर्माण मैं नहीं बल्कि का उपयोग करना चाहिए है निर्माता को सूचित करने की आवश्यकता होगी "अपना खुद का रोलिंग" से?

अग्रिम धन्यवाद।

Answer 1

java.util.concurrent.Phaser ऐसा लगता है कि यह आपके लिए अच्छा काम करेगा। यह जावा 7 में रिलीज होने की योजना है लेकिन सबसे स्थिर संस्करण jsr166 की रुचि समूह वेबसाइट पर पाया जा सकता है।

फ़ेज़र एक गौरवशाली चक्रीय बैरियर है। आप एन पार्टियों को पंजीकृत कर सकते हैं और जब आप तैयार हो जाते हैं तो विशिष्ट चरण में उनकी अग्रिम प्रतीक्षा करें।

कि यह कैसे काम करेगा पर एक त्वरित उदाहरण:

final Phaser phaser = new Phaser(); 

public Runnable getRunnable(){ 
    return new Runnable(){ 
     public void run(){ 
      ..do stuff... 
      phaser.arriveAndDeregister(); 
     } 
    }; 
} 
public void doWork(){ 
    phaser.register();//register self 
    for(int i=0 ; i < N; i++){ 
     phaser.register(); // register this task prior to execution 
     executor.submit(getRunnable()); 
    } 
    phaser.arriveAndAwaitAdvance(); 
} 

Answer 2

आप निश्चित रूप से एक CountDownLatch तो एक AtomicReference द्वारा संरक्षित इस्तेमाल कर सकते हैं कि अपने कार्यों को इस प्रकार लिपटे हो:

public class MyTask extends Runnable { 
    private final Runnable r; 
    public MyTask(Runnable r, AtomicReference<CountDownLatch> l) { this.r = r; } 

    public void run() { 
     r.run(); 
     while (l.get() == null) Thread.sleep(1000L); //handle Interrupted 
     l.get().countDown(); 
    } 
} 

सूचना कि कार्य अपने काम चलाने के लिए और उसके बाद स्पिन तक गिनती देने वाला है, सेट (यानी कार्यों की कुल संख्या पता है)। जैसे ही गिनती सेट हो जाती है, वे इसे नीचे गिनते हैं और बाहर निकलते हैं। ये इस प्रकार प्रस्तुत हो:

AtomicReference<CountDownLatch> l = new AtomicReference<CountDownLatch>(); 
executor.submit(new MyTask(r, l)); 

अपने काम, के निर्माण/प्रस्तुत करने की बात है जब आप जानते हैं कि कैसे कई कार्यों आप बनाया है के बाद:

latch.set(new CountDownLatch(nTasks)); 
latch.get().await(); 

Answer 3

मुझे लगता है अपने निर्माता करता है कतार खाली होने पर जानने की आवश्यकता नहीं है, लेकिन आखिरी कार्य पूरा होने पर यह जानने की जरूरत है।

मैं उपभोक्ता को waitforWorkDone(producer) विधि जोड़ दूंगा। निर्माता अपने एन कार्यों को जोड़ सकता है और प्रतीक्षा विधि को कॉल कर सकता है। प्रतीक्षा विधि आने वाली थ्रेड को अवरुद्ध करती है अगर काम कतार खाली नहीं है और इस समय कोई कार्य निष्पादित नहीं हो रहा है।

उपभोक्ता धागे notifyAll() वेटोर लॉक iff पर अपना कार्य पूरा हो गया है, कतार खाली है और कोई अन्य कार्य निष्पादित नहीं किया जा रहा है।

Answer 4

मैं कुछ इस तरह के लिए एक ExecutorCompletionService उपयोग किया है:

ExecutorCompletionService executor = ...; 
int count = 0; 
while (...) { 
    executor.submit(new Processor()); 
    count++; 
} 

//Now, pull the futures out of the queue: 
for (int i = 0; i < count; i++) { 
    executor.take().get(); 
} 

यह कार्य, प्रस्तुत किया गया है, इसलिए यदि आपकी सूची मनमाने ढंग से लंबी है की एक कतार रखने शामिल है, अपने विधि बेहतर हो सकता है।

लेकिन समन्वय के लिए AtomicInteger का उपयोग करना सुनिश्चित करें, ताकि आप इसे एक थ्रेड में बढ़ा सकें और कार्यकर्ता धागे में इसे कम कर सकें।

Answer 5

आप माना जाता है इस एक:

https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ExecutorService.html#invokeAll(java.util.Collection)

यहाँ एक उदाहरण मैं ने लिखा है: https://github.com/moulaali/java_fun/blob/master/src/WaitForAllConcurrencyExample.java

Answer 6

क्या आप वर्णित एक मानक सेमफोर का उपयोग करने के समान है लेकिन 'पिछड़ा' इस्तेमाल किया जाता है।

• आपका सेमाफोर 0 परमिट
• प्रत्येक काम इकाई एक परमिट जारी करता है जब यह
• आप ब्लॉक पूरा करता एन परमिट

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