ArrayBlockingQueue V.S. LinkedBlockingQueue

最近看《分布式JAVA应用 基础与实践》 里面有一段话
林昊 写道
ArrayBlockingQueue为一个固定大小数组、ReentrantLock以及Condition实现的可阻塞的先进先出的Queue。

除ArrayBlockingQueue之外，BlockingQueue的实现还有LinkedBlockingQueue，LinkedBlockingQueue实现的不同为采用对象的next构成链表的方式存储对象。由于读只操作对头，而写只操作队尾，这里巧妙地采用了两把锁，对于put和offer采用一把锁，对于take和poll则采用另外一把锁，避免了读写时互相竞争锁的情况，因此LinkedBlockingQueue在高并发读写操作都多的情况下，性能会较ArrayBlockingQueue好很多，在遍历以及删除元素则要两把锁都锁住。

乍一看，ArrayBlockingQueue怎么都不如LinkedBlockingQueue性能强大，那ArrayBlockingQueue存在的意义是什么呢？带着这个疑问，自己亲身写了个程序，4个生产者总共生产4* 102,4000*10个产品，4个消费者去消费，队列的最大大小是102,4000，队列分别采用ArrayBQ和LinkedBQ，对比2者消耗时间。（读者可以直接运行该程序得出对比结果)。


Java代码 收藏代码
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;

public class ArrayBlockingQueueVsLinkedBlockingQueue {
//队列最大容量
public static final int Q_SIZE = 1024000;
//生产者/消费者线程数
public static final int THREAD_NUM = 4;

//产品
class Product{
String name;
Product(String name){
this.name = name;
}
}
public void test(final BlockingQueue<Product> q) throws InterruptedException{
//生产者线程
class Producer implements Runnable{
@Override
public void run() {
for(int i=0;i<Q_SIZE*10;i++){
try {
q.put(new Product("Lee"));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

};
//消费者线程
class Consumer implements Runnable{
@Override
public void run(){
for(int i=0;i<Q_SIZE*10;i++){
try {
q.take();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
};
//创建生产者
Thread[] arrProducerThread = new Thread[THREAD_NUM];
for(int i=0;i<THREAD_NUM;i++){
arrProducerThread[i] = new Thread(new Producer());
}
//创建消费者
Thread[] arrConsumerThread = new Thread[THREAD_NUM];
for(int i=0;i<THREAD_NUM;i++){
arrConsumerThread[i] = new Thread(new Consumer());
}
//go!
long t1 = System.currentTimeMillis();
for(int i=0;i<THREAD_NUM;i++){
arrProducerThread[i].start();
arrConsumerThread[i].start();
}
for(int i=0;i<THREAD_NUM;i++){
arrProducerThread[i].join();
arrConsumerThread[i].join();
}
long t2 = System.currentTimeMillis();
System.out.println(q.getClass().getSimpleName() + " cost : " + (t2-t1));
}
public static void main(String[] args) throws InterruptedException{
final BlockingQueue<Product> q1 = new LinkedBlockingQueue<Product>(Q_SIZE);
final BlockingQueue<Product> q2 = new ArrayBlockingQueue<Product>(Q_SIZE);
new ArrayBlockingQueueVsLinkedBlockingQueue().test(q1);
new ArrayBlockingQueueVsLinkedBlockingQueue().test(q2);
}
}



结果令人我意外，ArrayBQ耗时只有LinkedBQ的一半！而且运行的时候ArrayBQ没占满CPU，LinkedBQ却一直占满！


(我的机器 JDK1.6 win7_64 -Xms1024M -Xmx1024M)


(群友的机器)
我这就不懂了，锁竞争更小的LinkedBQ输给了ArrayBQ。。。难道是线程不够多？
于是我把参数改成以下
Java代码 收藏代码
//队列最大容量
public static final int Q_SIZE = 10240;
//生产者/消费者线程数
public static final int THREAD_NUM = 1280;

结果还是ArrayBQ更快。。。

各位技术的朋友，这究竟解释？如果您知道为什么，请务必留言告知鄙人！

我现在唯一的想到的是，LinkedQueue需要建立Node，而且增删时引用的操作比ArrayBQ复杂。ArrayBQ的内部的数组在增删时并不会产生复制的操作，而是当作一个环，增删只会改变putIndex和takeIndex，操作非常简单。