JDK8 LinkedBlockingQueue源码解析
前言
在多线程开发中，线程池是个利器，可以帮助我们管理线程和复用线程。而在线程池中，用来保存线程和任务的数据结构就是队列，如newFixedThreadPool和newSingleThreadExecutor这两个线程池使用的LinkedBlockingQueue队列，newCachedThreadPool使用的是SynchronousQueue。本文重点讲解一下LinkedBlockingQueue。
LinkedBlocingQueue的继承关系如下所示：
特点
- 基于链表的阻塞队列，底层数据结构为链表；
FIFO，新元素被放在队尾，获取元素从队首拿；- 链表大小在初始化时可以设置，不设置的话默认为
Integer.MAX_VALUE； - 既支持集合的增删改查，又支持队列的增删改查，同时兼具阻塞的特性；
成员变量
//容量
private final int capacity;
//元素数量 AtomicInteger类型 线程安全
private final AtomicInteger count = new AtomicInteger();
//头节点
transient Node<E> head;
//尾节点
private transient Node<E> last;
// take poll 操作的锁
private final ReentrantLock takeLock = new ReentrantLock();
// take 的条件队列，condition 可以简单理解为基于 ASQ 同步机制建立的条件队列
private final Condition notEmpty = takeLock.newCondition();
// put 时的锁，设计两把锁的目的，主要为了 take 和 put 可以同时进行
private final ReentrantLock putLock = new ReentrantLock();
// put 的条件队列
private final Condition notFull = putLock.newCondition();
//节点数据结构
static class Node<E> {
E item;
Node<E> next;
Node(E x) { item = x; }
}
这里需要注意的是，有两把锁，takeLock和putLock，主要是为了可以同时支持两种操作，互不影响，实现线程安全。
构造方法
//无参构造时，默认 Integer 的最大值
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}
//这里可以看出，初始化时 首尾两个节点为 null
public LinkedBlockingQueue(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException();
this.capacity = capacity;
last = head = new Node<E>(null);
}
// 已有集合数据进行初始化
public LinkedBlockingQueue(Collection<? extends E> c) {
this(Integer.MAX_VALUE);
final ReentrantLock putLock = this.putLock;
putLock.lock(); // 加锁
try {
int n = 0;
for (E e : c) {
// 传入的集合c中 元素不能为null 否则报错
if (e == null)
throw new NullPointerException();
// capacity 代表链表的大小，在这里是 Integer 的最大值
// 如果集合类的大小大于 Integer 的最大值，就会报错
// 其实这个判断完全可以放在 for 循环外面，这样可以减少 Integer 的最大值次循环(最坏情况)
if (n == capacity)
throw new IllegalStateException("Queue full");
//放入队列
enqueue(new Node<E>(e));
//更新 n
++n;
}
//设置元素个数
count.set(n);
} finally {
putLock.unlock();//解锁
}
}
//加入队列中
private void enqueue(Node<E> node) {
//last.next=node
//last=last.next
last = last.next = node;
}
常用方法
put(E e)
// 阻塞放数据
public boolean offer(E e, long timeout, TimeUnit unit)
throws InterruptedException {
//空元素直接抛出异常
if (e == null) throw new NullPointerException();
// 预先设置 c 为 -1，约定负数为新增失败
int c = -1;
//put锁
final ReentrantLock putLock = this.putLock;
//计数器
final AtomicInteger count = this.count;
// 设置可中断锁
putLock.lockInterruptibly();
try {
// 队列满了
// 当前线程阻塞，等待其他线程的唤醒(其他线程 take 成功后就会唤醒此处被阻塞的线程)
while (count.get() == capacity) {
//调用notFull的await方法，等待唤醒
notFull.awaitNanos(nanos);
}
// 队列没有满，直接新增到队列的尾部
enqueue(new Node<E>(e));
// 新增计数赋值,注意这里 getAndIncrement 返回的是旧值
// 这里的 c 是比真实的 count 小 1
c = count.getAndIncrement();
// 如果链表现在的大小 小于链表的容量，说明队列未满 此时可以继续放入数据
// 可以尝试唤醒一个 put 的等待线程
if (c + 1 < capacity)
notFull.signal();
} finally {
putLock.unlock();//释放锁
}
// c==0，代表队列里面有一个元素
// 一开始设定c=-1 如果有一个元素 count.getAndIncrement()=1，c+1=0
// 会尝试唤醒一个take的等待线程
if (c == 0)
signalNotEmpty();
return true;
}
//唤醒等待队列
private void signalNotEmpty() {
final ReentrantLock takeLock = this.takeLock;
takeLock.lock();
try {
notEmpty.signal();
} finally {
takeLock.unlock();
}
}
总结一下流程如下：
- 判断元素是否为空，空直接抛出异常，否则继续；
- 加锁，保证线程安全；
- 新增时，如果队列满了，当前线程被阻塞，阻塞使用了锁来完成；
- 新增成功之后，在适当时机,会唤起
put的等待线程（队列不满时），或者take的等待线程（队列不为空时），这样保证队列一旦满足put或者take条件时，立马就能唤起阻塞线程，继续运行，保证了唤起的时机不被浪费；
offer(E e) & offer(E e, TimeUnit unit)
这两个方法与put方法非常相似，下面附上源码，自行分析一下即可。
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();
if (c + 1 < capacity)
notFull.signal();
}
} finally {
putLock.unlock();
}
if (c == 0)
signalNotEmpty();
return c >= 0;
}
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) {
if (nanos <= 0)
return false;
nanos = notFull.awaitNanos(nanos);
}
enqueue(new Node<E>(e));
c = count.getAndIncrement();
if (c + 1 < capacity)
notFull.signal();
} finally {
putLock.unlock();
}
if (c == 0)
signalNotEmpty();
return true;
}
add(E e)
public boolean add(E e) {
//添加成功
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
take()
// 阻塞拿数据
public E take() throws InterruptedException {
E x;
// 默认负数，代表失败
int c = -1;
// count 代表当前链表数据的真实大小
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
//可中断锁
takeLock.lockInterruptibly();
try {
// 空队列时，阻塞，等待其他线程唤醒
while (count.get() == 0) {
notEmpty.await();
}
// 非空队列，从队列的头部拿一个出来
x = dequeue();
// 减一计算，注意 getAndDecrement 返回的值是旧值
// c 比真实的 count 大1
c = count.getAndDecrement();
// 如果队列里面有值，从 take 的等待线程里面唤醒一个 此时可以继续弹出元素
// 意思是队列里面有值啦,唤醒之前被阻塞的线程
// c>1 又因为c-1=count 即 count>0
if (c > 1)
notEmpty.signal();
} finally {
takeLock.unlock();//解锁
}
// 如果队列空闲还剩下一个，尝试从 put 的等待线程中唤醒一个
//count-1=c==capacity
if (c == capacity)
signalNotFull();
//返回值
return x;
}
private E dequeue() {
Node<E> h = head;
Node<E> first = h.next;
h.next = h; // 就是 he.next=null
head = first;
E x = first.item;
first.item = null;
return x;
}
private void signalNotFull() {
final ReentrantLock putLock = this.putLock;
putLock.lock();
try {
notFull.signal();
} finally {
putLock.unlock();
}
}
整体和put的流程相似，都是先加锁，然后从队列头部拿数据，如果队列为空，会一直阻塞到队里有值为止。
poll() & poll(TimeUnit unit)
这两个方法跟take很像，自行分析一下即可。
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;
}
public E poll(long timeout, TimeUnit unit) throws InterruptedException {
E x = null;
int c = -1;
long nanos = unit.toNanos(timeout);
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
takeLock.lockInterruptibly();
try {
while (count.get() == 0) {
if (nanos <= 0)
return null;
nanos = notEmpty.awaitNanos(nanos);
}
x = dequeue();
c = count.getAndDecrement();
if (c > 1)
notEmpty.signal();
} finally {
takeLock.unlock();
}
if (c == capacity)
signalNotFull();
return x;
}
remove()
public E remove() {
//获取队尾元素
E x = poll();
if (x != null)
return x;
else
throw new NoSuchElementException();
}
peek()
//获取队首元素
public E peek() {
//队列为空的话直接返回null
if (count.get() == 0)
return null;
//take锁
final ReentrantLock takeLock = this.takeLock;
//加锁
takeLock.lock();
try {
//获取链表的第一个元素
Node<E> first = head.next;
//为空的话直接返回null
if (first == null)
return null;
else//否则返回该节点的值
return first.item;
} finally {
takeLock.unlock();
}
}
element()
public E element() {
//获取队首元素
E x = peek();
if (x != null)
return x;
else
throw new NoSuchElementException();
}
总结
LinkedBlockingQueue的操作总结如下所示，在开发过程根据具体情况选择合适的方法。
