LinkedBlockingQueue 深入分析

• 导语

LinkedBlockingQueue是一个单向链表实现的阻塞队列，先进先出的顺序。支持多线程并发操作。相比于数组实现的ArrayBlockingQueue的有界，LinkedBlockingQueue可认为是无界队列。多用于任务队列。

分析要点

• 是否线程安全？
• 数据结构是怎样的？
• 怎么实现阻塞和非阻塞插入和获取元素？
• 怎么实现插入和获取元素平衡的？
• 应用与哪些场景？

深入剖析

成员变量

// 队列的总容量
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);
}

• 构造函数中初始化队列容量、头尾节点

元素的插入

• 队列的插入方式分为三种，非阻塞插入、超时阻塞插入、阻塞插入

1. offer(),一旦队列容量已满，直接返回插入失败

public boolean offer(E e) {
  if (e == null) 
    throw new NullPointerException();
  final AtomicInteger count = this.count;
  // 如果容量已满，则返回插入失败
  if (count.get() == capacity)
    return false;
  int c = -1;
  // 新增节点
  Node<E> node = new Node<E>(e);
  final ReentrantLock putLock = this.putLock;
  // 获取插入锁
  putLock.lock();
  try {
    // 如果当前容量已满，则返回插入失败
    if (count.get() < capacity) {
      // 插入元素
      enqueue(node);
      c = count.getAndIncrement();
      // 判断队列+1是否已满
      if (c + 1 < capacity)
        notFull.signal();
     }
  } finally {
    putLock.unlock();
  }
  // 代表本次插入元素成功，发送队列不为空信号
  if (c == 0)
    signalNotEmpty();
  return c >= 0;
}

private void enqueue(Node<E> node) {
  // 将node赋值给当前的last.next,再将last设置为node
  last = last.next = node;
}

2. put()，一旦队列容量已满，则进入等待，直到队列可以插入元素为止

public void put(E e) throws InterruptedException {
  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;
  putLock.lockInterruptibly();
  try {
    // 如果当前容量已满，则挂起线程进入等待，直到其他线程调用notFull.signal()
    while (count.get() == capacity) {
      notFull.await();
    }
    // 插入元素
    enqueue(node);
    c = count.getAndIncrement();
    if (c + 1 < capacity)
      notFull.signal();
    } finally {
      putLock.unlock();
    }
    if (c == 0)
      signalNotEmpty();
}

3. offer(E e, long timeout, TimeUnit unit），源码省略，只是在线程阻塞的时候，加入了一个等待时间

元素的获取

• 队列获取元素，同样有三种方式，非阻塞获取、超时阻塞获取、阻塞获取

1. poll(),当队列为空时，直接返回null

public E poll() {
  final AtomicInteger count = this.count;
  if (count.get() == 0)
    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;
}

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;
}

2. take()，一旦队列为空，则阻塞，直到从队列中获取到元素为止

public E take() throws InterruptedException {
  E x;
  int c = -1;
  final AtomicInteger count = this.count;
  final ReentrantLock takeLock = this.takeLock;
  takeLock.lockInterruptibly();
  try {
    // 如果队列为空，则线程进入阻塞等待
    while (count.get() == 0) {
      notEmpty.await();
    }
    // 获取元素
    x = dequeue();
    c = count.getAndDecrement();
    if (c > 1)
      notEmpty.signal();
    } finally {
      takeLock.unlock();
    }
    // 如果成功获取元素，则发送队列不满信号
    if (c == capacity)
      signalNotFull();
    return x;
}

3. poll(E e, long timeout, TimeUnit unit），源码省略，只是在线程阻塞的时候，加入了一个等待时间

是否线程安全

LinkedBlockingQueue 在插入和获取元素的时候，都进行了锁，所以它是线程安全的

应用场景

• LinkedBlockingQueue是一个一个基于已链接节点的、范围任意（相对而论）的 blocking queue。此队列按 FIFO（先进先出）排序元素。新元素插入到队列的尾部，并且队列获取操作会获得位于队列头部的元素。链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知的性能要低。

更多细节，请阅读LinkedBlockingQueue源码。

扫码关注了解更多