BlockingQueue को कैसे बाधित करें जो टेक () पर रोक रहा है?

Question 1

मेरे पास एक वर्ग है जो वस्तुओं को लेता है BlockingQueueऔर take()एक सतत लूप में कॉल करके उन्हें संसाधित करता है । कुछ बिंदु पर मुझे पता है कि कतार में कोई और ऑब्जेक्ट नहीं जोड़ा जाएगा। मैं take()विधि को कैसे बाधित करूं ताकि यह अवरुद्ध होना बंद हो जाए?

यहाँ वह वर्ग है जो वस्तुओं को संसाधित करता है:

public class MyObjHandler implements Runnable {

  private final BlockingQueue<MyObj> queue;

  public class MyObjHandler(BlockingQueue queue) {
    this.queue = queue;
  }

  public void run() {
    try {
      while (true) {
        MyObj obj = queue.take();
        // process obj here
        // ...
      }
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
  }
}

और यहाँ वह विधि है जो वस्तुओं को संसाधित करने के लिए इस वर्ग का उपयोग करती है:

public void testHandler() {

  BlockingQueue<MyObj> queue = new ArrayBlockingQueue<MyObj>(100);  

  MyObjectHandler  handler = new MyObjectHandler(queue);
  new Thread(handler).start();

  // get objects for handler to process
  for (Iterator<MyObj> i = getMyObjIterator(); i.hasNext(); ) {
    queue.put(i.next());
  }

  // what code should go here to tell the handler
  // to stop waiting for more objects?
}

Question 2

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

Question 3

BlockingQueue<MyObj> queue = new ArrayBlockingQueue<MyObj>(100);
MyObjectHandler handler = new MyObjectHandler(queue);
Thread thread = new Thread(handler);
thread.start();
for (Iterator<MyObj> i = getMyObjIterator(); i.hasNext(); ) {
  queue.put(i.next());
}
thread.interrupt();

हालाँकि, यदि आप ऐसा करते हैं, तो थ्रेड बाधित हो सकता है, जबकि कतार में अभी भी आइटम हैं, संसाधित होने की प्रतीक्षा कर रहे हैं। आप pollइसके बजाय का उपयोग करने पर विचार कर सकते हैं take, जो प्रसंस्करण थ्रेड को टाइमआउट और समाप्त करने की अनुमति देगा जब उसने कुछ नए इनपुट के साथ थोड़ी देर इंतजार किया हो।

Question 4

बहुत देर से लेकिन आशा है कि इससे अन्यों को भी मदद मिलेगी क्योंकि मैंने भी इसी तरह की समस्या का सामना किया था और ऊपर दिएpoll गए दृष्टिकोण का इस्तेमाल कुछ छोटे बदलावों के साथ किया।

class MyObjHandler implements Runnable 
{
    private final BlockingQueue<MyObj> queue;
    public volatile boolean Finished;  //VOLATILE GUARANTEES UPDATED VALUE VISIBLE TO ALL
    public MyObjHandler(BlockingQueue queue) 
    {
        this.queue = queue;
        Finished = false;
    }
    @Override
    public void run() 
    {        
        while (true) 
        {
            try 
            {
                MyObj obj = queue.poll(100, TimeUnit.MILLISECONDS);
                if(obj!= null)//Checking if job is to be processed then processing it first and then checking for return
                {
                    // process obj here
                    // ...
                }
                if(Finished && queue.isEmpty())
                    return;

            } 
            catch (InterruptedException e) 
            {                   
                return;
            }
        }
    }
}

public void testHandler() 
{
    BlockingQueue<MyObj> queue = new ArrayBlockingQueue<MyObj>(100); 

    MyObjHandler  handler = new MyObjHandler(queue);
    new Thread(handler).start();

    // get objects for handler to process
    for (Iterator<MyObj> i = getMyObjIterator(); i.hasNext(); )
    {
        queue.put(i.next());
    }

    // what code should go here to tell the handler to stop waiting for more objects?
    handler.Finished = true; //THIS TELLS HIM
    //If you need you can wait for the termination otherwise remove join
    myThread.join();
}

इससे दोनों समस्याएं हल हो गईं

को हरी झंडी दिखाई BlockingQueue ताकि यह पता कि इसे तत्वों के लिए अधिक इंतजार नहीं करना पड़ा है
बीच में बाधित नहीं हुआ ताकि प्रसंस्करण ब्लॉक केवल तभी समाप्त हो जाएं जब कतार में सभी आइटम संसाधित हो जाएं और कोई आइटम शेष न हों

Question 5

थ्रेड को बाधित करें:

thread.interrupt()

Question 6

या बाधित नहीं है, इसका बुरा।

    public class MyQueue<T> extends ArrayBlockingQueue<T> {

        private static final long serialVersionUID = 1L;
        private boolean done = false;

        public ParserQueue(int capacity) {  super(capacity); }

        public void done() { done = true; }

        public boolean isDone() { return done; }

        /**
         * May return null if producer ends the production after consumer 
         * has entered the element-await state.
         */
        public T take() throws InterruptedException {
            T el;
            while ((el = super.poll()) == null && !done) {
                synchronized (this) {
                    wait();
                }
            }

            return el;
        }
    }

जब निर्माता कतार में वस्तु डालता है queue.notify(), तो कॉल करें , अगर यह समाप्त हो जाए, तो कॉल करेंqueue.done()
लूप जबकि (कतार ।isDone () ||! queue.isEmpty ())
null के लिए test take () रिटर्न वैल्यू

Question 7

क्या एक के बारे में

queue.add(new MyObj())

कुछ प्रोड्यूसर थ्रेड में, जहां एक स्टॉप-फ्लैग उपभोक्ता के धागे को लूप को समाप्त करने का संकेत देता है?