java LinkedBlockingQueue源码简析

阻塞队列的操作，当不能立即满足时（但将来可能会满足），有4种形式处理方式：

1抛异常；2返回特殊值；3阻塞；4等待特定时间（时间内操作被满足返回true，超时返回false）

这里分析其阻塞的处理方式。

现在来看put方法的源码

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);//创建新节点，节点中包含一个数据字段item=e，和一个指针字段next
        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) {//LinkedBlockingQueue队满时进入循环
                notFull.await();//主要包括操作三个：放入等待队列，释放锁，阻塞
            }
            enqueue(node);//入队
            c = count.getAndIncrement();//返回原值
            if (c + 1 < capacity)
                notFull.signal();//如果当前队列未满，则signal非满条件，signal操作为：将等待队列中的firstwaiter出队，并进入同步队列，检查，如果同步队列中的前一个节点已经cancelled，则unpark刚进入的这个节点（否则不对这个节点进行处理）
        } finally {
            putLock.unlock();//解锁
        }
        if (c == 0)
            signalNotEmpty();//如果队列中只有一个节点，则signal非空条件，操作如notFull.signal()
    }

public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();//将当前线程加入等待队列，并设置状态为condition
            int savedState = fullyRelease(node);//根据addConditionWaiter中新加节点可知，返回的state为condition。这里还会释放锁（即， 锁计数器减一，并unpark下一个节点（此处并不出队首节点，首节点在获取锁时出队），以便激活阻塞线程，并获得锁）
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {//不在同步队列（与等待队列区别）中时（此时线程已获得锁，必然在同步队列中，但此方法中还有一个判断条件是状态是否为condition，若是则返回false），进入循环
                LockSupport.park(this);//阻塞在这里（并放弃锁，从而使得其他线程也可阻塞在这里，即等待队列中包含多个节点（线程）），不会向下进行，当signal发生时会继续执行；中断发生时，抛出 
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

private Node addConditionWaiter() {//将线程加入等待队列，并设置状态为condition
            Node t = lastWaiter;
            // If lastWaiter is cancelled, clean out.
            if (t != null && t.waitStatus != Node.CONDITION) {
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            return node;
        }

final int fullyRelease(Node node) {//释放锁，并返回节点状态
        boolean failed = true;
        try {
            int savedState = getState();
            if (release(savedState)) {
                failed = false;
                return savedState;
            } else {
                throw new IllegalMonitorStateException();
            }
        } finally {
            if (failed)
                node.waitStatus = Node.CANCELLED;
        }
    }

public final boolean release(int arg) {
        if (tryRelease(arg)) {//尝试释放锁
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);//unpark后继线程
            return true;
        }
        return false;
    }

protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {//如果没有线程持有锁
                free = true;//释放锁成功
                setExclusiveOwnerThread(null);//设置独占线程为null
            }
            setState(c);
            return free;
        }

private void unparkSuccessor(Node node) {//unpark后继线程
        /*
         * If status is negative (i.e., possibly needing signal) try
         * to clear in anticipation of signalling.  It is OK if this
         * fails or if status is changed by waiting thread.
         */
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);

        /*
         * Thread to unpark is held in successor, which is normally
         * just the next node.  But if cancelled or apparently null,
         * traverse backwards from tail to find the actual
         * non-cancelled successor.
         */
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);
    }

Take方法细节可从put方法推出，就不分析了。

<pre name="code" class="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();//加入等待队列（与notFull.await()不是一个等待队列），释放锁，阻塞
            }
            x = dequeue();//出队
            c = count.getAndDecrement();
            if (c > 1)//队列非空
                notEmpty.signal();//notFull等待队列出队一节点，节点入队同步队列
        } finally {
            takeLock.unlock();
        }
        if (c == capacity)
            signalNotFull();
        return x;
    }