并发编程之阻塞队列

一、认识阻塞队列

我们学习过数据结构的话,应该知道队列这样一种数据结构,他的特点就是陷阱先出(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();
        }
    }

四、阻塞队列总结

阻塞队列的实现是基于锁和condition实现的,所以掌握阻塞队列,需要掌握这两个只是点

链接一:ReentrantLock锁
链接二:condition线程通信

本文是综合自己的认识和参考各类资料(书本及网上资料)编写,若有侵权请联系作者,所有内容仅代表个人认知观点,如有错误,欢迎校正; 邮箱:1354518382@qq.com 博客地址:https://blog.csdn.net/qq_35576976/

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值