java并发编程 BlockingQueue-阻塞队列（七）

最新推荐文章于 2023-10-31 19:55:21 发布

邋遢道

最新推荐文章于 2023-10-31 19:55:21 发布

阅读量402

点赞数

分类专栏：并发 java 文章标签： java 高并发编程

本文链接：https://blog.csdn.net/qq_20607405/article/details/126987368

版权

java 同时被 2 个专栏收录

18 篇文章 0 订阅

订阅专栏

并发

8 篇文章 0 订阅

订阅专栏

队列

在学习阻塞队列之前，我们先来了解一下什么是队列，Java中队列是Queue接口，一种特殊的线性表或者说一种存储数据的结构，遵循先入先出、后入后出的基本原则。一般来说，它只允许在表的前端进行删除操作，而在表的后端进行插入操作，但是java的某些队列运行在任何地方插入删除；比如我们常用的 LinkedList 集合，它实现了Queue 接口，因此，我们可以理解为 LinkedList 就是一个队列。
队列主要分为：

阻塞和非阻塞，有界和无界、单向和双向链表（本文只对阻塞队列进行说明）

首先来了解下Queue接口：

public interface Queue<E> extends Collection<E> {

    //添加一个元素，添加成功返回true, 如果队列满了，就会抛出异常
    boolean add(E e);

    //添加一个元素，添加成功返回true, 如果队列满了，返回false
    boolean offer(E e);

    //返回并删除队首元素，队列为空则抛出异常
    E remove();

    //返回并删除队首元素，队列为空则返回null
    E poll();

    //返回队首元素，但不移除，队列为空则抛出异常
    E element();

    //获取队首元素，但不移除，队列为空则返回null
    E peek();
}

阻塞队列

特点

阻塞队列区别于其他类型的队列的最主要的特点就是“阻塞”这两个字阻塞功能使得生产者和消费者两端的能力得以平衡，当有任何一端速度过快时，阻塞队列便会把过快的速度给降下来。实现阻塞最重要的两个方法是 take 方法和 put 方法

1. take 方法的功能是获取并移除队列的头结点，通常在队列里有数据的时候是可以正常移除的。可是一旦执行 take 方法的时候，队列里无数据，则阻塞，直到队列里有数据。一旦队列里有数据了，就会立刻解除阻塞状态，并且取到数据。

2. put 方法插入元素时，如果队列没有满，那就和普通的插入一样是正常的插入，但是如果队列已满，那么就无法继续插入，则阻塞，直到队列里有了空闲空间。如果后续队列有了空闲空间，比如消费者消费了一个元素，那么此时队列就会解除阻塞状态，并把需要添加的数据添加到队列中。

应用场景：

通常使用生产者/消费者模式的时候（或者其他入队出队业务），我们生产者只需要往队列里添加元素，而消费者只需要从队列里取出它们就可以了，而且阻塞队列（BlockingQueue）是线程安全的，所以生产者和消费者都可以是多线程的，不会发生线程安全问题。生产者/消费者直接使用线程安全的队列就可以，而不需要自己去考虑更多的线程安全问题

BlockingQueue接口

java.util.concurrent包下也是专门为并发编程设计，继承自Queue接口，在Queue接口基础上加了阻塞的操作

public interface BlockingQueue<E> extends Queue<E> {
   
    将给定元素设置到队列中，如果设置成功返回true, 否则抛出异常。如果是往限定了长度的队列中设置值，推荐使用offer()方法
    boolean add(E e);

    //将给定的元素设置到队列中，如果队列没满，返回true，如果队列已满，返回false（不阻塞）
    boolean offer(E e);

    //元素设置到队列中，如果队列已满，则阻塞，直至队列空出位置
    void put(E e) throws InterruptedException;

    //将给定的元素设置到队列中，可以设置阻塞时间，如果队列已满，则进行阻塞。超过阻塞时间，则返回false
    boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException;

    //队列里有数据会正常取出数据并删除；但是如果队列里无数据，则阻塞，直到队列里有数据
    E take() throws InterruptedException;

    //从队列中获取值，如果有数据，出队，如果没有数据，返回null （不阻塞）
    E poll();

    //从队列中获取值，可以设置阻塞时间，如果没有数据，则阻塞，超过阻塞时间，则返回null
    E poll(long timeout, TimeUnit unit) throws InterruptedException;

     //获取队列中剩余的空间。
    int remainingCapacity();
 
    //从队列中移除指定的值。
    boolean remove(Object o);
 
    //判断队列中是否拥有该值。
    public boolean contains(Object o);
 
    //将队列中值，全部移除，并发设置到给定的集合中。
    int drainTo(Collection<? super E> c);
 
    //指定最多数量限制将队列中值，全部移除，并发设置到给定的集合中。
    int drainTo(Collection<? super E> c, int maxElements);
}

既然是接口，肯定需要实现这些方法来使用，一起看下常用的几个实现类：

ArrayBlockingQueue 基于数组结构实现的一个有界阻塞队列

LinkedBlockingQueue 基于链表结构实现的一个有界阻塞队列

PriorityBlockingQueue 支持按优先级排序的无界阻塞队列

DelayQueue 基于优先级队列（PriorityBlockingQueue）实现的无界阻塞队列

SynchronousQueue 不存储元素的阻塞队列

LinkedTransferQueue 基于链表结构实现的一个无界阻塞队列

LinkedBlockingDeque 基于链表结构实现的一个双端阻塞队列

老样子，接口的多态实现，只是为了解决不同的业务场景，所以，需要哪一个自选

ArrayBlockingQueue

最典型的有界阻塞队列，其内部是用数组存储元素的，初始化时需要指定容量大小（小于等于0抛出异常），利用 ReentrantLock 实现线程安全。

使用场景：如果生产速度和消费速度基本匹配的情况下，使用 ArrayBlockingQueue是个不错选择；当如果生产速度远远大于消费速度，则会导致队列填满，大量生产线程被阻塞

核心源码：

public void put(E e) throws InterruptedException {
        检查是否为空
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        //加锁，如果线程中断抛出异常
        lock.lockInterruptibly();
        try {
            //阻塞队列已满，则将生产者挂起，等待消费者唤醒
            //设计注意点： 用while不用if是为了防止虚假唤醒
            while (count == items.length)
                //队列满了，使用notFull等待（生产者阻塞）
                notFull.await();
            // 入队
            enqueue(e);
        } finally {
            //唤醒消费者线程
            lock.unlock();
        }
}

private void enqueue(E x) {
     final Object[] items = this.items;
     //入队 使用的putIndex
     items[putIndex] = x;

     if (++putIndex == items.length)
     putIndex = 0; //设计的精髓： 环形数组，putIndex指针到数组尽头了，返回头部
     count++;

     //notEmpty条件队列转同步队列，准备唤醒消费者线程，因为入队了一个元素，肯定不为空了
     notEmpty.signal();
}

public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        //加锁，如果线程中断抛出异常
        lock.lockInterruptibly();
        try {
            //如果队列为空，则消费者挂起
            while (count == 0)
                notEmpty.await();
            //出队
            return dequeue();
        } finally {
            lock.unlock();// 唤醒生产者线程
        }
}
 private E dequeue() {
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex]; //取出takeIndex位置的元素
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0; //设计的精髓： 环形数组，takeIndex 指针到数组尽头了，返回头部
        count‐‐;
        if (itrs != null)
            itrs.elementDequeued();
        //notFull条件队列转同步队列，准备唤醒生产者线程，此时队列有空位
        notFull.signal();
        return x;
}

使用方式：

BlockingQueue arrayBlockingQueue= new ArrayBlockingQueue(100);
arrayBlockingQueue.put("1"); //向队列中添加元素
Object object = arrayBlockingQueue.take(); //从队列中取出元素

LinkedBlockingQueue

一个基于链表实现的阻塞队列，默认情况下，该阻塞队列的大小为Integer.MAX_VALUE，由于这个数值特别大，所以 LinkedBlockingQueue 也被称作无界队列，代表它几乎没有界限，队列可以随着元素的添加而动态增长，但是如果没有剩余内存，则队列将抛出OOM错误。所以为了避免队列过大造成机器负载或者内存爆满的情况出现，我们在使用的时候建议手动传一个队列的大小

LinkedBlockingQueue内部由单链表实现，只能从head取元素，从tail添加元素。采用两把锁的锁分离技术实现入队出队互不阻塞，添加元素和获取元素都有独立的锁，也就是说LinkedBlockingQueue是读写分离的，读写操作可以并行执行

核心源码：

public void put(E e) throws InterruptedException {
        // 不允许null元素
        if (e == null) throw new NullPointerException();
        int c = ‐1;
        // 新建一个节点
        Node<E> node = new Node<E>(e);
        final ReentrantLock putLock = this.putLock;
        final AtomicInteger count = this.count;
        // 使用put锁加锁
        putLock.lockInterruptibly();
        try {
            // 如果队列满了，就阻塞在notFull上等待被其它线程唤醒（阻塞生产者线程）
            while (count.get() == capacity) {
                notFull.await();
            }
            // 队列不满，就入队
            enqueue(node);
            c = count.getAndIncrement();// 队列长度加1，返回原值
            // 如果现队列长度小于容量，notFull条件队列转同步队列，准备唤醒一个阻塞在notFull条件上的线程(可以继续入队)
            // 因为可能有很多线程阻塞在notFull这个条件上,而取元素时只有取之前队列是满的才会唤醒notFull,此处不用等到取元素时才唤醒
            if (c + 1 < capacity)
                notFull.signal();
        } finally {
            putLock.unlock(); // 真正唤醒生产者线程
        }
        // 如果原队列长度为0，现在加了一个元素后立即唤醒阻塞在notEmpty上的线程
        if (c == 0)
            signalNotEmpty();
    }
    private void enqueue(Node<E> node) {
        // 直接加到last后面,last指向入队元素
        last = last.next = node;
    }
    private void signalNotEmpty() {
        final ReentrantLock takeLock = this.takeLock;
        takeLock.lock();// 加take锁
        try {
            notEmpty.signal();// notEmpty条件队列转同步队列，准备唤醒阻塞在notEmpty上的线程
        } finally {
            takeLock.unlock(); // 真正唤醒消费者线程
        }
    }

public E take() throws InterruptedException {
        E x;
        int c = ‐1;
        final AtomicInteger count = this.count;
        final ReentrantLock takeLock = this.takeLock;
        // 使用takeLock加锁
        takeLock.lockInterruptibly();
        try {
            // 如果队列无元素，则阻塞在notEmpty条件上（消费者线程阻塞）
            while (count.get() == 0) {
                notEmpty.await();
            }
            // 否则，出队
            x = dequeue();
            c = count.getAndDecrement();//长度‐1，返回原值
            if (c > 1)// 如果取之前队列长度大于1，notEmpty条件队列转同步队列，准备唤醒阻塞在notEmpty上的线程，原因与入队同理
                notEmpty.signal();
        } finally {
            takeLock.unlock(); // 真正唤醒消费者线程
        }
        // 唤醒是需要加putLock的，这是为了减少锁的次数,所以，这里索性在放完元素就检测一下，未满就唤醒其它notFull上的线程,
        // 这也是锁分离带来的代价
        // 如果取之前队列长度等于容量（已满），则唤醒阻塞在notFull的线程
        if (c == capacity)
            signalNotFull();
        return x;
    }
    private E dequeue() {
        // head节点本身是不存储任何元素的
        // 这里把head删除，并把head下一个节点作为新的值
        // 并把其值置空，返回原来的值
        Node<E> h = head;
        Node<E> first = h.next;
        h.next = h; // 方便GC
        head = first;
        E x = first.item;
        first.item = null;
        return x;
    }
    private void signalNotFull() {
        final ReentrantLock putLock = this.putLock;
        putLock.lock();
        try {
            notFull.signal();// notFull条件队列转同步队列，准备唤醒阻塞在notFull上的线程
        } finally {
            putLock.unlock(); // 解锁，这才会真正的唤醒生产者线程
        }
    }

使用方式：同ArrayBlockingQueue 指定参数就是有界，不指定就是无界

DelayQueue

一个支持延时获取元素的阻塞队列，内部采用优先队列 PriorityQueue 存储元素，同时元素必须实现 Delayed 接口；在创建元素时可以指定多久才可以从队列中获取当前元素，只有在延迟期满时才能从队列中提取元素。延迟队列的特点是：不是先进先出，而是会按照延迟时间的长短来排序，下一个即将执行的任务会排到队列的最前面。

它是无界队列，放入的元素必须实现 Delayed 接口，而 Delayed 接口又继承了 Comparable 接口，所以自然就拥有了比较和排序的能力

SynchronousQueue

一个没有数据缓冲的BlockingQueue，生产者线程对其的插入操作 put必须等待消费者的移除操作take。每次取数据都要先阻塞，直到有数据被放入；同理，每次放数据的时候也会阻塞，直到有消费者来取。

需要注意的是，SynchronousQueue 的容量不是 1 而是 0，因为 SynchronousQueue 不需要去持有元素，它所做的就是直接传递（direct handoff）。由于每当需要传递的时候， SynchronousQueue 会把元素直接从生产者传给消费者，在此期间并不需要做存储，所以如果运用得当，它的效率是很高的。

使用场景：如果我们不确定来自生产者请求数量，但是这些请求需要很快的处理掉，那么配合SynchronousQueue为每个生产者请求分配一个消费线程是处理效率最高的办法。Executors.newCachedThreadPool()就使用了 SynchronousQueue，这个线程池根据需要（新任务到来时）创建新的线程，如果有空闲线程则会重复使用，线程空闲了60秒后会被回收。