JUC 之队列 LinkedBlockingQueue 详解

JUC 之队列 LinkedBlockingQueue 详解

上一篇我们讲解了 ArrayBlockingQueue 的实现原理，该篇我们来学习 LinkedBlockingQueue 的源码实现，通过名称我们可以知道它是通过链表实现的，那么具体是单向链表还是双向链表呢？这个我们就要从源码中去发现了。下面我们就开始源码之旅吧！

使用方式同 ArrayBlockingQueue ，这里就给使用示例了，直接进入源码阶段。

核心成员介绍

// 链表的数据节点信息，通过 Node 的信息我们可知 LinkedBlockingQueue 是一个单项链表实现的阻塞队列
static class Node<E> {
    E item;// 真实数据信息
    Node<E> next;// 指向下一个节点的引用
    Node(E x) { item = x; }
}
// 队列容量限制
private final int capacity;
// 记录当前队列中的元素个数
private final AtomicInteger count = new AtomicInteger();
// 队列的头结点
transient Node<E> head;
// 队列的尾结点
private transient Node<E> last;
// 获取数据线程的同步锁（消费线程的同步锁）
private final ReentrantLock takeLock = new ReentrantLock();
// 消费线程条件信息
private final Condition notEmpty = takeLock.newCondition();
// 生产者线程同步锁
private final ReentrantLock putLock = new ReentrantLock();
// 生产者线程条件信息
private final Condition notFull = putLock.newCondition();

public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node<E>(null);// 初始化头尾节点，伪节点不包含数据信息
}

通过上述源码信息我们发现 LinkedBlockingQueue 内部实现依赖两把 ReentrantLock 锁，一个 takeLock 锁用于控制消费线程并发从队列中获取数据的安全性（保证 head 引用操作的原子性）；一个 putLock 锁用于控制生产者线程并发向队列中放数据的安全性（保证 last 引用操作的原子性）。

核心方法讲解

put 方法

通过源码可知 LinkedBlockingQueue 采用的是尾插法插入数据，为了保证 last 的原子性这里使用了 putLock 锁，通过 Condition 条件控制生产者的阻塞与唤醒行为。

public void put(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    int c = -1;
    Node<E> node = new Node<E>(e);// 创建一个 Node 节点
    final ReentrantLock putLock = this.putLock;
    final AtomicInteger count = this.count;// 记录当前队列中的元素个数
    putLock.lockInterruptibly();// 获取写锁
    try {
        while (count.get() == capacity) {
            notFull.await();// 队列满了，阻塞等待
        }
        enqueue(node);// 添加到队列中
        c = count.getAndIncrement();// count 原子性加一，并返回 加一 之前的 值
        if (c + 1 < capacity)
            notFull.signal();// 说明队列还有空间，唤醒其它阻塞的生产者线程继续生产数据（只会唤醒一个）
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();// 唤醒消费线程
}

private void enqueue(Node<E> node) {
    last = last.next = node;// 单项链表操作
}

offer 方法

该方法在队列满时直接返回 false，不阻塞生产线程。LinkedBlockingQueue 还提供了一个带超时时间的offer(E e, long timeout, TimeUnit unit) 方法，这两个方法唯一的区别就在于 在队列满时是否等待一段时间，其它处理逻辑均一致。此处不在过多赘述，详细读者一看便懂。

public boolean offer(E e) {
    if (e == null) throw new NullPointerException();
    final AtomicInteger count = this.count;
    if (count.get() == capacity)
        return false;// 队列满了直接返回 false
    int c = -1;
    Node<E> node = new Node<E>(e);// 创建一个 Node 节点
    final ReentrantLock putLock = this.putLock;
    putLock.lock();
    try {
        if (count.get() < capacity) {// 表明队列还有容量
            enqueue(node);// 添加到队列中
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                notFull.signal();// 说明队列还有空间，唤醒其它阻塞的生产者线程继续生产数据（只会唤醒一个）
        }
    } finally {
        putLock.unlock();
    }
    if (c == 0)
        signalNotEmpty();// 唤醒消费线程
    return c >= 0;
}

take 方法

获取数据，当队列为空时阻塞等待。通过 takeLock 锁 和 Condition实现。

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        // 此处为啥用 while 循环？上一步不是已经获取了 takeLock 锁吗？大家可以先想一下【注 1】
        while (count.get() == 0) {
            notEmpty.await();// 队列为空时阻塞等待
        }
        x = dequeue();// 获取数据
        c = count.getAndDecrement();// 计数原子性减一
        if (c > 1)
            notEmpty.signal();// 队列中还有数据，唤醒其它消费者线程（唤醒一个）
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)// 因为 c 在上一步已经减了 1 
        signalNotFull();// 队列未满，唤醒一个生产者
    return x;
}

dequeue 方法

出队操作，从头节点取，该方法是线程安全的，单链表操作

private E dequeue() {
    Node<E> h = head;
    Node<E> first = h.next;
    h.next = h; // help GC
    head = first;// 更新头结点
    E x = first.item;
    first.item = null;
    return x;
}

poll 方法

获取数据，与 take 方法的不同之处在于 队列为空时返回 null，不会阻塞消费者线程。而 poll(long timeout, TimeUnit unit) 方法提供了阻塞等待一定时间的功能，其它逻辑同 poll 方法。

public E poll() {
    final AtomicInteger count = this.count;
    if (count.get() == 0) // 队列为空时 返回null，如果 调用的是  poll(long timeout, TimeUnit unit) 该方法，队列为空时将阻塞等待给定的时间，等待时间结束，如果还是没有数据 返回 null
        return null;
    E x = null;
    int c = -1;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        if (count.get() > 0) {
            x = dequeue();// 获取数据
            c = count.getAndDecrement();
            if (c > 1)
                notEmpty.signal();// 队列中还有数据，唤醒其它消费者线程（唤醒一个）
        }
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
        signalNotFull();// 队列未满，唤醒一个生产者
    return x;
}

remove 方法

删除指定元素，注意删除操作的时候获取了 读锁和写锁

public boolean remove(Object o) {
    if (o == null) return false;
    fullyLock();
    try {
        // 从头结点开始遍历查找，找到对应元素将其从链表中移除
        for (Node<E> trail = head, p = trail.next;
             p != null;
             trail = p, p = p.next) {
            if (o.equals(p.item)) {
                unlink(p, trail);// 从链表中移除数据
                return true;
            }
        }
        return false;
    } finally {
        fullyUnlock();
    }
}
// 单向链表操作
void unlink(Node<E> p, Node<E> trail) {
    p.item = null;
    trail.next = p.next;
    if (last == p)
        last = trail;
    if (count.getAndDecrement() == capacity)
        notFull.signal();// 唤醒 生产者
}

peek 方法

获取数据但是不会从队列中移除

public E peek() {
    if (count.get() == 0)
        return null;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        Node<E> first = head.next;
        if (first == null)
            return null;
        else
            return first.item;
    } finally {
        takeLock.unlock();
    }
}

drainTo 方法

从队列中取出指定数量的元素放入集合 c 中

public int drainTo(Collection<? super E> c, int maxElements) {
    // ... 删除了检测代码
    boolean signalNotFull = false;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lock();
    try {
        int n = Math.min(maxElements, count.get());
        Node<E> h = head;
        int i = 0;
        try {
            while (i < n) {
                Node<E> p = h.next;
                c.add(p.item);
                p.item = null;
                h.next = h;
                h = p;
                ++i;
            }
            return n;
        } finally {
            if (i > 0) {
                head = h;// 更新 头结点
                signalNotFull = (count.getAndAdd(-i) == capacity);// count 计数原子性 减 i ，两者相等表明之前队列是满的
            }
        }
    } finally {
        takeLock.unlock();
        if (signalNotFull)
            signalNotFull();// 唤醒一个生产者线程
    }
}

注 1：

还记得上述遗留的一个问题吗？take 方法中 为什么使用 while 循环判断 count 是否等于 0？在多线程并发的情况下，当生产者向队列中插入了一条数据，由于 count 使用的是 AtomicInteger 的原子类，而 Condition 的唤醒操作是将等待的线程节点先移动到锁竞争的竞争队列中，然后再去抢锁等待OS唤醒调度执行，但是在此唤醒状态过程中如果有其它线程先拿到锁把数据取走了，然后又将 count 值减为了 0，如果使用 if 条件将不会从新检测队列中的值，这时就有问题了。所以在这种场景下必须使用 while 循环来判断。