目录
结构:
public class LinkedBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable { private final int capacity;//queue的容量大小 private final AtomicInteger count = new AtomicInteger(0);//当前存储的数量 private transient Node<E> head;//Head of linked list. private transient Node<E> last;//Tail of linked list. private final ReentrantLock takeLock = new ReentrantLock();//取出锁 private final Condition notEmpty = takeLock.newCondition(); /** Wait queue for waiting takes */ private final ReentrantLock putLock = new ReentrantLock();//放入锁 private final Condition notFull = putLock.newCondition();/** Wait queue for waiting puts */ 原文:https://blog.csdn.net/lan861698789/article/details/81323750 static class Node<E> { E item; Node<E> next; Node(E x) { item = x; } } } |
分析:
结构包含:容量大小、存储数量大小、头节点、尾节点、put和take锁
这里的Node和linkedlist里的Node不同,这里只有next节点,没有父节点。
拥有两把锁,这是take和put不相互影响的关键。
原文:https://blog.csdn.net/lan861698789/article/details/81323750
PUT操作
public void put(E e) throws InterruptedException { 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) {//如果大小和容量一样了,表示不能放入了,要阻塞。 //While用的比if好多了。万一消费者GET时候,唤醒了多个。 notFull.await();//当前线程休息,等待signal随机唤醒。 } last = last.next = node;//赋值新元素的最后一个位置 c = count.getAndIncrement();//大小+1 if (c + 1 < capacity)//如果当前大小还是小于容量,则继续唤醒一个put线程 notFull.signal(); } finally { putLock.unlock(); } if (c == 0) {//此时队列中总共有1个node了。因为初始值是0。Put后会增加getAndIncrement signalNotEmpty();//通知take消费者,可以消费 } } 原文:https://blog.csdn.net/lan861698789/article/details/81323750 private void signalNotEmpty() { final ReentrantLock takeLock = this.takeLock; takeLock.lock(); try { notEmpty.signal(); } finally { takeLock.unlock(); } } |
分析:
流程:
1.判断是否能生产放入
2.如果不能生产,则释放当前put锁,线程阻塞等待。
3.如果能生产,则向队列尾部新增元素。
注意:
极端情况下当生产者都阻塞等待了,哪里来唤醒?
可以看take操作,在take后,会判断取操作之前的大小和容器大小一样,则signal一个生产者,让他继续工作。这个被唤醒的生产者会继续唤醒其他的生产者。
if (c == capacity) { signalNotFull();//通知一个生产者,可以生产了 } |
原文:https://blog.csdn.net/lan861698789/article/details/81323750
TAKE操作
public E take() throws InterruptedException { E x; int c = -1; final AtomicInteger count = this.count; final ReentrantLock takeLock = this.takeLock; takeLock.lockInterruptibly();//lockInterruptibly()方法是一个可以对中断进行响应的锁申请动作 try { while (count.get() == 0) {//如果大小=0,表示不能取了,要阻塞 notEmpty.await(); } //取出头元素 Node<E> h = head; Node<E> first = h.next; h.next = h; // help GC head = first; x = first.item; first.item = null;
c = count.getAndDecrement();//先赋值,再减1 if (c > 1) notEmpty.signal(); } finally { takeLock.unlock(); } if (c == capacity) { signalNotFull();//通知一个生产者,可以生产了 } return x; } private void signalNotFull() { final ReentrantLock putLock = this.putLock; putLock.lock(); try { notFull.signal();//通知生产者 } finally { putLock.unlock(); } } |
分析:
流程:
1.判断是否能消费取出
2.能,则从队列尾部取
3.不能,则释放take锁,阻塞等待被唤醒。
原文:https://blog.csdn.net/lan861698789/article/details/81323750
注意:
极端情况下当消费者都阻塞等待了,哪里来唤醒?
可以看put操作,在put后,会判断取操作之前的大小=0,则signal一个消费者,让他继续工作,这个被唤醒的消费着会继续唤醒其他的消费者。
if (c == 0) { signalNotEmpty();//通知take消费者,可以消费 } |