ArrayBlockingQueue 和 add vs put vs capacity

Question

来自ArrayBlockingQueueArrayBlockingQueue的Javadoc：

添加

公共布尔加法(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.

我一直将这句话（if it is possible to do so immediattely）解释如下：

如果队列有空闲容量，则插入将成功。如果没有空白空间，则不会成功。

但我的理解在这里是错误的。

在一个简单的例子中，我决定使用ArrayBlockingQueue，例如20 个元素（小队列）并有一个线程在做：

queue.take()

尽管队列几乎是空的，但另一个线程没有通过add 方法将元素添加到队列中。

我也通过调试验证了它。

一旦我将queue.add(element) 的调用替换为queue.put(element)，该元素确实已添加到队列中。

那么这些方法有什么不同呢？

还有什么其他原因（除了容量）不能添加？

---

更新：

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 只是 String 值的持有者。

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

消费者：

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

如果我使用add，则不会引发异常，但不会将元素添加到队列中。

只是一个想法：也许由于消费者正在队列中“等待”，如果某些内部管家无法添加元素，则不会添加它并且不会引发异常。可能是这种情况。

否则我无法理解为什么没有异常并且使用put 代码有效。

put 和 add 的使用方式是否不同？

Answer 1

其实很简单：

• 如果队列未满，两种方法都成功；
• 如果队列已满，add() 将失败并出现异常，而 put() 会阻塞。

我认为上面的文档很清楚。如果您不同意，并且想要第二个意见，您可以查看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

调试问题的一个更重要的部分是编写一个测试用例，以确保您认为正在发生的事情确实正在发生。这要么证明要么反驳你的理论。

下面的测试用例表明您使用的方法的行为与文档（您引用的）完全一致：

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

}