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者消耗时间。（读者可以直接运行该程序得出对比结果)。

 

 

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。。。难道是线程不够多？
于是我把参数改成以下

//队列最大容量
public static final int Q_SIZE = 10240;
//生产者/消费者线程数
public static final int THREAD_NUM = 1280;

 
结果还是ArrayBQ更快。。。

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

 

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