阻塞队列在日常开发中直接使用比较少,但是在很多工具类或者框架中有很多应用,例如线程池,消息队列等。所以,深入了解阻塞队列也是很有必要的。所以这里来了解一下LinkedBlockingQueue的相关源码,从命名可以看出来是由链表实现的数据结构。
类定义
public class LinkedBlockingQueue<E> extends AbstractQueue<E>
implements BlockingQueue<E>, java.io.Serializable {
}
从上面可以看到继承Queue,实现BlockingQueue,我们介绍一下两个类里面方法的作用,为了方便记忆和对比放到表格里进行展示。
Queue
作用 | 方法1 | 方法2 | 区别 |
---|---|---|---|
新增 | add() | offer() | add()队列满的时候抛出异常,offer()队列满的时候返回false |
查看并删除 | remove() | poll() | remove()队列为空的时候抛出异常,poll()队列为空的时候返回null |
查看不删除 | element() | peek() | element()队列为空的时候抛出异常,peek()队列为空的时候返回null |
BlockingQueue
BlockingQueue顾名思义带有阻塞的队列,方法有所区别,下面方法包含了Queue,因为属于继承关系,下面表格方法名用序号代替。
作用 | 方法1 | 方法2 | 方法3 | 方法4 | 区别 |
---|---|---|---|---|---|
新增 | add() | offer() | put() | offer(E e, long timeout, TimeUnit unit) | 队列满的时候,1和2作用和queue相同,3会一直阻塞,4阻塞一段时间,返回false |
查看并删除 | remove() | poll() | take() | poll(long timeout, TimeUnit unit) | 队列为空,1和2没有变化,3会一直阻塞,4会阻塞一段时间,返回null |
查看不删除 | element() | peek() | 无 | 无 | 队列为空,1和2没有变化 |
成员变量
//链表的容量,默认Integer.MAX_VALUE
private final int capacity;
//当前存在元素数量
private final AtomicInteger count = new AtomicInteger();
//链表的head节点
transient Node<E> head;
//链表的tail节点
private transient Node<E> last;
//主要用于take, poll等方法的加锁
private final ReentrantLock takeLock = new ReentrantLock();
//主要用在取值的阻塞场景
private final Condition notEmpty = takeLock.newCondition();
//主要用于put, offer等方法的加锁
private final ReentrantLock putLock = new ReentrantLock();
//主要用在新增的阻塞场景
private final Condition notFull = putLock.newCondition();
//Node比较简单,一个item,还有指向下个节点,也就是单向链表
static class Node<E> {
E item;
/**
* One of:
* - the real successor Node
* - this Node, meaning the successor is head.next
* - null, meaning there is no successor (this is the last node)
*/
Node<E> next;
Node(E x) { item = x; }
}
构造函数
//默认队列存储的元素最大为Integer.MAX_VALUE
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}
//自定义capacity,初始化head、tail
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
putLock.lock();
try {
int n = 0;
//遍历集合,每次生成一个node,添加到链表尾部
for (E e : c) {
if (e == null)
throw new NullPointerException();
//每次判断新增的节点是否超过capacity,如果是,抛出异常
if (n == capacity)
throw new IllegalStateException("Queue full");
//将节点添加到队列tail
enqueue(new Node<E>(e));
++n;
}
//设置当前元素个数count
count.set(n);
//finally解锁
} finally {
putLock.unlock();
}
}
offer()
public boolean offer(E e) {
if (e == null) throw new NullPointerException();
final AtomicInteger count = this.count;
if (count.get() == capacity)
return false;
//初始设置为-1,c < 0,表示新增失败
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;
}
流程:
- 如果e为空,抛出异常。
- 如果当前队列已满,返回false。
- 将e封装成一个新的节点,加锁,putLock。
- 再次判断队列元素数量 < capacity,然后将node添加到链表tail。
- CAS将count+1,注意这里调用的是getAndIncrement返回的是+1之前的值。如果队列没满,唤醒某个某个因为添加而阻塞的线程。
- finally解锁,如果c == 0,加锁takeLock,唤醒继续添加。
- 返回 c >= 0。
put()
相对于offer(),put的代码会判断当前队列是否满了,如果满了,通过Condition阻塞,其他没啥区别。
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();
}
//注意这里c是先获取,后-1的
if (c == capacity)
signalNotFull();
return x;
}
流程:
- 加锁,takeLock。
- 如果当前队列为空,直接通过notEmpty阻塞,等待被唤醒。
- 取出第一个元素,并删除元素。
- 如果c > 1,表示队列还有元素,唤醒别的线程获取。
- finally解锁,如果c == capacity,表示队列没满,加锁takeLock,唤醒继续添加。
- 返回 x。
enqueue and dequeue
private void enqueue(Node<E> node) {
last = last.next = node;
}
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;
}
这里统一讲一下在链表中添加和删除数据的流程,特别是dequeue(),我刚看第一眼的时候有点蒙蔽的,下面举个栗子。
BlockingQueue<Integer> queue = new LinkedBlockingDeque<>();
queue.offer(1);
queue.offer(2);
queue.offer(3);
Integer take = queue.take();
System.out.println(take);
这里把每一步都画出来了,还是比较好理解的。其余方法的逻辑都比较相似,下面简单说一下。
peek()
peek()和take()的代码差不多,只是不会删除元素,take()通过dequeue(),而peek()通过一句代码Node first = head.next;获得该节点的数据然后返回。