并发编程之阻塞队列

最新推荐文章于 2021-01-27 16:29:24 发布

MR~许先生

最新推荐文章于 2021-01-27 16:29:24 发布

阅读量129

点赞数

分类专栏：多线程文章标签： java 队列

本文链接：https://blog.csdn.net/qq_35576976/article/details/106608830

版权

多线程专栏收录该内容

21 篇文章 0 订阅

订阅专栏

一、认识阻塞队列

我们学习过数据结构的话，应该知道队列这样一种数据结构，他的特点就是陷阱先出（FIFO），那么什么是阻塞队列呢？
我们可以想象下面两种场景
场景一： 向队列里面添加元素的时候，队列满了
场景二： 从队列获取元素, 但是队列为空
按场景一来说，如果队列满了，我们再往里面添加的话，应该添加不进去，那么改怎么处理呢，是报错，还是等待队列有空闲位置（有数据被取出）的时候加到队列里面？
按场景二来说，如果队列为空的时候，我们取数据，直接返回null，还是等待直到队列里面有数据了，返回第一个数据呢
其实针对上述两种场景，普通的队列有一些默认实现，但是在多线程这一章节，基于队列实现了一种阻塞队列。
那什么是阻塞队列呢？从名字可以看出阻塞队列其实也就是队列的一种特殊情况，只不过是添加了阻塞的效果，它主要由以下两个特点：
1）支持阻塞的插入方法：意思是当队列满时，队列会阻塞插入元素的线程，直到队列不满。

2）支持阻塞的移除方法：意思是在队列为空时，获取元素的线程会等待队列变为非空
阻塞队列的学习有助于我们对一些中间件的理解，在生产者-消费者模式中广泛应用

二、阻塞队列示例

我们用一个非常简单的例子来掩饰阻塞队列的阻塞效果，首先我们创建一个队列，然后直接用take()方法取值

public class Demo {

    static BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);

    public static void main(String[] args) throws InterruptedException {
        blockingQueue.take();
    }
}

运行效果，我们从控制台可以看到，程序一直在运行状态未结束，说明被阻塞了，因为队列为空，所以取值的时候就被阻塞了
在这里插入图片描述
然后我们再测试一种添加元素被阻塞情况，我们创建一个容量为1的阻塞队列，通过代码块给他添加一个元素，再通过在main方法里面添加元素，代码如下

public class Demo {

    static BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);

    static{
        try {
            blockingQueue.put("存放元素");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        blockingQueue.put("测试添加元素");
    }
}

会发现效果同样是被阻塞了
在这里插入图片描述
然后我们模拟一个生产者-消费者的模型

生产者代码：

public class Product extends Thread{
    private ArrayBlockingQueue<String> blockingQueue;

    public Product(ArrayBlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    @Override
    public void run() {
        try {
            System.out.println("添加元素成功");
            blockingQueue.put("添加元素");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

消费者代码

public class Consumer extends Thread{

    private ArrayBlockingQueue<String> blockingQueue;

    public Consumer(ArrayBlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    @Override
    public void run() {
        try {
            System.out.println("取值成功-"+blockingQueue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

测试代码

public class Test {
    public static void main( String[] args ) throws InterruptedException {
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);
        Product product = new Product(queue);
        Consumer consumer = new Consumer(queue);
        consumer.start();  // 先从队列取值线程
        Thread.sleep(1000);
        product.start();   // 然后再往队列添加值线程
    }
}

执行多次效果都一样，先打印添加元素，再取出元素

添加元素成功
取值成功-添加元素

Process finished with exit code 0

其实在阻塞队列里面提供了很多阻塞方法，我这里只是以put()和take()方法演示的，以下是总结的阻塞队列方法和区别
在这里插入图片描述

三、阻塞队列原理-源码分析

我们分析一下阻塞队列的源码，来看一下阻塞队列是怎么实现的，以ArrayBlockingQueue为例，以下代码中，是我从源码中抽取的核心代码

public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable  {
    // 定义一个数组，存储元素
    final Object[] items;
    // 定义获取元素的指针
    int takeIndex;
    // 定义存放元素的指针
    int putIndex;
    // 定义元素数量
    int count;
    // 定义一个重入锁
    final ReentrantLock lock;
    // 定义了一个数组元素不能为空的Condition条件
    private final Condition notEmpty;
    // 定义了一个数组元素不能满了的Condition条件
    private final Condition notFull;

    // 定义一个构造函数
    public ArrayBlockingQueue(int capacity, boolean fair){
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        // 调用构造函数的时候初始化锁和Condition条件
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }
    // 添加元素的方法
    public void put(E e) throws InterruptedException{
        final ReentrantLock lock = this.lock;
        // 因为方法阻塞的时候可能会被中断，所以不是调用lock.lock()方法，lockInterruptibly()方法在线程被中断时会抛出异常
        lock.lockInterruptibly();
        try {
            // 如果当前队列满了，调用notFull条件的await()方法阻塞
            if (count == items.length){
                notFull.await();
            }else {
                // 队列不满，添加元素进队列
                enqueue(e);
            }
        } finally {
            lock.unlock();
        }
    }

    // 定义一个获取元素的阻塞方法
    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
         // 因为方法阻塞的时候可能会被中断，所以不是调用lock.lock()方法，lockInterruptibly()方法在线程被中断时会抛出异常
        lock.lockInterruptibly();
        try {
        	// 如果当前队列元素为空，调用notEmpty条件await()方法阻塞
            while (count == 0) {  
                notEmpty.await();
            }
            return dequeue(); // 不为空的话，就取出元素
        } finally {
            lock.unlock();
        }
    }

    // 添加一个元素进队列
    private void enqueue(E x) {
        final Object[] items = this.items;
        // 把元素放在此位置
        items[putIndex] = x;
        // 存放元素的指针+1
        putIndex+=1;
        // 判断队列是否已满，如果满了的话，把指针从头开始
        if (putIndex == items.length) {
            putIndex = 0;
        }
        // 元素个数+1
        count++;
        // 如果在第一个元素添加之前，可能有获取过元素，然后被阻塞了，此处调用notEmpty条件的signal()方法唤醒获取元素的方法
        notEmpty.signal();
    }


    // 取出当前队列中的一个元素
    private E dequeue() {
        final Object[] items = this.items;
        // 取出获取指针指向的元素
        E x = (E) items[takeIndex];
        // 将当前位置元素置为null
        items[takeIndex] = null;
        // 获取指针+1
        ++takeIndex;
        // 如果获取指针的位置到了最后一个元素，再下一个元素就是从0开始
        if (takeIndex == items.length) {
            takeIndex = 0;
        }
        // 取出元素后，数量-1
        count--;
        // 调用notEmpty条件的signal()方法唤醒队列满时，仍然添加元素时被阻塞的线程
        notFull.signal();
        return x;
    }
}

以上就是阻塞队列put()/take()方法的核心原理，我们可以看到，阻塞队列是基于lock锁和Condition条件实现的，至于其他方法，如offer方法，核心代码一样，无非是临界点（队列满或者队列为空）的时候处理方式不一样而已

public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
            // 此处是返回false，而不是阻塞
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }