Jak przerwać BlockingQueue czyli blocking on take()?

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();

Jednakże, jeśli to zrobisz, wątek może zostać przerwany, gdy w kolejce są jeszcze elementy oczekujące na przetworzenie. Warto rozważyć użycie poll zamiast take, co pozwoli wątkowi przetwarzającemu na timeout i zakończenie, gdy odczekał jakiś czas bez nowego wejścia.

Bardzo późno, ale mam nadzieję, że to pomoże innym, ponieważ spotkałem się z podobnym problemem i zastosowałem podejście poll zasugerowane przez erickson powyżej z niewielkimi zmianami,

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();
}

To rozwiązało oba problemy

1. oznaczył BlockingQueue aby wiedział, że nie musi dłużej czekać na elementy
2. nie przerwano pomiędzy nimi, tak aby bloki przetwarzania kończyły się tylko wtedy, gdy wszystkie elementy w kolejce są przetwarzane i nie ma elementów do wysłania dodano

Przerwij wątek:

thread.interrupt()

Albo nie przerywaj, to paskudne.

    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;
        }
    }

1. gdy producent umieszcza obiekt w kolejce, wywołuje queue.notify(), jeśli się kończy, wywołuje queue.done()
2. pętla while (!KolejkaisDone ()//!KolejkaisEmpty ())
3. test take() Zwraca wartość null