java.util.concurrent.LinkedBlockingQueue

一、简介

    LinkedBlockingQueue是BlockingQueue的一种使用Link List的实现，它对头和尾（取和添加操作）采用两把不同的锁，相对于ArrayBlockingQueue提高了吞吐量。它也是一种阻塞型的容器，适合于实现“消费者生产者”模式。

二、具体实现

    LinkedBlockingQueue底层的定义如下：

[java] view plain copy print ?

1. public class LinkedBlockingQueue<E> extends AbstractQueue<E>    
2.         implements BlockingQueue<E>, java.io.Serializable {    
3.    
4.     static class Node<E> {    
5.         /** The item, volatile to ensure barrier separating write and read */   
6.         volatile E item;    
7.         Node<E> next;    
8.         Node(E x) { item = x; }    
9.     }    
10.    
11.     // 支持原子操作    
12.      private final AtomicInteger count = new AtomicInteger(0);    
13.    
14.     // 链表的头和尾    
15.      private transient Node<E> head;    
16.     private transient Node<E> last;    
17.    
18.     // 针对取和添加操作的两把锁及其上的条件    
19.     private final ReentrantLock takeLock = new ReentrantLock();    
20.     private final Condition notEmpty = takeLock.newCondition();    
21.     private final ReentrantLock putLock = new ReentrantLock();    
22.     private final Condition notFull = putLock.newCondition();    
23.    
24.    ...    
25. }   

public class LinkedBlockingQueue<E> extends AbstractQueue<E>   
        implements BlockingQueue<E>, java.io.Serializable {   
  
    static class Node<E> {   
        /** The item, volatile to ensure barrier separating write and read */  
        volatile E item;   
        Node<E> next;   
        Node(E x) { item = x; }   
    }   
  
    // 支持原子操作   
     private final AtomicInteger count = new AtomicInteger(0);   
  
    // 链表的头和尾   
     private transient Node<E> head;   
    private transient Node<E> last;   
  
    // 针对取和添加操作的两把锁及其上的条件   
    private final ReentrantLock takeLock = new ReentrantLock();   
    private final Condition notEmpty = takeLock.newCondition();   
    private final ReentrantLock putLock = new ReentrantLock();   
    private final Condition notFull = putLock.newCondition();   
  
   ...   
}  

LinkedBlockingQueue的添加操作：

[java] view plain copy print ?

1. public class LinkedBlockingQueue<E> extends AbstractQueue<E>    
2.         implements BlockingQueue<E>, java.io.Serializable {    
3.    
4.     private void insert(E x) {    
5.         last = last.next = new Node<E>(x);    
6.     }    
7.    
8.     /** 
9.      * signal方法在被调用时，当前线程必须拥有该condition相关的锁! 
10.      * Signal a waiting take. Called only from put/offer (which do not 
11.      * otherwise ordinarily lock takeLock.) 
12.      */   
13.     private void signalNotEmpty() {    
14.         final ReentrantLock takeLock = this.takeLock;    
15.         takeLock.lock();    
16.         try {    
17.             notEmpty.signal();    
18.         } finally {    
19.             takeLock.unlock();    
20.         }    
21.     }    
22.    
23.     public void put(E o) throws InterruptedException {    
24.         if (o == null) throw new NullPointerException();    
25.         int c = -1;    
26.         final ReentrantLock putLock = this.putLock;    
27.         final AtomicInteger count = this.count;    
28.         // 使用putLock    
29.         putLock.lockInterruptibly();    
30.         try {    
31.             try {    
32.                   // 当容量已满时，等待notFull条件    
33.             while (count.get() == capacity)    
34.                     notFull.await();    
35.             } catch (InterruptedException ie) {    
36.                 notFull.signal(); // propagate to a non-interrupted thread    
37.                 throw ie;    
38.             }    
39.             insert(o);    
40.             // 取出当前值，并将原数据增加1    
41.             c = count.getAndIncrement();    
42.             // 容量不满，再次激活notFull上等待的put线程    
43.         if (c + 1 < capacity)    
44.                 notFull.signal();    
45.         } finally {    
46.             putLock.unlock();    
47.         }    
48.         // 必须先释放putLock再在notEmpty上signal，否则会造成死锁    
49.      if (c == 0)    
50.             signalNotEmpty();    
51.     }    
52.    
53.   ...    
54. }   

public class LinkedBlockingQueue<E> extends AbstractQueue<E>   
        implements BlockingQueue<E>, java.io.Serializable {   
  
    private void insert(E x) {   
        last = last.next = new Node<E>(x);   
    }   
  
    /**  
     * signal方法在被调用时，当前线程必须拥有该condition相关的锁!  
     * Signal a waiting take. Called only from put/offer (which do not  
     * otherwise ordinarily lock takeLock.)  
     */  
    private void signalNotEmpty() {   
        final ReentrantLock takeLock = this.takeLock;   
        takeLock.lock();   
        try {   
            notEmpty.signal();   
        } finally {   
            takeLock.unlock();   
        }   
    }   
  
    public void put(E o) throws InterruptedException {   
        if (o == null) throw new NullPointerException();   
        int c = -1;   
        final ReentrantLock putLock = this.putLock;   
        final AtomicInteger count = this.count;   
        // 使用putLock   
        putLock.lockInterruptibly();   
        try {   
            try {   
                  // 当容量已满时，等待notFull条件   
            while (count.get() == capacity)   
                    notFull.await();   
            } catch (InterruptedException ie) {   
                notFull.signal(); // propagate to a non-interrupted thread   
                throw ie;   
            }   
            insert(o);   
            // 取出当前值，并将原数据增加1   
            c = count.getAndIncrement();   
            // 容量不满，再次激活notFull上等待的put线程   
        if (c + 1 < capacity)   
                notFull.signal();   
        } finally {   
            putLock.unlock();   
        }   
        // 必须先释放putLock再在notEmpty上signal，否则会造成死锁   
     if (c == 0)   
            signalNotEmpty();   
    }   
  
  ...   
}  

LinkedBlockingQueue的取操作：

[java] view plain copy print ?

1. public class LinkedBlockingQueue<E> extends AbstractQueue<E>    
2.         implements BlockingQueue<E>, java.io.Serializable {    
3.    
4.     private E extract() {    
5.         Node<E> first = head.next;    
6.         head = first;    
7.         E x = first.item;    
8.         first.item = null;    
9.         return x;    
10.     }    
11.    
12.     private void signalNotFull() {    
13.         final ReentrantLock putLock = this.putLock;    
14.         putLock.lock();    
15.         try {    
16.             notFull.signal();    
17.         } finally {    
18.             putLock.unlock();    
19.         }    
20.     }    
21.    
22.     public E take() throws InterruptedException {    
23.         E x;    
24.         int c = -1;    
25.         final AtomicInteger count = this.count;    
26.         final ReentrantLock takeLock = this.takeLock;    
27.         // 使用takeLock    
28.         takeLock.lockInterruptibly();    
29.         try {    
30.             try {    
31.                   // 若容量为空，等待notEmpty    
32.                 while (count.get() == 0)    
33.                     notEmpty.await();    
34.             } catch (InterruptedException ie) {    
35.                 notEmpty.signal(); // propagate to a non-interrupted thread    
36.                 throw ie;    
37.             }    
38.    
39.             x = extract();    
40.             c = count.getAndDecrement();    
41.             // 再次激活notEmpty    
42.             if (c > 1)    
43.                 notEmpty.signal();    
44.         } finally {    
45.             takeLock.unlock();    
46.         }    
47.         // take执行之前容量已满，则激活notFull    
48.         if (c == capacity)    
49.             signalNotFull();    
50.         return x;    
51.     }    
52.    
53.   ...    
54. }