BlockQueue中ArrayBlockingQueue和LinkedBlockingQueue比较

LinkedBlockingQueue是BlockingQueue的一种使用Link List的实现，它对头和尾（取和添加操作）采用两把不同的锁，相对于ArrayBlockingQueue提高了吞吐量。它也是一种阻塞型的容器，适合于实现“消费者生产者”模式。

ArrayBlockingQueue是对BlockingQueue的一个数组实现，它使用一把全局的锁并行对queue的读写操作，同时使用两个Condition阻塞容量为空时的取操作和容量满时的写操作。

 

正因为LinkedBlockingQueue使用两个独立的锁控制数据同步，所以可以使存取两种操作并行执行，从而提高并发效率。而ArrayBlockingQueue使用一把锁，造成在存取两种操作争抢一把锁，而使得性能相对低下。LinkedBlockingQueue可以不设置队列容量，默认为Integer.MAX_VALUE.其容易造成内存溢出，一般要设置其值。

 LinkedBlockingQueue底层的定义如下：

Java代码  

1. public class ArrayBlockingQueue<E> extends AbstractQueue<E>  
2.         implements BlockingQueue<E>, java.io.Serializable {  
3.   
4.     private void insert(E x) {  
5.         items[putIndex] = x;  
6.         putIndex = inc(putIndex);  
7.         ++count;  
8.         notEmpty.signal();  
9.     }  
10.   
11.     public void put(E o) throws InterruptedException {  
12.         if (o == null) throw new NullPointerException();  
13.         final E[] items = this.items;  
14.         final ReentrantLock lock = this.lock;  
15.         lock.lockInterruptibly();  
16.         try {  
17.             try {  
18.                   // 等待notFull条件  
19.            while (count == items.length)  
20.                     notFull.await();  
21.             } catch (InterruptedException ie) {  
22.                 notFull.signal(); // propagate to non-interrupted thread  
23.                 throw ie;  
24.             }  
25.             insert(o);  
26.         } finally {  
27.             lock.unlock();  
28.         }  
29.     }  
30.   
31.   ...  
32. }  

    注意：ArrayBlockingQueue在读写操作上都需要锁住整个容器，因此吞吐量与一般的实现是相似的，适合于实现“生产者消费者”模式。

 

通过保证在临界区上多个线程的相互排斥，线程间可以完全避免竞争状态的发生，但是有时候还是需要线程之间的相互协作。使用条件（Condition）便于线程间通信。一个线程可以指定在某种条件下该做什么。标间是通过调用Lock对象的newCoditionn（）方法来实现线程之间的相互通信的。

 一旦创建一个条件，就可使用await（）、signal（）、signalAll（）方法来实现线程间通信。await（）方法可以让当前线程都处于等待状态，知道条件放生。signal（）方法唤醒一个等待的线程，而signalAll（）方法唤醒所有等待线程。

注：

Lock接口的 线程请求锁的 几个方法：

lock(), 拿不到lock就不罢休，不然线程就一直block。 比较无赖的做法。
tryLock()，马上返回，拿到lock就返回true，不然返回false。 比较潇洒的做法。
带时间限制的tryLock()，拿不到lock，就等一段时间，超时返回false。比较聪明的做法。

下面的lockInterruptibly()就稍微难理解一些。

先说说线程的打扰机制，每个线程都有一个 打扰 标志。这里分两种情况，
1. 线程在sleep或wait,join， 此时如果别的进程调用此进程的 interrupt（）方法，此线程会被唤醒并被要求处理InterruptedException；(thread在做IO操作时也可能有类似行为，见java thread api)
2. 此线程在运行中， 则不会收到提醒。但是 此线程的 “打扰标志”会被设置， 可以通过isInterrupted()查看并 作出处理。

lockInterruptibly()和上面的第一种情况是一样的， 线程在请求lock并被阻塞时，如果被interrupt，则“此线程会被唤醒并被要求处理InterruptedException”。

 

 

引自：http://zhuhui-zj.iteye.com/blog/784193

BlockQueue中ArrayBlockingQueue和LinkedBlockingQueue比较,布布扣,bubuko.com