一、基本介绍
ArrayBlcokingQueue,LinkedBlockingQueue是jdk中内置的阻塞队列,网上对它们的分析已经很多,主要有以下几点:
1、底层实现机制不同,ArrayBlcokingQueue是基于数组的,LinkedBlockingQueue是基于链表的;
2、初始化方式不同,ArrayBlcokingQueue是有界的,初始化时必须指定队列的大小;LinkedBlockingQueue可以是无界的,但如果初始化时指定了队列大小,也可以做为有界队列使用;
3、锁机制实现不同,ArrayBlcokingQueue生产和消费使用的是同一把锁,并没有做锁分离;LinkedBlockingQueue中生产、消费分别通过putLock与takeLock保证同步,进行了锁的分离;
使用的过程中,根据应该场景提供了可选插入和删除策略,我们需要掌握和区分
1、插入操作
[
//队列未满时,返回true;队列满则抛出IllegalStateException(“Queue full”)异常
add(e);//队列未满时,直接插入没有返回值;队列满时会阻塞等待,一直等到队列未满时再插入。
put(e);
//队列未满时,返回true;队列满时返回false。非阻塞立即返回。
offer(e);
//设定等待的时间,如果在指定时间内还不能往队列中插入数据则返回false,插入成功返回true。
offer(e, timeout, unit);
[
2、删除操作
[
//队列不为空时,返回队首值并移除;队列为空时抛出NoSuchElementException()异常
remove();
//队列不为空返回队首值并移除;当队列为空时会阻塞等待,一直等到队列不为空时再返回队首值。
queue.take();//队列不为空时返回队首值并移除;队列为空时返回null。非阻塞立即返回。
queue.poll();
//设定等待的时间,如果在指定时间内队列还未孔则返回null,不为空则返回队首值
queue.poll(timeout, unit)
[
Disruptor框架是由LMAX公司开发的一款高效的无锁内存队列。
Disruptor的最大特点就是高性能,它的内部与众不同的使用了环形队列(RingBuffer)来代替普通的线型队列,相比普通队列环形队列不需要针对性的同步head和tail头尾指针,减少了线程协作的复杂度,再加上它本身基于无锁操作的特性,从而可以达到了非常高的性能;
在使用Disruptor框架时,我们需要注意以下几个方面
1、Disruptor的构造
[
/**
*
*
* @param eventFactory 定义的事件工厂
* @param ringBufferSize 环形队列RingBuffer的大小,必须是2的N次方
* @param threadFactory 消费者线程工厂
* @param producerType 生产者线程的设置,当你只有一个生产者线程时设置为 ProducerType.SINGLE,多个生产者线程ProducerType.MULTI
* @param waitStrategy 消费者的等待策略
*/
public Disruptor(
final EventFactory<T> eventFactory,
final int ringBufferSize,
final ThreadFactory threadFactory,
final ProducerType producerType,
final WaitStrategy waitStrategy)
{
this(
RingBuffer.create(producerType, eventFactory, ringBufferSize, waitStrategy),
new BasicExecutor(threadFactory));
}
[
上面的消费者等待策略有以下:
BlockingWaitStrategy: 使用锁和条件变量。CPU资源的占用少,延迟大;
SleepingWaitStrategy: 在多次循环尝试不成功后,选择让出CPU,等待下次调度,多次调度后仍不成功,尝试前睡眠一个纳秒级别的时间再尝试。这种策略平衡了延迟和CPU资源占用,但延迟不均匀。
YieldingWaitStrategy: 在多次循环尝试不成功后,通过Thread.yield()让出CPU,等待下次调度。性能和CPU资源占用上较为平衡,但要注意使用该策略时消费者线程最好小于CPU的核心数
BusySpinWaitStrategy: 性能最高的一种,一直不停的自旋等待,获取资源。可以压榨出最高的性能,但会占用最多的CPU资源
PhasedBackoffWaitStrategy: 上面多种策略的综合,CPU资源的占用少,延迟大。
2、handleEventsWith与handleEventsWithWorkerPool的区别
这两个方法区别主要就是在于是否重复消费队列中的消息,前者加载的不同消费者会各自对消息进行消费,各个消费者之间不存在竞争。后者消费者对于队列中的同一条消息不重复消费;
二、性能对比
上面我们对三种阻塞队列做了一个基本的介绍,下面我们分别对它们进行性能上的测试与比对,看下ArrayBlcokingQueue与LinkedBlockingQueue性能上有哪些差别,而Disruptor是否像说的那样具备很高的并发性能
首先我们构造一个加单的消息事件实体
[
public class InfoEvent implements Serializable {
private static final long serialVersionUID = 1L;
private long id;
private String value;
public InfoEvent() {
}
public InfoEvent(long id, String value) {
this.id = id;
this.value = value;
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
}
[
定义事件工厂
[
public class InfoEventFactory implements EventFactory<InfoEvent>{
public InfoEvent newInstance() {
return new InfoEvent();
}
}
[
定义Disruptor的消费者
[
public class InfoEventConsumer implements WorkHandler<InfoEvent> {
private long startTime;
private int cnt;
public InfoEventConsumer() {
this.startTime = System.currentTimeMillis();
}
@Override
public void onEvent(InfoEvent event) throws Exception {
// TODO Auto-generated method stub
cnt++;
if (cnt == DisruptorTest.infoNum) {
long endTime = System.currentTimeMillis();
System.out.println(" 消耗时间: " + (endTime - startTime) + "毫秒");
}
}
}
[
接下来分别针对ArrayBlockingQueue、LinkedBlockingQueue与Disruptor编写测试程序
ArrayBlcokingQueueTest
[
public class ArrayBlcokingQueueTest {
public static int infoNum = 5000000;
public static void main(String[] args) {
final BlockingQueue<InfoEvent> queue = new ArrayBlockingQueue<InfoEvent>(100);
final long startTime = System.currentTimeMillis();
new Thread(new Runnable() {
@Override
public void run() {
int pcnt = 0;
while (pcnt < infoNum) {
InfoEvent kafkaInfoEvent = new InfoEvent(pcnt, pcnt+"info");
try {
queue.put(kafkaInfoEvent);
} catch (InterruptedException e) {
e.printStackTrace();
}
pcnt++;
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
int cnt = 0;
while (cnt < infoNum) {
try {
queue.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
cnt++;
}
long endTime = System.currentTimeMillis();
System.out.println("消耗时间 : " + (endTime - startTime) + "毫秒");
}
}).start();
}
}
[
LinkedBlockingQueueTest
[
public class LinkedBlockingQueueTest {
public static int infoNum = 50000000;
public static void main(String[] args) {
final BlockingQueue<InfoEvent> queue = new LinkedBlockingQueue<InfoEvent>();
final long startTime = System.currentTimeMillis();
new Thread(new Runnable() {
@Override
public void run() {
int pcnt = 0;
while (pcnt < infoNum) {
InfoEvent kafkaInfoEvent = new InfoEvent(pcnt, pcnt + "info");
try {
queue.put(kafkaInfoEvent);
} catch (InterruptedException e) {
e.printStackTrace();
}
pcnt++;
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
int cnt = 0;
while (cnt < infoNum) {
try {
queue.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
cnt++;
}
long endTime = System.currentTimeMillis();
System.out.println("消耗时间: " + (endTime - startTime) + "毫秒");
}
}).start();
}
}
[
DisruptorTest
[
public class DisruptorTest {
public static int infoNum = 5000000;
@SuppressWarnings("unchecked")
public static void main(String[] args) {
InfoEventFactory factory = new InfoEventFactory();
int ringBufferSize = 65536; //数据缓冲区的大小 必须为2的次幂
/**
*
* factory,定义的事件工厂
* ringBufferSize,环形队列RingBuffer的大小,必须是2的N次方
* ProducerType,生产者线程的设置,当你只有一个生产者线程时设置为 ProducerType.SINGLE,多个生产者线程ProducerType.MULTI
* waitStrategy,消费者的等待策略
*
*/
final Disruptor<InfoEvent> disruptor = new Disruptor<InfoEvent>(factory, ringBufferSize,
DaemonThreadFactory.INSTANCE, ProducerType.SINGLE, new YieldingWaitStrategy());
InfoEventConsumer consumer = new InfoEventConsumer();
disruptor.handleEventsWithWorkerPool(consumer);
disruptor.start();
new Thread(new Runnable() {
@Override
public void run() {
RingBuffer<InfoEvent> ringBuffer = disruptor.getRingBuffer();
for (int i = 0; i < infoNum; i++) {
long seq = ringBuffer.next();
InfoEvent infoEvent = ringBuffer.get(seq);
infoEvent.setId(i);
infoEvent.setValue("info" + i);
ringBuffer.publish(seq);
}
}
}).start();
}
}
[
我们在十万、百万、千万三个数量级上,分别对ArrayBlockingQueue,LinkedBlockingQueue初始化为无界和有界队列,Disruptor的BlockingWaitStrategy和YieldingWaitStrategy,进行三次测试,生产者与消费者均在单线程模式下运行,对结果进行统计记录;
测试环境:
操作系统:win7 64位,CPU:Intel Core i7-3250M 2.9GHz ,内存:8G,JDK:1.8,disruptor版本:3.4.2
五十万数据
第一次 | 第二次 | 第三次 | |
ArrayBlcokingQueue | 229ms | 233ms | 253ms |
LinkedBlockingQueue(无界) | 211ms | 207ms | 202ms |
LinkedBlockingQueue(有界) | 265ms | 207ms | 256ms |
Disruptor(BlockingWaitStrategy) | 71ms | 56ms | 65ms |
Disruptor(YieldingWaitStrategy) | 56ms | 48ms | 49ms |
五百万数据
第一次 | 第二次 | 第三次 | |
ArrayBlcokingQueue | 1530ms | 1603ms | 1576ms |
LinkedBlockingQueue(无界) | 1369ms | 1390ms | 1409ms |
LinkedBlockingQueue(有界) | 1408ms | 1397ms | 1494ms |
Disruptor(BlockingWaitStrategy) | 345ms | 363ms | 357ms |
Disruptor(YieldingWaitStrategy) | 104ms | 108ms | 107ms |
五千万数据
第一次 | 第二次 | 第三次 | |
ArrayBlcokingQueue | 14799ms | 14928ms | 15122ms |
LinkedBlockingQueue(无界) | 14226ms | 14008ms | 13518ms |
LinkedBlockingQueue(有界) | 14039ms | 14434ms | 13839ms |
Disruptor(BlockingWaitStrategy) | 2972ms | 2910ms | 2848ms |
Disruptor(YieldingWaitStrategy) | 699ms | 742ms | 698ms |
然后我对程序进行了修改,让测试程序持续运行,每五千万输出一次,对运行期间CPU和内存使用情况进行了记录
ArrayBlcokingQueue
LinkedBlockingQueue(无界)
LinkedBlockingQueue(有界)
Disruptor(BlockingWaitStrategy)
Disruptor(YieldingWaitStrategy)
从上面的测试中我们可以看到ArrayBlcokingQueue与LinkedBlockingQueue性能上区别不是很大,LinkedBlockingQueue由于读写锁的分离,平均性能会稍微好些,但差距并不明显。
而Disruptor性能表现突出,特别是随着数据量的增大,优势会越发明显。同时在单线程生产和消费的应用场景下,相比jdk内置的阻塞队列,CPU和GC的压力反而更小。
三、总结
1、ArrayBlcokingQueue与LinkedBlockingQueue,一般认为前者基于数组实现,初始化后不需要再创建新的对象,但没有进行锁分离,所以内存GC压力较小,但性能会相对较低;后者基于链表实现,每次都需要创建 一个node对象,会存在频繁的创建销毁操作,GC压力较大,但插入和删除数据是不同的锁,进行了锁分离,性能会相对较好;从测试结果上看,其实两者性能和GC上差别都不大,在实际运用过程中,我认为一般场景下ArrayBlcokingQueue的性能已经足够应对,处于对GC压力的考虑,及潜在的OOM的风险我建议普通情况下使用ArrayBlcokingQueue即可。当然你也可以使用LinkedBlockingQueue,从测试结果上看,它相比ArrayBlcokingQueue性能上有有所提升但并不明显,结合gc的压力和潜在OOM的风险,所以结合应用的场景需要综合考虑。
2、Disruptor做为一款高性能队列框架,确实足够优秀,在测试中我们可以看到无论是性能和GC压力都远远好过ArrayBlcokingQueue与LinkedBlockingQueue;如果你追求更高的性能,那么Disruptor是一个很好的选择。
但需要注意的是,你需要结合自己的硬件配置和业务场景,正确配置Disruptor,选择合适的消费策略,这样不仅可以获取较高的性能,同时可以保证硬件资源的合理分配。
3、对这三种阻塞队列的测试,并不是为了比较孰优孰劣,主要是为了加强理解,实际的业务应用需要根据情况合理进行选择。这里只是结合自己的使用,对它们进行一个简单的总结,并没有进行较深入的探究,如有错误的的地方还请指正与海涵。