【JUC源码解析】LinkedBlockingQueue

简介

一个基于链表的阻塞队列,FIFO的顺序,head指向的元素等待时间最长,tail指向的元素等待时间最短,新元素从队列尾部添加,检索元素从队列头部开始,队列的容量,默认是Integer#MAX_VALUE。

源码分析

内部类Node

1     static class Node<E> {
2         E item; // 结点的值
3 
4         Node<E> next; // 指向下一个结点
5 
6         Node(E x) { // 构造方法
7             item = x;
8         }
9     }

属性

 1     private final int capacity; // 队列的容量,大小
 2 
 3     private final AtomicInteger count = new AtomicInteger(); // 当前队列里元素的个数
 4 
 5     transient Node<E> head; // 头结点,head.item = null
 6 
 7     private transient Node<E> last; // 尾结点,last.next = null
 8 
 9     private final ReentrantLock takeLock = new ReentrantLock(); // 可重入锁,take元素时,需持有该锁
10 
11     private final Condition notEmpty = takeLock.newCondition(); // take锁上的条件,队列空时等待,不空时通知
12 
13     private final ReentrantLock putLock = new ReentrantLock(); // 可重入锁,put元素时,需持有该锁
14 
15     private final Condition notFull = putLock.newCondition(); // put锁上的条件,队列满时等待,不满时通知

 

通知方法

 1     private void signalNotEmpty() { // 通知在take锁上等待的线程
 2         final ReentrantLock takeLock = this.takeLock;
 3         takeLock.lock(); // 加锁
 4         try {
 5             notEmpty.signal(); // 通知
 6         } finally {
 7             takeLock.unlock(); // 释放
 8         }
 9     }
10 
11     private void signalNotFull() { // 通知在put锁上等待的线程
12         final ReentrantLock putLock = this.putLock;
13         putLock.lock(); // 加锁
14         try {
15             notFull.signal(); // 通知
16         } finally {
17             putLock.unlock(); // 释放
18         }
19     }

 

元素入队

1     private void enqueue(Node<E> node) { // 队尾入队
2         last = last.next = node; // last的next域指向新结点,last后移(指向新加入的结点)
3     }

 

元素出队

1     private E dequeue() { // 队首出队
2         Node<E> h = head; // 获得头结点
3         Node<E> first = h.next; // 活动第一个有效(item != null)结点(head结点的next结点)
4         h.next = h; // next域指向自己,帮助GC
5         head = first; // head后移
6         E x = first.item; // 取得结点值
7         first.item = null; // 置空
8         return x; // 返回
9     }

加锁与释放

1     void fullyLock() { // 加锁
2         putLock.lock();
3         takeLock.lock();
4     }
5 
6     void fullyUnlock() { // 释放
7         takeLock.unlock();
8         putLock.unlock();
9     }

 

构造方法

 1     public LinkedBlockingQueue() { // 构造方法
 2         this(Integer.MAX_VALUE);
 3     }
 4 
 5     public LinkedBlockingQueue(int capacity) { // 构造方法
 6         if (capacity <= 0)
 7             throw new IllegalArgumentException();
 8         this.capacity = capacity;
 9         last = head = new Node<E>(null); // 初始时,last和head指向一个DUMMY结点
10     }
11 
12     public LinkedBlockingQueue(Collection<? extends E> c) {
13         this(Integer.MAX_VALUE);
14         final ReentrantLock putLock = this.putLock;
15         putLock.lock(); // 加锁,可见性
16         try {
17             int n = 0;
18             for (E e : c) {
19                 if (e == null)
20                     throw new NullPointerException(); // 空指针
21                 if (n == capacity)
22                     throw new IllegalStateException("Queue full"); // 越界
23                 enqueue(new Node<E>(e)); // 元素入队
24                 ++n; // 递增
25             }
26             count.set(n); // 设置当前队列里元素的个数
27         } finally {
28             putLock.unlock(); // 解锁
29         }
30     }

添加元素

put(E e)

 1     public void put(E e) throws InterruptedException { // 添加元素
 2         if (e == null)
 3             throw new NullPointerException(); // 空指针
 4         int c = -1;
 5         Node<E> node = new Node<E>(e); // 创建新结点
 6         final ReentrantLock putLock = this.putLock; // 获得put锁
 7         final AtomicInteger count = this.count; // 获得当前元素的个数
 8         putLock.lockInterruptibly(); // 加锁,响应中断
 9         try {
10             while (count.get() == capacity) { // 队列满了
11                 notFull.await(); // 要等一等
12             }
13             enqueue(node); // 入队
14             c = count.getAndIncrement(); // 获取队列的容量
15             if (c + 1 < capacity) // 不满,唤醒等待的线程
16                 notFull.signal(); // 通知
17         } finally {
18             putLock.unlock(); // 解锁
19         }
20         if (c == 0) // 队列非空(c初始值为-1)
21             signalNotEmpty();
22     }

 

offer(E e, long timeout, TimeUnit unit)

 1     public boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException {
 2 
 3         if (e == null)
 4             throw new NullPointerException(); // 空指针
 5         long nanos = unit.toNanos(timeout);
 6         int c = -1;
 7         final ReentrantLock putLock = this.putLock; // 获得put锁
 8         final AtomicInteger count = this.count; // 获得当前元素的个数
 9         putLock.lockInterruptibly(); // 加锁,响应中断
10         try {
11             while (count.get() == capacity) { // 队列满了
12                 if (nanos <= 0) // 超时,返回
13                     return false;
14                 nanos = notFull.awaitNanos(nanos); // 等待响应的时间
15             }
16             enqueue(new Node<E>(e)); // 入队
17             c = count.getAndIncrement(); // 获取队列的容量
18             if (c + 1 < capacity) // 不满,唤醒等待的线程
19                 notFull.signal(); // 通知
20         } finally {
21             putLock.unlock(); // 解锁
22         }
23         if (c == 0)
24             signalNotEmpty(); // 队列非空(c初始值为-1)
25         return true;
26     }

 

offer(E e)

 1     public boolean offer(E e) {
 2         if (e == null)
 3             throw new NullPointerException(); // 空指针
 4         final AtomicInteger count = this.count; // 获得当前元素的个数
 5         if (count.get() == capacity) // 队列满了,直接返回失败
 6             return false;
 7         int c = -1;
 8         Node<E> node = new Node<E>(e); // 新建结点
 9         final ReentrantLock putLock = this.putLock; // 获得put锁
10         putLock.lock(); // 加锁
11         try {
12             if (count.get() < capacity) { // 不满
13                 enqueue(node); // 入队
14                 c = count.getAndIncrement(); // 加1
15                 if (c + 1 < capacity) // 不满,通知
16                     notFull.signal();
17             }
18         } finally {
19             putLock.unlock(); // 解锁
20         }
21         if (c == 0)
22             signalNotEmpty(); // 不空,通知
23         return c >= 0;
24     }

 

获取元素

take()

 1     public E take() throws InterruptedException {
 2         E x;
 3         int c = -1;
 4         final AtomicInteger count = this.count; // 当前队列元素个数
 5         final ReentrantLock takeLock = this.takeLock; // 获取take锁
 6         takeLock.lockInterruptibly(); // 加锁,响应中断
 7         try {
 8             while (count.get() == 0) { // 队列空了
 9                 notEmpty.await(); // 等待
10             }
11             x = dequeue(); // 出队
12             c = count.getAndDecrement(); // 减1
13             if (c > 1) // 不空
14                 notEmpty.signal(); // 通知
15         } finally {
16             takeLock.unlock(); // 解锁
17         }
18         if (c == capacity) // 获取元素之前,队列是满的,有线程在put元素时阻塞,当前线程take一个元素后,空出一个位置
19             signalNotFull(); // 通知
20         return x;
21     }

poll(long timeout, TimeUnit unit)

 1     public E poll(long timeout, TimeUnit unit) throws InterruptedException {
 2         E x = null;
 3         int c = -1;
 4         long nanos = unit.toNanos(timeout); // 计算等待时间
 5         final AtomicInteger count = this.count; // 当前队列元素个数
 6         final ReentrantLock takeLock = this.takeLock; // 获得take锁
 7         takeLock.lockInterruptibly(); // 加锁,响应中断
 8         try {
 9             while (count.get() == 0) { // 队列空了
10                 if (nanos <= 0) // 超时
11                     return null;
12                 nanos = notEmpty.awaitNanos(nanos); // 等待指定时间
13             }
14             x = dequeue(); // 出队
15             c = count.getAndDecrement(); // 个数减1
16             if (c > 1) // 非空
17                 notEmpty.signal(); // 通知
18         } finally {
19             takeLock.unlock();
20         }
21         if (c == capacity) // 同take()方法
22             signalNotFull();
23         return x;
24     }

poll()

 1     public E poll() {
 2         final AtomicInteger count = this.count; // 当前队列元素个数
 3         if (count.get() == 0) // 队列空了,直接返回
 4             return null;
 5         E x = null;
 6         int c = -1;
 7         final ReentrantLock takeLock = this.takeLock; // 获得take锁
 8         takeLock.lock(); // 加锁
 9         try {
10             if (count.get() > 0) { // 非空
11                 x = dequeue(); // 元素出队
12                 c = count.getAndDecrement(); // 个数减1
13                 if (c > 1) // 非空,通知
14                     notEmpty.signal();
15             }
16         } finally {
17             takeLock.unlock(); // 解锁
18         }
19         if (c == capacity)
20             signalNotFull(); // 同take()方法
21         return x;
22     }

peek()

 1     public E peek() { // 只获取元素,不出队
 2         if (count.get() == 0) // 队列为空,直接返回null
 3             return null;
 4         final ReentrantLock takeLock = this.takeLock; // 获得take锁
 5         takeLock.lock(); // 解锁
 6         try {
 7             Node<E> first = head.next; // 取得第一个有效元素
 8             if (first == null) // 为空,直接返回null
 9                 return null;
10             else
11                 return first.item; // 返回结果
12         } finally {
13             takeLock.unlock(); // 解锁
14         }
15     }

剔除结点p

1     void unlink(Node<E> p, Node<E> trail) { // 剔除结点p
2         p.item = null; // 置空
3         trail.next = p.next; // 断开p, 连接p的next结点
4         if (last == p) // 如果p是尾结点,last指针前移
5             last = trail;
6         if (count.getAndDecrement() == capacity) // 同take()方法
7             notFull.signal();
8     }

 

删除元素

 1     public boolean remove(Object o) { // 删除元素o
 2         if (o == null)
 3             return false;
 4         fullyLock(); // 加锁
 5         try { // 从头结点开始遍历,找寻o元素所在的结点,并从中剔除它
 6             for (Node<E> trail = head, p = trail.next; p != null; trail = p, p = p.next) {
 7                 if (o.equals(p.item)) {
 8                     unlink(p, trail); // 剔除
 9                     return true;
10                 }
11             }
12             return false;
13         } finally {
14             fullyUnlock(); // 解锁
15         }
16     }

 

迁徙

 1     public int drainTo(Collection<? super E> c, int maxElements) { // 将当前队列里的元素移动到c中,并从当前队列里清除这些元素
 2         if (c == null)
 3             throw new NullPointerException(); // 空指针
 4         if (c == this)
 5             throw new IllegalArgumentException(); // 不合法参数
 6         if (maxElements <= 0) // 参数校验
 7             return 0;
 8         boolean signalNotFull = false;
 9         final ReentrantLock takeLock = this.takeLock; // 获得take锁
10         takeLock.lock(); // 加锁
11         try {
12             int n = Math.min(maxElements, count.get()); // 取其中较小值
13             Node<E> h = head; // 头结点
14             int i = 0; // 初始值
15             try {
16                 while (i < n) {
17                     Node<E> p = h.next; // 取得元素
18                     c.add(p.item); // 添加到集合c中
19                     p.item = null; // 置空
20                     h.next = h; // 结点next域指向自己,帮助GC
21                     h = p;  // 元素出队
22                     ++i; // 自增
23                 }
24                 return n; // 返回
25             } finally {
26                 if (i > 0) {
27                     head = h; // 更新头节点
28                     signalNotFull = (count.getAndAdd(-i) == capacity); // 需要通知
29                 }
30             }
31         } finally {
32             takeLock.unlock(); // 解锁
33             if (signalNotFull)
34                 signalNotFull(); // 通知
35         }
36     }

 

行文至此结束。

 

尊重他人的劳动,转载请注明出处:http://www.cnblogs.com/aniao/p/aniao_lbq.html

posted @ 2018-03-11 16:13  林城画序  阅读(160)  评论(0编辑  收藏