ArrayBlockingQueue e aggiungere vs put vs capacità

Question

Da Javadoc di ArrayBlockingQueueArrayBlockingQueue:

aggiungere

public boolean add (E e)

Inserts the specified element at the tail of this queue if it is possible 
to do so immediately without exceeding the queue's capacity, returning true 
upon success and throwing an IllegalStateException if this queue is full. 

ho sempre interpretato nel presente comunicato (il parte if it is possible to do so immediattely) come segue:

Se la coda ha capacità libera, l'inserimento avrà esito positivo. Se non c'è spazio vuoto, non ci riuscirà.

Ma la mia comprensione era sbagliata qui.

In un caso semplice ho deciso di utilizzare uno ArrayBlockingQueue per es. 20 elementi (piccola coda) e aventi un filo facendo:

queue.take()

l'altro filo non aggiungere un elemento alla coda tramite il metodo add nonostante la coda era quasi vuoto.

Ho verificato anche tramite debug.

Dopo aver sostituito la chiamata di queue.add(element) a queue.put(element), l'elemento è stato effettivamente aggiunto alla coda.

Quindi cosa c'è di così diverso in questi metodi?

Per quale altro motivo (oltre alla capacità) l'aggiunta non può avvenire?

---

UPDATE:

public class ConnectionListener implements Observer { 

    public static BlockingQueue<ConnectionObject> queueConnections = new ArrayBlockingQueue<ConnectionObject>(10); 

    @Override 
    public void update(Observable arg0, Object arg1) { 
     ConnectionObject con = ((ConnectionObject)arg1); 
     queueConnections.add(con); 
    } 

} 

ConnectionObject è solo un supporto per i valori stringa.

public class ConnectionObject { 
    private String user; 
    private String ip; 
    //etc 
} 

e il consumatore:

public class ConnectionTreeUpdater extends Thread { 
    @Override 
    public void run() { 
    while(true){ 
    try { 
    final ConnectionObject con = ConnectionListener.queueConnections.take(); 

Se uso add non viene generata un'eccezione, ma elemento non viene aggiunto alla coda.

Solo un pensiero: forse in quanto il consumatore è "in attesa" sulla coda, se per qualche servizio di pulizia interna l'elemento non può essere aggiunto che non verranno aggiunti e non fa eccezione è thrown.Could che essere il caso.

Altrimenti non riesco a capire perché non ci siano eccezioni e con put il codice funziona.

Sono put e add destinati a essere utilizzati in modo diverso?

Answer 1

E 'abbastanza semplice, in realtà:

• se la coda non è pieno, entrambi i metodi riescono;
• se la coda è piena, add() non riesce con un'eccezione mentre put() blocchi.

Penso che la documentazione sia abbastanza chiara su quanto sopra. Se non sei d'accordo, e vorrebbe un secondo parere, si potrebbe esaminare il codice sorgente per ArrayBlockingQueue:

public boolean add(E e) { 
    if (offer(e)) 
     return true; 
    else 
     throw new IllegalStateException("Queue full"); 
} 

public boolean offer(E e) { 
    if (e == null) throw new NullPointerException(); 
    final ReentrantLock lock = this.lock; 
    lock.lock(); 
    try { 
     if (count == items.length) 
      return false; 
     else { 
      insert(e); 
      return true; 
     } 
    } finally { 
     lock.unlock(); 
    } 
} 

public void put(E e) throws InterruptedException { 
    if (e == null) throw new NullPointerException(); 
    final E[] items = this.items; 
    final ReentrantLock lock = this.lock; 
    lock.lockInterruptibly(); 
    try { 
     try { 
      while (count == items.length) 
       notFull.await(); 
     } catch (InterruptedException ie) { 
      notFull.signal(); // propagate to non-interrupted thread 
      throw ie; 
     } 
     insert(e); 
    } finally { 
     lock.unlock(); 
    } 
} 

Answer 2

Una delle parti più importanti di debug di un problema è scrivendo un banco di prova per assicurarsi quello che pensi stia accadendo davvero sta succedendo. Questo dimostra o confuta la tua teoria.

Il caso di test che segue indica che i metodi in uso si comportano esattamente come la documentazione (che si citi) afferma:

public static void main(String[] args) { 

    final ArrayBlockingQueue<Integer> myQueue = 
      new ArrayBlockingQueue<Integer>(10); 


    Thread t1 = new Thread(new Runnable() { 

     public void run() 
     { 
      int i = 0; 
      while (true) 
      { 
       try 
       { 
        myQueue.add(i); 
        System.out.println("Added to queue! value: " + 
             i + 
             " size: " + myQueue.size()); 
        i++; 
       } 
       catch (Exception e) 
       { 
        System.out.println("add() threw exception, size: " + 
             myQueue.size()); 
        try 
        { 
         Thread.sleep(1000); 
        } 
        catch (InterruptedException ex) 
        { 
         Logger.getLogger(Main.class.getName()).log(Level.SEVERE, 
                    null, ex); 
        } 
       } 
      } 
     } 

    }); 

    Thread t2 = new Thread(new Runnable() { 

     public void run() 
     { 
      while (true) 
      { 
       try 
       { 
        Integer i = myQueue.take(); 
        System.out.println("Took a off the queue! value: " + 
             i + 
             " size: " + myQueue.size()); 
        Thread.sleep(100); 
       } 
       catch (InterruptedException ex) 
       { 
        Logger.getLogger(Main.class.getName()).log(Level.SEVERE, 
                   null, ex); 
       } 
      } 
     } 
    }); 

    t1.start(); 
    t2.start(); 

}