ArrayBlockingQueue 和 LinkedBlockingQueue 性能测试与分析

最新推荐文章于 2024-07-01 03:56:33 发布
最新推荐文章于 2024-07-01 03:56:33 发布
阅读量7.9k 收藏 8
点赞数 4
分类专栏： Java 文章标签： 队列 多线程 java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A434534658/article/details/110195787
版权

ArrayBlockingQueue 和 LinkedBlockingQueue 性能测试

测试代码：

package com.demo.queue;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ArrayBlockingQueueVsLinkedBlockingQueue {
    //任务数量
    public static int TASK_SUM = 0;
    //生产者/消费者线程数
    public static int THREAD_NUM = 0;
    //队列大小
    public static int QUE_SIZE = 0;

    /**
     *测试方法
     */
    public void test(final BlockingQueue<String> q) throws InterruptedException {
        //生产者线程
        class Producer implements Runnable {
            @Override
            public void run() {
                for (int i = 0; i < TASK_SUM; i++) {
                    try {
                        q.put("task");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
        ;
        //消费者线程
        class Consumer implements Runnable {
            @Override
            public void run() {
                for (int i = 0; i < TASK_SUM; 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("任务数量="+ArrayBlockingQueueVsLinkedBlockingQueue.TASK_SUM);
        System.out.println("生产者和消费者各线程数量="+ArrayBlockingQueueVsLinkedBlockingQueue.THREAD_NUM);
        System.out.println("队列大小="+ArrayBlockingQueueVsLinkedBlockingQueue.QUE_SIZE);
        System.out.println(q.getClass().getSimpleName() + " 耗时 : " + (t2 - t1)+"ms");
        System.out.println();
    }

    /**
     *主方法
     */
    public static void main(String[] args) throws InterruptedException {
        //任务数量
        ArrayBlockingQueueVsLinkedBlockingQueue.TASK_SUM = 1000000;
        //生产者和消费者各多少线程
        ArrayBlockingQueueVsLinkedBlockingQueue.THREAD_NUM = 1;
        //队列大小
        ArrayBlockingQueueVsLinkedBlockingQueue.QUE_SIZE = 100;
        final BlockingQueue<String> q1 = new LinkedBlockingQueue<String>(ArrayBlockingQueueVsLinkedBlockingQueue.QUE_SIZE );
        final BlockingQueue<String> q2 = new ArrayBlockingQueue<String>(ArrayBlockingQueueVsLinkedBlockingQueue.QUE_SIZE );
        new ArrayBlockingQueueVsLinkedBlockingQueue().test(q1);
        new ArrayBlockingQueueVsLinkedBlockingQueue().test(q2);
    }
}

测试结果1：

任务数量=1000000
生产者和消费者各线程数量=1
队列大小=100
LinkedBlockingQueue 耗时 : 569ms

任务数量=1000000
生产者和消费者各线程数量=1
队列大小=100
ArrayBlockingQueue 耗时 : 560ms

测试结果2：

任务数量=1000000
生产者和消费者各线程数量=1
队列大小=1000
LinkedBlockingQueue 耗时 : 454ms

任务数量=1000000
生产者和消费者各线程数量=1
队列大小=1000
ArrayBlockingQueue 耗时 : 418ms

测试结果3：

任务数量=1000000
生产者和消费者各线程数量=10
队列大小=100
LinkedBlockingQueue 耗时 : 4253ms

任务数量=1000000
生产者和消费者各线程数量=10
队列大小=100
ArrayBlockingQueue 耗时 : 10053ms

测试结果4：

任务数量=1000000
生产者和消费者各线程数量=10
队列大小=1000
LinkedBlockingQueue 耗时 : 3655ms

任务数量=1000000
生产者和消费者各线程数量=10
队列大小=1000
ArrayBlockingQueue 耗时 : 3508ms

测试结果5：

任务数量=1000000
生产者和消费者各线程数量=30
队列大小=1000
LinkedBlockingQueue 耗时 : 10417ms

任务数量=1000000
生产者和消费者各线程数量=30
队列大小=1000
ArrayBlockingQueue 耗时 : 9432ms

测试结果6：

任务数量=1000000
生产者和消费者各线程数量=30
队列大小=5000
LinkedBlockingQueue 耗时 : 10449ms

任务数量=1000000
生产者和消费者各线程数量=30
队列大小=5000
ArrayBlockingQueue 耗时 : 5600ms

测试结果7：

任务数量=1000000
生产者和消费者各线程数量=100
队列大小=5000
LinkedBlockingQueue 耗时 : 33265ms

任务数量=1000000
生产者和消费者各线程数量=100
队列大小=5000
ArrayBlockingQueue 耗时 : 21303ms

总结：

  1. 总的来看，ArrayBlockingQueue 要比LinkedBlockingQueue 效率高；网上说LinkedBlockingQueue 性能更好，但我没测出来；
  2. 两者共同点，随着线程增多，并发越大，效率越低；
  3. 两者共同点，队列容量越大，效率越高；
  4. 两者共同点，单线程读写效率最高；

原因分析：

  1. 共同点好理解，线程多，并发大，互相争抢，协调资源需要时间，所以降低了效率。增加队列容量，相当于增大了缓冲，有益于提高性能；

  2. 但为什么ArrayBlockingQueue 性能更好，我没分析出来，有请大佬评论；

修改代码，使生产者和消费者线程数量不同

package com.demo.queue;

import com.sun.deploy.util.StringUtils;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ArrayBlockingQueueVsLinkedBlockingQueue {
    //任务数量
    public static int TASK_SUM = 0;
    //生产者/消费者线程数
    public static int CONSUME_THREAD_NUM = 0;
    public static int PRODUCE_THREAD_NUM = 0;
    //队列大小
    public static int QUE_SIZE = 0;

    /**
     *测试方法
     */
    public void test(final BlockingQueue<String> queue) throws InterruptedException {
        //生产者线程
        class Producer implements Runnable {
            @Override
            public void run() {
                for (int i = 0; i < TASK_SUM; i++) {
                    try {
                        queue.put("task");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        }
        ;
        AtomicInteger counter = new AtomicInteger(0);
        //消费者线程
        class Consumer implements Runnable {

            @Override
            public void run() {
              while(true){
                  if(counter.get()>=TASK_SUM*PRODUCE_THREAD_NUM){
                      return;
                  }
                  try {
                      String poll = queue.poll(1, TimeUnit.MICROSECONDS);
                      if(poll!=null){
                          counter.incrementAndGet();
                      }

                  } catch (InterruptedException e) {
                      e.printStackTrace();
                  }
              }
            }
        }
        ;
        //创建生产者
        Thread[] arrProducerThread = new Thread[PRODUCE_THREAD_NUM];
        for (int i = 0; i < PRODUCE_THREAD_NUM; i++) {
            arrProducerThread[i] = new Thread(new Producer());
        }
        //创建消费者
        Thread[] arrConsumerThread = new Thread[CONSUME_THREAD_NUM];
        for (int i = 0; i < CONSUME_THREAD_NUM; i++) {
            arrConsumerThread[i] = new Thread(new Consumer());
        }
        //go!
        long t1 = System.currentTimeMillis();
        for (int i = 0; i < CONSUME_THREAD_NUM; i++) {
            arrConsumerThread[i].start();
        }
        for (int i = 0; i < PRODUCE_THREAD_NUM; i++) {
            arrProducerThread[i].start();
        }
        //等待完成
        for (int i = 0; i < CONSUME_THREAD_NUM; i++) {
            arrConsumerThread[i].join();
        }
        for (int i = 0; i < PRODUCE_THREAD_NUM; i++) {
            arrProducerThread[i].join();
        }
        long t2 = System.currentTimeMillis();
        System.out.println("任务数量="+TASK_SUM);
        System.out.println("生产者各线程数量="+PRODUCE_THREAD_NUM);
        System.out.println("消费者各线程数量="+CONSUME_THREAD_NUM);
        System.out.println("队列大小="+QUE_SIZE);
        System.out.println("执行完毕的任务数量="+counter.get());
        System.out.println(queue.getClass().getSimpleName() + " 耗时 : " + (t2 - t1)+"ms");
        System.out.println();
    }

    /**
     *主方法
     */
    public static void main(String[] args) throws InterruptedException {
        //任务数量
        ArrayBlockingQueueVsLinkedBlockingQueue.TASK_SUM = 1000000;
        //生产者和消费者各多少线程
        ArrayBlockingQueueVsLinkedBlockingQueue.PRODUCE_THREAD_NUM = 1;
        ArrayBlockingQueueVsLinkedBlockingQueue.CONSUME_THREAD_NUM = 1;
        //队列大小
        ArrayBlockingQueueVsLinkedBlockingQueue.QUE_SIZE = 100;
        final BlockingQueue<String> q1 = new LinkedBlockingQueue<String>(ArrayBlockingQueueVsLinkedBlockingQueue.QUE_SIZE );
        final BlockingQueue<String> q2 = new ArrayBlockingQueue<String>(ArrayBlockingQueueVsLinkedBlockingQueue.QUE_SIZE );

        new ArrayBlockingQueueVsLinkedBlockingQueue().test(q1);
        new ArrayBlockingQueueVsLinkedBlockingQueue().test(q2);
    }
}

测试结果1：
都是单线程,ArrayBlockingQueue 相对较快

任务数量=1000000
生产者各线程数量=1
消费者各线程数量=1
队列大小=100
执行完毕的任务数量=1000000
LinkedBlockingQueue 耗时 : 267ms

任务数量=1000000
生产者各线程数量=1
消费者各线程数量=1
队列大小=100
执行完毕的任务数量=1000000
ArrayBlockingQueue 耗时 : 203ms

测试结果2：
一个生产者，10个消费者，LinkedBlockingQueue耗时稍微上涨。ArrayBlockingQueue 耗时上涨较多。

任务数量=1000000
生产者各线程数量=1
消费者各线程数量=10
队列大小=100
执行完毕的任务数量=1000000
LinkedBlockingQueue 耗时 : 321ms

任务数量=1000000
生产者各线程数量=1
消费者各线程数量=10
队列大小=100
执行完毕的任务数量=1000000
ArrayBlockingQueue 耗时 : 919ms

测试结果3：
10个生产者，10个消费者，队列大小100，耗时都剧增，ArrayBlockingQueue 耗时是LinkedBlockingQueue 的3倍。

任务数量=1000000
生产者各线程数量=10
消费者各线程数量=10
队列大小=100
执行完毕的任务数量=10000000
LinkedBlockingQueue 耗时 : 2208ms

任务数量=1000000
生产者各线程数量=10
消费者各线程数量=10
队列大小=100
执行完毕的任务数量=10000000
ArrayBlockingQueue 耗时 : 6620ms

测试结果4：
10个生产者，10个消费者，加大队列容量到1000，两者耗时相对之前有所下降。ArrayBlockingQueue 耗时较少。

任务数量=1000000
生产者各线程数量=10
消费者各线程数量=10
队列大小=1000
执行完毕的任务数量=10000000
LinkedBlockingQueue 耗时 : 1860ms

任务数量=1000000
生产者各线程数量=10
消费者各线程数量=10
队列大小=1000
执行完毕的任务数量=10000000
ArrayBlockingQueue 耗时 : 1459ms

测试结果5：
10个生产者，20个消费者，队列容量还是1000。LinkedBlockingQueue 耗时基本不变。ArrayBlockingQueue 耗时增加，且大于LinkedBlockingQueue ；

任务数量=1000000
生产者各线程数量=10
消费者各线程数量=20
队列大小=1000
执行完毕的任务数量=10000000
LinkedBlockingQueue 耗时 : 1845ms

任务数量=1000000
生产者各线程数量=10
消费者各线程数量=20
队列大小=1000
执行完毕的任务数量=10000000
ArrayBlockingQueue 耗时 : 2100ms

测试结果6：
20个生产者，10个消费者，队列大小还是1000。两者耗时都剧增。ArrayBlockingQueue 耗时更大。

任务数量=1000000
生产者各线程数量=20
消费者各线程数量=10
队列大小=1000
执行完毕的任务数量=20000000
LinkedBlockingQueue 耗时 : 3752ms

任务数量=1000000
生产者各线程数量=20
消费者各线程数量=10
队列大小=1000
执行完毕的任务数量=20000000
ArrayBlockingQueue 耗时 : 5121ms

总结：
LinkedBlockingQueue 更适合生产者数量少于消费者的情况；
ArrayBlockingQueue 更适合队列容量大的情况；
生产者数量少于消费者时候，两者效率都会更高。
并发越小，两者效率越高。

阿拉的梦想
关注
专栏目录
ArrayBlockingQueue源码分析
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
02-19 258
Java阻塞队列的历史可以追溯到JDK1.5版本，Java平台增加了java.util.concurrent(即我们常说的JUC包)，这其中包含了各种并发流程控制工具、并发容器等。这其中自然也包含了我们这篇文章所讨论的阻塞队列。为了实现在高并发场景下，多线程之间数据共享的问题，在JDK1.5版本，出现了我们所熟知的ArrayBlockingQueue和LinkedBlockingQueue，一种带有生产者-消费者模式所实现的并发容器。
并发队列对比之二：LinkedBlockingQueue和ArrayBlockingQueue性能对比
weixin_34055910的博客
10-11 331
回顾下，LinkedBlockingQueue和ArrayBlockingQueue在实现上不同点有： 1、ArrayBlockingQueue使用数组存储数据，LinkedBlockingQueue使用单向链表存储数据； 2、ArrayBlockingQueue使用一个可重入锁和这个锁生成的两个条件对象进行并发控制(classic two-condition algorithm)，而Link...
ArrayBlockingQueue和LinkedBlockingQueue
qq_27672691的博客
11-05 243
阻塞队列与普通队列最大的不同之处 阻塞添加：当阻塞队列已满时，队列会阻塞加入的线程，直到队列未满的时候再加入队列 阻塞删除：当阻塞队列为空时，删除队列的元素的线程将会被阻塞，直到队列为空的时候再执行删除操作。 ArrayBlockingQueue 是一个用数组实现的先进先出的有界阻塞队列，其中put方法和take方法为添加阻塞和删除阻塞的方法。 ArrayBlockingQueue内部的阻塞队列...
Queue之ArrayBlockingQueue、LinedBlockingQueue
最新发布
weixin_42591908的博客
07-01 70
LinkedBlockingQueue和ArrayBlockingQueue都是Java中的阻塞队列实现，下面是他们两个直接的比较：底层数据结构：LinkedBlockingQueue使用链表作为底层数据结构，而ArrayBlockingQueue使用数组作为底层数据结构。这导致LinkedBlockingQueue在插入...
LinkedBlockingQueue与ArrayBlockingQueue性能比较
爱科学，爱生活
06-12 3723
实验结论：在JDK1.8下，LinkedBlockingQueue性能优于ArrayBlockingQueue 实验一： public class BlockQueueApp { public static void main(String[] args) { //final LinkedBlockingQueue queue = new LinkedBl
SynchronousQueue、LinkedBlockingQueue、ArrayBlockingQueue性能测试
qq_35381274的博客
12-19 425
https://blog.csdn.net/QQ578473688/article/details/54562193
LinkedBlockingQueue和ArrayBlockingQueue
沐雨金鳞
09-26 3271
相同： LinkedBlockingQueue和ArrayBlockingQueue都实现了BlockingQueue接口； LinkedBlockingQueue和ArrayBlockingQueue都是可阻塞的队列(内部都是使用ReentrantLock和Condition来保证生产和消费的同步;当队列为空，消费者线程被阻塞；当队列装满，生产者线程被阻塞.) 不同： 1、队列中的同步锁机制不同 ArrayBlockingQueue中的锁是没有分离的，即生产和消费用的是同一个锁; 使用一个R.
Java线程池实验：ArrayBlockingQueue和LinkedBlockingQueue性能测试
trigger的博客
05-12 1261
性能比较是ArrayBlockingQueue优于LinkedBlockingQueue，因为ArrayBlockingQueue采用数组存储队列元素，因此再插入、删除元素时不会产生或销毁任何额外的对象实例，而LinkedBlockingQueue每次插入都会生成一个新的结点（Node）对象，这会影响日后GC垃圾回收，也会影响性能。1千万个put+take7000ms3000ms。...
ArrayBlockingQueue 的性能瓶颈
freeRoad
07-25 2067
先看看ArrayBlockingQueue的源码，主要有两个方法 先看put方法：向队列的尾部插入元素，若已满则等待。 /** * Inserts the specified element at the tail of this queue, waiting * for space to become available if the queue is full. * * @t...
LinkedBlockingQueue性能测试
Godric的杂记
04-30 5018
LinkedBl官方文档： An optionally-bounded blocking queue based on linked nodes. This queue orders elements FIFO (first-in-first-out). The head of the queue is that element that has been on the queue th
ArrayBlockingQueue实现原理与性能对比
ArrayBlockingQueue是Java中的一个阻塞队列实现，它基于数组结构实现，具有固定容量，可以按先进先出的顺序进行元素存储和获取。在多线程环境下，ArrayBlockingQueue提供了线程安全的操作。 ## 1.2 ...
java并发之ArrayBlockingQueue详细介绍
08-30
主要介绍了java并发之ArrayBlockingQueue详细介绍的相关资料,需要的朋友可以参考下
性能测试与调优：阻塞式线程安全队列的实际表现
#### 1.1 什么是性能测试与调优 性能测试是指对系统在不同条件下进行模拟，以评估其性能指标并发现潜在的性能问题的过程。性能调优则是指根据性能测试结果，对系统进行优化，以提升系统的性能表现和用户体验。 ####...
Java是否能够重写LinkedBlockingQueue的写入锁以提高性能
07-27
如果你想要提高`LinkedBlockingQueue`的性能，你可以考虑使用其他类型的队列，如`ConcurrentLinkedQueue`或`ArrayBlockingQueue`，它们在特定场景下可能具有更好的性能表现。 另外，如果你对性能要求非常高，你可以...
Java中的LinkedBlockingQueue：原理、应用与性能深入剖析
码到三十五
03-14 1748
LinkedBlockingQueue，如其名，是一个基于链接节点的、线程安全的队列。它不仅可以作为生产者-消费者模式中的核心组件，帮助我们在多线程环境下安全地传递数据，还可以利用其阻塞特性，有效地协调生产和消费的速度，使得系统更为稳定、高效。 但LinkedBlockingQueue背后的原理、应用场景以及性能特性，你是否真正了解呢？这篇博客，将带你深入Java并发编程的世界，一起探索LinkedBlockingQueue的每一个角落。
java BlockingQueque的多种实现
weixin_30284355的博客
06-29 215
参考链接：http://www.importnew.com/28053.html 最近得空，想写篇文章好好说说 java 线程池问题，我相信很多人都一知半解的，包括我自己在仔仔细细看源码之前，也有许多的不解，甚至有些地方我一直都没有理解到位。 说到线程池实现，那么就不得不涉及到各种 BlockingQueue 的实现，那么我想就 BlockingQueue 的问题和大家分享分享我了解的一些知识...
ArrayBlockingQueue分析
lwt_zd的博客
05-07 226
ArrayBlockingQueue分析ArrayBlockingQueue概述特征应用场景合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导...
LinkedBlockingQueue
xjk201的博客
01-06 424
以单链表实现的阻塞队列，它是线程安全的，借助分段的思想把入队出队分裂成两个锁 特性 前面有概述 public class LinkedBlockingDeque<E> extends AbstractQueue<E> implements BlockingDeque<E>, java.io.Serializable {} 成员变量 // 容量,有界队列 private final int capacity; // 元素数量...
Java线程池实验：ArrayBlockingQueue和LinkedBlockingQueue吞吐量测试
trigger的博客
05-12 1014
二者区别 ArrayBlockingQueue内部使用1个锁来控制队列项的插入、取出操作，而LinkedBlockingQueue则是使用了2个锁来控制，一个名为putLock，另一个是takeLock，但是锁的本质都是ReentrantLock。 Array里面使用的时一个锁，不管put还是take行为，都可能被这个锁卡住，而Linked里面put和take是两个锁，put只会被put行为卡住，而不会被take卡住，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，因此吞吐性能自然强
arrayblockingqueue和linkedblockingqueue
03-28
相比于ArrayBlockingQueue，LinkedBlockingQueue在并发环境下的性能更好，但因为它是基于链表实现的，所以在频繁的插入和删除操作中，性能可能会受到影响。 综上所述，如果你需要一个固定大小的、读写操作都是原子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值