java.util.concurrent包之 LinkedBlockingQueue 阻塞队列学习笔记

最新推荐文章于 2021-09-09 15:27:53 发布

JC. Lin

最新推荐文章于 2021-09-09 15:27:53 发布

阅读量869

点赞数

分类专栏：多线程文章标签： LinkedBlockingQueue java高并发

本文链接：https://blog.csdn.net/qq_31803503/article/details/87893390

版权

本文详细探讨了`java.util.concurrent`包中的`LinkedBlockingQueue`，讲解其类图、方法以及在高并发场景下的应用。重点分析了`put`、`take`、`offer`等操作，阐述了其在生产者-消费者模型中的作用，并结合`ThreadPoolExecutor`解释了队列在实际框架中的使用。文章还讨论了队列满和空时的安全处理策略，以及提供了一个简单的并发示例。

摘要由CSDN通过智能技术生成

LinkedBlockingQueue 类图

LinkedBlockingQueue 中也有两个 Node 分别用来存放首尾节点，并且里面有个初始值为 0 的原子变量 count 用来记录队列元素个数，另外里面有两个 ReentrantLock 的独占锁，分别用来控制元素入队和出队加锁，其中 takeLock 用来控制同时只有一个线程可以从队列获取元素，其他线程必须等待，putLock 控制同时只能有一个线程可以获取锁去添加元素，其他线程必须等待。另外 notEmpty 和 notFull 用来实现入队和出队的同步。另外由于出入队是两个非公平独占锁，所以可以同时又一个线程入队和一个线程出队，其实这个是个生产者-消费者模型，如下类图：

/** 通过 take 取出进行加锁、取出 */
private final ReentrantLock takeLock = new ReentrantLock();
/** 等待中的队列等待取出 */
private final Condition notEmpty = takeLock.newCondition();
/*通过 put 放置进行加锁、放置*/
private final ReentrantLock putLock = new ReentrantLock();
/** 等待中的队列等待放置 */
private final Condition notFull = putLock.newCondition();
/* 记录集合中的个数（计数器） */
private final AtomicInteger count = new AtomicInteger(0);

队列的容量：

//队列初始容量，Integer 最大值
public static final int MAX_VALUE = 0x7fffffff;
public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}
/**
 * 默认队列容量为 0x7fffffff;用户也可以自己指定容量。
 */
public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    //初始化首尾节点
    last = head = new Node<E>(null);
}

LinkedBlockingQueue 方法

ps：下面介绍 LinkedBlockingQueue 用到很多 Lock 对象。详细可以查找 Lock 对象的介绍

带时间的 Offer 操作-生产者

在上篇 ArrayBlockingQueue （https://blog.csdn.net/qq_31803503/article/details/87876461）中已经简单介绍了 Offer()方法，LinkedBlocking 的 Offer 方法类似，在此就不过多去介绍。这次我们从介绍下带时间的 Offer 方法

public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {
    //空元素抛空指针异常
    if (e == null) throw new NullPointerException();
    //换算时间
    long nanos = unit.toNanos(timeout);
    int c = -1;
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;
    //获取可被中断锁，只有一个线程可获取
    putLock.lockInterruptibly();
    try {
        //如果队列满则进入循环
        while (count.get() == capacity) {
            //nanos<=0 直接返回
            if (nanos <= 0)
                return false;
            //否者调用 await 进行等待，超时则返回<=0
            nanos = notFull.awaitNanos(nanos);
        }
        //await 在超时时间内返回则添加元素
        enqueue(new Node<E>(e));
        //getAndIncrement方法返回值是改动前的值，与incrementAndGet方法不同（返回改动后的值）
        c = count.getAndIncrement();
        //c+1是元素添加后总个数；队列不满则激活其他等待入队线程
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        //释放锁
        putLock.unlock();
    }
    //当 c==0 说明队列里面有一个元