LinkedBlockingQueue实现了BlockingQueue接口以及Serializable接口,是有序的FIFO队列,构造函数中,可传入一个最大容量值,如果没有传入,则默认是Integer.MAX_VALUE
一 首先看一下重要的几个类变量:
/** 保存当前队列中元素的个数 */
private final AtomicInteger count = new AtomicInteger(0);
/**
* 头元素
* Invariant: head.item == null
*/
private transient Node<E> head;
/**
* 尾元素
* Invariant: last.next == null
*/
private transient Node<E> last;
/** 消费者锁,Lock held by take, poll, etc */
private final ReentrantLock takeLock = new ReentrantLock();
/** 使消费者线程等待,直到被唤醒或者打断 */
private final Condition notEmpty = takeLock.newCondition();
/** 生产者锁,Lock held by put, offer, etc */
private final ReentrantLock putLock = new ReentrantLock();
/** 使生产者线程等待,直到被唤醒或者打断 */
private final Condition notFull = putLock.newCondition();
二 put方法解读
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);
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();
}
执行过程如下:
1 如果传入元素为空,抛出空指针异常
2 获得put的锁,以及原子的count,然后lock,注意,是可打断的lock
3 判断当前队列是否饱和,若饱和,生产者线程进入等待状态
4 如果队列不饱和,则将元素包装为一个node放到队列中
5 count+1,如果count+1仍然小于队列的最大容量,则生产者线程被唤醒
6 在finnally中释放锁,最后唤醒消费者,提醒消费者可以从队列中取对象了
三 offer方法
offer提供了两个方法,一个方法是可传入等待时间,另一个则没有
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;
}
执行过程如下:
1 如果传入元素为空,抛出空指针异常
2 根据传入的timeout和unit计算出最长等待的时间
3 获得put的锁,以及原子的count,表示当前队列中的元素个数,然后lock,注意,是可打断的lock
4 如果队列饱和,则超过等待时间后,直接返回false
5 以下处理构成同put
另外一个不带参数的方法,如果判断队列饱和,直接返回false,不阻塞
四 take方法
java代码
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;
}
执行过程如下:
1 获得put的锁,以及原子的count,表示当前队列中的元素个数,然后lock,注意,是可打断的lock
2 如果当前队列为空,则阻塞
3 如果非空,则元素出列,count-1,如果count>1,表示队列非空,则消费者线程被唤醒
4 在finally中释放lock,唤醒生产者生产
五 pool方法
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;
}
执行过程如下:
1 获得put的锁,以及原子的count,表示当前队列中的元素个数,然后lock,注意,是可打断的lock
2 如果当前队列为空,则线程阻塞,并等待指定时间,如果在指定时间还是空,则直接返回空
3 以下过程同take
pool也提供了不带参数的方法,表示如果队列为空,则直接返回null,不阻塞
六 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();
}
}
不阻塞,不移除队首元素
个人学习总结:
根据以上源码分析,得出方法之间的异同:
(1) 生产者方法:put,offer
(2)消费者方法:take,poll,peek
(3)put方法中,如果队列始终饱和,则当前线程会一直等待,直到有对象出列
offer(可传入等待时间),如果队列饱满,会等待指定的时间,如果在指定时间内还饱满,则直接返回false
offer(没有参数),如果队列饱满,直接返回false,线程不等待
put和offer(可传入等待时间)都是可被打断的
(4)take在队列为空时,会始终阻塞
poll分为带等待时间和不带的,如果不带等待时间,则不阻塞,移除队首元素(FIFO)
peek是不移除队首元素,不阻塞