धागे (जावा)

Question

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

बेशक इस वर्ग को समझने वाली कक्षा को लागू करने में कोई समस्या नहीं है, लेकिन मैं java.util.concurrent (यदि ऐसा तंत्र मौजूद है) से मानक तंत्र का उपयोग करना चाहता हूं। ध्यान दें कि सिंक्रोनस क्यूई एक अच्छा समाधान नहीं है: उपभोक्ता "एस 1" को घेरते समय ब्लॉक करेगा और "एस 2" उत्पादन करने का मौका नहीं मिलेगा।

कोई भी विचार (संक्षेप में, मैं एक एकल तत्व संग्रह के लिए एक अवरुद्ध आपरेशन को हटाने और एक गैर अवरुद्ध सेट संचालन के साथ देख रहा हूँ)?

Answer 1

मुझे लगता है कि अपने सबसे अच्छे जवाब शायद ArrayBlockingQueue, जहां निर्माता (आप केवल है उपयोग करने के लिए है एक निर्माता, सही?) नया तत्व जोड़ने से पहले किसी भी मौजूदा तत्व को हटा देता है।

निश्चित रूप से, इस कार्यान्वयन में दौड़ की स्थिति है: उपभोक्ता इसे हटाए जाने से ठीक पहले तत्व को संसाधित करना शुरू कर सकता है। लेकिन उन दौड़ की स्थिति हमेशा मौजूद रहेगी, इससे कोई फर्क नहीं पड़ता कि आप किस डेटा संरचना का उपयोग करते हैं।

Answer 2

आप उस के लिए आकार एक की एक सरणी इस्तेमाल कर सकते हैं:

String[] oeq = new String[1]; 

नमूना स्रोत:

public class Test { 
    private static final String[] oeq = new String[1]; 
    public static void main(String[] args) { 
     (new Producer()).start(); 
     (new Consumer()).start(); 
     (new Consumer()).start(); 
     (new Consumer()).start(); 
     (new Consumer()).start(); 
     (new Consumer()).start(); 
     (new Consumer()).start(); 
    } 

    private static class Producer extends Thread { 
     public void run() { 
      int i=0; 
      while(true) { 
       i++; 
       synchronized(oeq) { 
        oeq[0] = ""+i; 
        oeq.notifyAll(); 
       } 
      } 
     } 
    } 

    private static class Consumer extends Thread { 
     public void run() { 
      String workload = null; 
      while(true) { 
       synchronized(oeq) { 
        try { 
         oeq.wait(); 
        } catch(InterruptedException ie) { 
         ie.printStackTrace(); 
        } 
        if(oeq[0] != null) { 
         workload = oeq[0]; 
         oeq[0] = null; 
        } 
       } 
       if(workload != null) { 
        System.out.println(workload); 
       } 
      } 
     } 
    } 
} 

Answer 3

Exchanger कक्षा के बारे में क्या? धागे के बीच वस्तुओं का आदान-प्रदान करने का यह मानक तरीका है। इसे अपनी कक्षा के साथ विशेषज्ञ बनाएं, तारों की एक सूची हो सकती है। उपभोक्ता को केवल पहले/आखिरी का उपयोग करें।

Answer 4

ठीक है, अगर आप केवल हाल ही में उत्पादित स्ट्रिंग चाहते हैं, तो आपको कतार की आवश्यकता नहीं है - आपको केवल एक स्ट्रिंग संदर्भ चाहिए: निर्माता इसे सेट करता है, उपभोक्ता इसे पढ़ता है। यदि उपभोक्ता इसे पढ़ने के लिए इतना लंबा समय लेता है कि निर्माता इसे फिर से सेट करता है ... तो क्या?

संदर्भों को सेट करना और पढ़ना परमाणु हैं। एकमात्र मुद्दा यह है कि यदि आप उपभोक्ता को किसी भी तरह सूचित करना चाहते हैं कि एक स्ट्रिंग उपलब्ध है। लेकिन तब भी ... यदि उपभोक्ता कुछ ऐसा कर रहा है जो थोड़ी देर लेता है, तो आपको वास्तव में समवर्ती पुस्तकालयों से किसी भी फैंसी-पैंट सामान की आवश्यकता नहीं होती है।

नोट, बीटीडब्ल्यू, यह उदाहरण किसी भी निर्माता और/या उपभोक्ता धागे के साथ काम करता है।

import java.util.Random; 

public class Example { 
    public static void main(String[] av) { 
     new Example().go(); 
    } 

    Object mutex  = new Object(); 
    String theString = null; 

    void go() { 
     Runnable producer = new Runnable() { 
      public void run() { 
       Random rnd = new Random(); 
       try { 
        for (;;) { 
         Thread.sleep(rnd.nextInt(10000)); 
         synchronized (mutex) { 
          theString = "" + System.currentTimeMillis(); 
          System.out.println("Producer: Setting string to " + theString); 
          mutex.notify(); 
         } 
        } 
       } catch (InterruptedException e) { 
        // TODO Auto-generated catch block 
        e.printStackTrace(); 
       } 

      } 
     }; 

     Runnable consumer = new Runnable() { 
      public void run() { 
       try { 
        String mostRecentValue = null; 
        Random rnd = new Random(); 
        for (;;) { 
         synchronized (mutex) { 
          // we use == because the producer 
          // creates new string 
          // instances 
          if (theString == mostRecentValue) { 
           System.out.println("Consumer: Waiting for new value"); 
           mutex.wait(); 
           System.out.println("Consumer: Producer woke me up!"); 
          } else { 
           System.out.println("Consumer: There's a new value waiting for me"); 
          } 
          mostRecentValue = theString; 
         } 
         System.out.println("Consumer: processing " + mostRecentValue); 
         Thread.sleep(rnd.nextInt(10000)); 
        } 
       } catch (InterruptedException e) { 
        // TODO Auto-generated catch block 
        e.printStackTrace(); 
       } 
      } 
     }; 


     new Thread(producer).start(); 
     new Thread(consumer).start(); 
    } 
}