JAVA多线程基础之十一并发队列Queue

最新推荐文章于 2025-07-10 16:40:43 发布

hp15

最新推荐文章于 2025-07-10 16:40:43 发布

阅读量3.8k

点赞数

CC 4.0 BY-SA版权

分类专栏：基础多线程文章标签：并发队列 Queue 多线程

本文链接：https://blog.youkuaiyun.com/haponchang/article/details/90439416

Java并发队列分为非阻塞队列（如ConcurrentLinkedQueue）和阻塞队列（如ArrayBlockingQueue, LinkedBlockingQueue）。阻塞队列在队列为空或满时，操作会阻塞，常用于生产者消费者模型。本文详细介绍了 BlockingQueue 的各种实现，如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue等，以及它们的特点和使用场景。" 127069678,12536492,JavaScript中的location与history对象详解,"['JavaScript', '前端开发', 'HTML', 'servlet']

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

并发队列Queue

在并发队列上JDK提供了两套实现，一个是以ConcurrentLinkedQueue为代表的高性能非阻塞队列，一个是以BlockingQueue接口为代表的阻塞队列，无论哪种都继承自Queue。

下面这张图是 Java 并发类库提供的各种各样的线程安全队列实现，注意，图中并未将非线程安全部分包含进来。

Queue 阻塞队列与非阻塞队列

阻塞队列与普通队列的区别在于，当队列是空的时，从队列中获取元素的操作将会被阻塞，或者当队列是满时，往队列里添加元素的操作会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他的线程使队列重新变得空闲起来，如从队列中移除一个或者多个元素，或者完全清空队列.（前四个为非阻塞队列，后四个为阻塞队列）

1.ArrayDeque, （数组双端队列）
2.PriorityQueue, （优先级队列）
3.ConcurrentLinkedQueue, （基于链表的并发队列）
4.DelayQueue, （延期阻塞队列）（阻塞队列实现了BlockingQueue接口）
5.ArrayBlockingQueue, （基于数组的并发阻塞队列）
6.LinkedBlockingQueue, （基于链表的FIFO阻塞队列）
7.LinkedBlockingDeque, （基于链表的FIFO双端阻塞队列）
8.PriorityBlockingQueue, （带优先级的无界阻塞队列）
9.SynchronousQueue （并发同步阻塞队列）

ConcurrentLinkedDeque
ConcurrentLinkedQueue : 是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLinkedQueue性能好于BlockingQueue.它是一个基于链接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先加入的，尾是最近加入的，该队列不允许null元素。
ConcurrentLinkedQueue重要方法:
add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中这俩个方法没有任何区别)
poll() 和peek() 都是取头元素节点，区别在于前者会删除元素，后者不会。

import java.util.concurrent.ConcurrentLinkedDeque;

ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();

//添加元素 FIFO

q.offer("a");

q.offer("b");

q.offer("c");

q.offer("d");

q.offer("e");

//从头获取元素,删除该元素

System.out.println(q.poll());

//从头获取元素,不刪除该元素

System.out.println(q.peek());

//获取总长度

System.out.println(q.size());

BlockingQueue

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列。这两个附加的操作是：

在队列为空时，获取元素的线程会等待队列变为非空。

当队列满时，存储元素的线程会等待队列可用。

阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

BlockingQueue即阻塞队列，从阻塞这个词可以看出，在某些情况下对阻塞队列的访问可能会造成阻塞。被阻塞的情况主要有如下两种：

1. 当队列满了的时候进行入队列操作

2. 当队列空了的时候进行出队列操作

因此，当一个线程试图对一个已经满了的队列进行入队列操作时，它将会被阻塞，除非有另一个线程做了出队列操作；同样，当一个线程试图对一个空队列进行出队列操作时，它将会被阻塞，除非有另一个线程进行了入队列操作。

在Java中，BlockingQueue的接口位于java.util.concurrent 包中(在Java5版本开始提供)，由上面介绍的阻塞队列的特性可知，阻塞队列是线程安全的。

在新增的Concurrent包中，BlockingQueue很好的解决了多线程中，如何高效安全“传输”数据的问题。通过这些高效并且线程安全的队列类，为我们快速搭建高质量的多线程程序带来极大的便利。本文详细介绍了BlockingQueue家庭中的所有成员，包括他们各自的功能以及常见使用场景。

认识BlockingQueue

阻塞队列，顾名思义，首先它是一个队列，而一个队列在数据结构中所起的作用大致如下图所示：

从上图我们可以很清楚看到，通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出；

常用的队列主要有以下两种：（当然通过不同的实现方式，还可以延伸出很多不同类型的队列，DelayQueue就是其中的一种）

　　先进先出（FIFO）：先插入的队列的元素也最先出队列，类似于排队的功能。从某种程度上来说这种队列也体现了一种公平性。

　　后进先出（LIFO）：后插入队列的元素最先出队列，这种队列优先处理最近发生的事件。

多线程环境中，通过队列可以很容易实现数据共享，比如经典的“生产者”和“消费者”模型中，通过队列可以很便利地实现两者之间的数据共享。假设我们有若干生产者线程，另外又有若干个消费者线程。如果生产者线程需要把准备好的数据共享给消费者线程，利用队列的方式来传递数据，就可以很方便地解决他们之间的数据共享问题。但如果生产者和消费者在某个时间段内，万一发生数据处理速度不匹配的情况呢？理想情况下，如果生产者产出数据的速度大于消费者消费的速度，并且当生产出来的数据累积到一定程度的时候，那么生产者必须暂停等待一下（阻塞生产者线程），以便等待消费者线程把累积的数据处理完毕，反之亦然。然而，在concurrent包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。好在此时，强大的concurrent包横空出世了，而他也给我们带来了强大的BlockingQueue。（在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒）

下面两幅图演示了BlockingQueue的两个常见阻塞场景：

ArrayBlockingQueue

ArrayBlockingQueue是一个有边界的阻塞队列，它的内部实现是一个数组。有边界的意思是它的容量是有限的，我们必须在其初始化的时候指定它的容量大小，容量大小一旦指定就不可改变。

ArrayBlockingQueue是以先进先出的方式存储数据，最新插入的对象是尾部，最新移出的对象是头部。下面

是一个初始化和使用ArrayBlockingQueue的例子：

//容量大小一旦指定就不可改变

  ArrayBlockingQueue<String> arrays = new ArrayBlockingQueue<String>(3);

  arrays.add("李四");

boolean b ;

try {

    //队列未满，可以存入

    b = arrays.offer("张军", 1, TimeUnit.SECONDS);

    System.out.println(b);

  } catch (InterruptedException e) {

    e.printStackTrace();

  }

arrays.add("张军");

  // 添加阻塞队列

  try {

    //队列已满，无法存入

    b = arrays.offer("张三", 1, TimeUnit.SECONDS);

    System.out.println(b);

  } catch (InterruptedException e) {

    e.printStackTrace();

  }

System.out.println("ArrayBlockingQueue size : "+arrays.size());

网吧有届队列：

import java.util.concurrent.ArrayBlockingQueue;



/**

 * Created by zhanghaipeng on 2018/11/12.

 */

public class WangbaArray{



    public static ArrayBlockingQueue<WangminArray> queue = new ArrayBlockingQueue(5);



    private boolean isOpen = true;



    public void open() {

        isOpen = true;

    }



    public void close() {

        isOpen = false;

    }



    public static void main(String[] args){

        System.out.println("网吧开始营业");

        WangbaArray wangba = new WangbaArray();

        wangba.open();



        new Thread(new Runnable() {

            @Override

            public void run() {

                while (wangba.isOpen)

                {

                    WangminArray wangmin ;



                    for (int i = 0; i < 10; i++) {



                        wangmin = new WangminArray("网民" + i, "id" + i,System.currentTimeMillis());

                        wangba.action(wangmin);

                        try {

                            Thread.sleep(1000);

                        } catch (InterruptedException e) {

                            e.printStackTrace();

                        }

                    }

                }

            }

        }).start();



        new Thread(new Runnable() {

            @Override

            public void run() {

                while (wangba.isOpen)

                {

                    try {

                        Thread.sleep(3000);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    wangba.stop();

                }

            }

        }).start();



    }



    private void action(WangminArray wangmin) {

      &nbs