深入LinkedBlockingQueue实现原理
学习BlockingQueue之LinkedBlockingQueue实现原理
一：概念
LinkedBlockingQueue是一个用链表实现的有界阻塞队列。此队列的默认和最大长度为 Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行排序。
与ArrayBlockingQueue的异同：
ArrayBlockingQueue： 必须设置长度容量 底层数组结构 单锁控制
LinkedBlockingQueue：默认Integer最大值 底层链表结构 双锁
二：LinkedBlockingQueue源码实现
不设置容量，默认为Integer的最大值
也支持设置容量
也支持预先将集合设置入队列
两把锁，一个take锁，控制消费者并发，一个put锁，控制生产者并发：
内部维护单向链表结构：
来看一下主要方法：offer与poll
offer方法：
如果e为null或者对列已满，返回false， 然后加锁，其他的生产者会被阻塞，再次判断如果对列里面元素数量小于容量，那么入队，对列的数量也自加，
如果这时对列仍然有空间，会唤醒正在等待的其他生产者，向对列里面放数据。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
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; } |
入队方法：
如果是第一次放入数据，效果图：
主要是建立两个连接，让最后一个元素last指向新来的元素，然后将last指针指向新来的。
再来看一下poll方法：取数据
如果对列为空，返回null ，然后加锁，其他想取数据的消费者线程会被阻塞， 如果没有数据释放锁，返回null，对列有数据，则出队，对列自减，
如果出队后对列中还有数据，那么会唤醒正在等待的其他消费者线程来取数据。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
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; } |
出队方法：
返回first的item元素，这个链表的头结点维护的都是空节点，效果图如下：
出队前：
出队后：
add 和remove：
add方法： 直接使用父类AbstractQueue的方法：
在offer的基础上进行了保证，成功返回true，false的时候返回异常。
remove方法：
两把锁同时上锁，两把锁同时解锁：
来看一下删除元素的动作：因为数据结构是链表，所以只需要把指向该节点的上一个节点的next变量不指向该节点即可，然后
gc的时候就会把该节点回收掉：
trial.next = p.next 的作用就是让p节点的前一个元素直接指向p的后一个元素，而数组结构就是把该下标置为null object[takeIndex] == null
put和take方法：
put方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
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 { /* * Note that count is used in wait guard even though it is * not protected by lock. This works because count can * only decrease at this point (all other puts are shut * out by lock), and we (or some other waiting put) are * signalled if it ever changes from capacity. Similarly * for all other uses of count in other wait guards. */ while (count.get() == capacity) { notFull.await(); } enqueue(node); c = count.getAndIncrement(); if (c + 1 < capacity) notFull.signal(); } finally { putLock.unlock(); } if (c == 0) signalNotEmpty(); } |
take方法：
take方法的判断逻辑与poll基本相同，唯一区别是，如果对列没有元素，take为阻塞消费者线程，而poll会返回false。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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; } |
