ArrayBlockingQueue và thêm vs đặt vs công suất

Question

Từ Javadoc của ArrayBlockingQueueArrayBlockingQueue:

thêm

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. 

Tôi luôn interpretted tuyên bố này (một phần if it is possible to do so immediattely) như sau:

Nếu hàng đợi có dung lượng miễn phí, khi đó chèn sẽ thành công. Nếu không có không gian trống thì nó sẽ không thành công.

Nhưng sự hiểu biết của tôi sai ở đây.

Trong trường hợp đơn giản, tôi quyết định sử dụng số ArrayBlockingQueue cho ví dụ: 20 yếu tố (hàng đợi nhỏ) và có một thread thực hiện:

queue.take()

thread khác không thêm một yếu tố để xếp hàng thông qua phương thức add mặc dù hàng đợi đã gần như trống rỗng.

Tôi đã xác minh nó cũng thông qua gỡ lỗi.

Khi tôi đã thay thế cuộc gọi queue.add(element) thành queue.put(element) yếu tố này thực sự đã được thêm vào hàng đợi.

Vậy các phương pháp này khác nhau như thế nào?

Vì lý do nào khác (ngoài năng lực), việc bổ sung có thể xảy ra không?

---

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 chỉ là một người giữ cho các giá trị String.

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

Và người tiêu dùng:

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

Nếu tôi sử dụng add không phải ngoại lệ được ném nhưng yếu tố không được thêm vào hàng đợi.

Chỉ cần suy nghĩ: có lẽ vì người tiêu dùng đang "chờ" trên hàng đợi, nếu đối với một số dịch vụ vệ sinh nội bộ thì không thể thêm phần tử đó vào nó và không có ngoại lệ nào được ném.

Nếu không, tôi không thể hiểu tại sao không có ngoại lệ và với mã put hoạt động.

Có phải put và add có nghĩa là được sử dụng khác nhau?

Answer 1

Nó khá đơn giản thực sự:

• nếu hàng đợi là không đầy đủ, cả hai phương pháp thành công;
• nếu hàng đợi đầy, add() không thành công với ngoại lệ trong khi put() khối.

Tôi nghĩ tài liệu này khá rõ ràng ở trên. Nếu bạn không đồng ý, và muốn có một ý kiến ​​thứ hai, bạn có thể kiểm tra mã nguồn cho 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

Một trong những phần quan trọng hơn của gỡ một vấn đề được viết một trường hợp thử nghiệm để đảm bảo những gì bạn nghĩ đang xảy ra thực sự xảy ra. Điều này chứng minh hoặc bác bỏ lý thuyết của bạn.

Các trường hợp thử nghiệm dưới đây cho thấy những phương pháp bạn đang sử dụng cư xử chính xác như các tài liệu (mà bạn trích dẫn) khẳng định:

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

}