Take () üzerinde bloke eden bir BlockingQueue nasıl kesilir?

Nesneleri a'dan alan BlockingQueueve onları take()sürekli bir döngüde çağırarak işleyen bir sınıfım var . Bir noktada, kuyruğa başka nesnelerin eklenmeyeceğini biliyorum. take()Engellemeyi durdurması için yöntemi nasıl keserim?

İşte nesneleri işleyen sınıf:

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

Ve işte bu sınıfı nesneleri işlemek için kullanan yöntem:

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

İş parçacığını kesmek bir seçenek değilse, bir diğeri de MyObjHandler tarafından bu şekilde tanınacak ve döngüden çıkacak olan kuyruğa bir "işaret" veya "komut" nesnesi yerleştirmektir.

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

Ancak, bunu yaparsanız, kuyrukta hala işlenmeyi bekleyen öğeler varken iş parçacığı kesintiye uğrayabilir. Bunun pollyerine kullanmayı düşünebilirsiniz take, bu işlem iş parçacığının zaman aşımına uğramasına ve bir süre yeni girdi olmadan beklediğinde sona ermesine izin verecektir.

Çok geç ama umarım bu , benzer problemle karşılaştığım ve yukarıdaki ericksonpoll tarafından önerilen yaklaşımı bazı küçük değişikliklerle kullandığım için başkalarına da yardımcı olur

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

Bu her iki sorunu da çözdü

1. BlockingQueueÖğeleri daha fazla beklememesi gerektiğini bilmesi için işaretlendi
2. İşlem blokları yalnızca kuyruktaki tüm öğeler işlendiğinde ve eklenecek öğe kalmadığında sona ereceği için arada kesintiye uğramadı

İleti dizisini kesin:

thread.interrupt()

Ya da sözünü kesme, iğrenç.

    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. yapımcı kuyruğa nesne koyduğunda, ara queue.notify(), biterse araqueue.done()
2. döngü sırasında (! queue.isDone () ||! queue.isEmpty ())
3. null için test take () dönüş değeri

Ne hakkında

queue.add(new MyObj())

Bazı üretici iş parçacığında, bir durdurma işaretinin tüketici iş parçacığının while döngüsünü bitirmesini işaret ettiği durumlarda?