जावा में किसी ईवेंट की प्रतीक्षा करना - यह कितना मुश्किल है?

Question

मेरे पास एक थ्रेड है जो समय-समय पर इसकी स्थिति अपडेट करता है और मैं चाहता हूं कि दूसरा थ्रेड पहले थ्रेड के लिए इंतजार कर सके। कुछ इस तरह:

Thread 1: 
    while(true) { 
     ...do something... 
     foo.notifyAll() 
     ...wait for some condition that might never happen... 
     ... 
    } 

Thread 2: 
    ... 
    foo.wait(); 
    ... 

अब इस अच्छा लग रहा है और सभी जब तक थ्रेड 1 के notifyAll() धागा 2 के इंतजार(), से पहले चलाता है जो मामले थ्रेड में जब तक 2 प्रतीक्षा करता थ्रेड 1 अधिसूचित फिर (कभी नहीं हो सकता है) ।

मेरे संभव समाधान:

एक) मैं एक CountDownLatch या एक भविष्य इस्तेमाल कर सकते हैं, लेकिन दोनों समस्या यह है कि वे स्वाभाविक केवल एक बारचलाने की है। यही है, थ्रेड 1 के दौरान लूप में, मुझे प्रत्येक बार प्रतीक्षा करने के लिए एक नया फू बनाने की आवश्यकता होगी और थ्रेड 2 को यह पूछने की आवश्यकता होगी कि किस फू का इंतजार है। के रूप में मुझे डर है कि foo = नए FutureTask() में, क्या होता है जब किसी को, के लिए "किसी कारण" (वर्ष foo के लिए इंतजार कर रहे थे सेट आमंत्रित नहीं किया गया मैं बस

while(true) { 
    foo = new FutureTask(); 
    ... 
    foo.set(...); 
    ...wait for a condition that might never be set... 
    ... 
} 

लिखने के बारे में बुरा विचार है, जैसे एक अपवाद हैंडलिंग में बग)?

ख) या मैं एक सेमाफोर इस्तेमाल कर सकते हैं:

class Event { 
    Semaphore sem; 
    Event() { sem = new Semaphore(1); sem . } 
    void signal() { sem.release(); } 
    void reset() { sem.acquire(1); } 
    void wait() { if (sem.tryAcquire(1)) { sem.release(); } } 
} 

लेकिन मुझे डर है, कुछ रेस स्थिति है कि वहाँ एक से अधिक थ्रेड प्रतीक्षा() इसके लिए ing कर रहे हैं, जबकि एक अन्य एक संकेत() और रीसेट () रों।

प्रश्न:

वहाँ जावा एपीआई कि Windows ईवेंट व्यवहार जैसा दिखता में कुछ भी नहीं है? या, यदि आप विंडोज़ को तुच्छ मानते हैं, तो गोलांग के वेट ग्रुप जैसे कुछ (यानी एक काउंटरडाउनलैच जो countUp() को अनुमति देता है)? कुछ भी?

मैन्युअल रूप से ऐसा करने के लिए:

थ्रेड 2 बस नकली Wakeup की वजह से इंतजार नहीं कर सकता और जावा में कोई रास्ता नहीं है पता करने के लिए क्यों Object.wait() लौट आए है। तो मुझे एक शर्त चर की आवश्यकता है जो स्टोर करता है कि घटना संकेतित है या नहीं। थ्रेड 2:

synchronized(foo) { 
    while(!condition) { 
     foo.wait(); 
    } 
} 

और पाठ्यक्रम का थ्रेड 1 सिंक्रनाइज़ किए गए ब्लॉक में सही स्थिति को सेट करता है। संकेत के लिए सप्ताहांत के लिए धन्यवाद!

क्या कोई मौजूदा वर्ग है जो उस व्यवहार को लपेटता है?

या मुझे कोड को कॉपी और पेस्ट करने की आवश्यकता है?

Answer 1

सूचना देने पर कुछ राज्य बदलने के लिए मानक अभ्यास है और प्रतीक्षा करते समय कुछ राज्य जांचने के लिए()।

उदा।

boolean ready = false; 

// thread 1 
synchronized(lock) { 
    ready = true; 
    lock.notifyAll(); 
} 


// thread 2 
synchronized(lock) { 
    while(!ready) 
     lock.wait(); 
} 

इस दृष्टिकोण के साथ, इससे कोई फर्क नहीं पड़ता कि थ्रेड 1 या थ्रेड 2 पहले लॉक प्राप्त करता है या नहीं।

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

Answer 2

सबसे आसान तरीका सिर्फ

firstThread.join();

यह जब तक पहले धागा समाप्त होता है अवरुद्ध हो जाएगा कहने के लिए है।

लेकिन आप प्रतीक्षा/अधिसूचना का उपयोग करके इसे लागू कर सकते हैं। दुर्भाग्यवश आपने अपने असली कोड टुकड़े पोस्ट नहीं किए हैं, लेकिन मुझे लगता है कि यदि आप सूचित करते हैं तो प्रतीक्षा बाहर नहीं निकलती है, ऐसा इसलिए होता है क्योंकि आपने synchronized ब्लॉक दोनों में नहीं रखा है। ध्यान दें कि synchronized ब्लॉक का "तर्क" जोड़ी को प्रतीक्षा/सूचित करने के लिए समान होना चाहिए।

Answer 3

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

synchronized(syncObject) { 
    while(condition.isTrue()) { 
     syncObject.wait(WAIT_TIMEOUT); 
    } 
} 

(अपने थ्रेड 2 में)

संपादित करें: ले जाया गया पाश बाहर सिंक्रनाइज़।

Answer 4

मैं दो धागे के बीच BlockingQueue का उपयोग करता हूं। का उपयोग करते हुए wait और notify 5 मिनट पहले इतना है;)

enum Event { 
    Event, 
    Stop; 
} 

BlockingQueue<Event> queue = new LinkedBlockingQueue<Event>(); 

// Thread 1 
try { 
    while(true) { 
    ...do something... 
    queue.put(Event.Event); 
    ...wait for some condition that might never happen... 
    ... 
    } 
} finally { 
    // Tell other thread we've finished. 
    queue.put(Event.Stop}; 
} 

// Thread 2 
... 
switch (queue.take()) { 
    case Event: 
     ... 
     break; 

    default: 
     ... 
     break; 
}