LinkedBlockingQueue原理分析
概述
LinkedBlockingQueue也是一个阻塞队列，相比于ArrayBlockingQueue，他的底层是使用链表实现的，而且是一个可有界可无界的队列，在生产和消费的时候使用了两把锁，提高并发，是一个高效的阻塞队列，下面就分析一下这个队列的源码。
属性
//链表节点定义
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;
/** Lock held by take, poll, etc */
//消费者的锁
private final ReentrantLock takeLock = new ReentrantLock();
/** Wait queue for waiting takes */
private final Condition notEmpty = takeLock.newCondition();
/** Lock held by put, offer, etc */
//生产者的锁
private final ReentrantLock putLock = new ReentrantLock();
/** Wait queue for waiting puts */
private final Condition notFull = putLock.newCondition();
构造方法
//默认构造方法，无界
public LinkedBlockingQueue() {
this(Integer.MAX_VALUE);
}
//可以传入容量大小，有界
public LinkedBlockingQueue(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException();
this.capacity = capacity;
last = head = new Node<E>(null);
}
消费者常用方法
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; }
进入dequeue()方法
//通过这个方法可以看出，链表的首节点的值是null，每次获取元素的时候
//先把首节点干掉，然后从第二个节点获取值
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()方法
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;
}
poll(long timeout, TimeUnit unit)
这个方法和上面的区别就是加入了时延，在规定的时间没有消费成功，就返回失败。
生产者常用方法
add()方法
public boolean add(E e) {
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
直接调用父类AbstractQueue的方法
offer(E e)方法
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;
}
进入enqueue()方法
private void enqueue(Node<E> node) {
// assert putLock.isHeldByCurrentThread();
// assert last.next == null;
last = last.next = node;
}
直接放到链表的尾部
offer(E e, long timeout, TimeUnit unit)
和poll(E e,long timeout,TimeUnit unit)相反。
put(E e)方法
public void put(E e) throws InterruptedException {
if (e == null) throw new NullPointerException();
// Note: convention in all put/take/etc is to preset local var
// holding count negative to indicate failure unless set.
int c = -1;
Node<E> node = new Node<E>(e);
final ReentrantLock putLock = this.putLock;
final AtomicInteger count = this.count;
putLock.lockInterruptibly();
try {
//如果满了，等待
while (count.get() == capacity) {
notFull.await();
}
enqueue(node);
c = count.getAndIncrement();
if (c + 1 < capacity)
notFull.signal();
} finally {
putLock.unlock();
}
if (c == 0)
signalNotEmpty();
}
总结
总体来说比较简单，下面就列一下LindedBlockingQueue的特点：
- 生产者和消费者采用不同的锁控制，提高并发效率
- 底层采用链表存储，构造方法中可以传入队列的容量，默认为无界
- 链表的首节点是一个空节点
