欢迎使用CSDN-markdown编辑器

最近在研究blockqueue的源码，从今天开始，和大家分享一下我看源码的一些心得体会
LinkedBlockingQueue实现了BlockingQueue接口以及Serializable接口，是有序的FIFO队列，构造函数中，可传入一个最大容量值，如果没有传入，则默认是Integer.MAX_VALUE
一 首先看一下重要的几个类变量：

、、、

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();  

二 put方法

Java代码 收藏代码
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 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提供了两个方法，一个方法是可传入等待时间，另一个则没有

Java代码 收藏代码
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方法

Java代码 收藏代码
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

Java代码 收藏代码
public E peek() {
if (count.get() == 0)
return null;
final ReentrantLock takeLock = this.takeLock;
takeLock.lock();
try {
Node 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是不移除队首元素，不阻塞