阻塞队列实现LinkedBlockingQueue

LinkedBlockingQueue类通过调用本地方法，实现超过容器容量，阻塞当前线程。调用栈如下：

 

LinkedBlockingQueue的增加元素方法

private final ReentrantLock putLock = new ReentrantLock();

Condition notFull = putLock.newCondition();

/**

* 通过一个内部类实现数据结构

*/

static class Node<E> {

E item;

Node<E> next;

Node(E x) { item = x; }

}

 

public void put(E e) throws InterruptedException {

if (e == null) throw new NullPointerException();

int c = -1;

Node<E> node = new Node<E>(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();

}

 

ConditionObject类例notFull类的await()方法源码如下：

public final void await() throws InterruptedException {

if (Thread.interrupted())

throw new InterruptedException();

Node node = addConditionWaiter();

int savedState = fullyRelease(node);

int interruptMode = 0;

while (!isOnSyncQueue(node)) {

LockSupport.park(this);

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

}

 

LockSupport 通过UNSAFE.putObject方法调用本地方法实现阻塞

public static void park(Object blocker) {

Thread t = Thread.currentThread();

setBlocker(t, blocker);

UNSAFE.park(false, 0L);

setBlocker(t, null);

}

 

private static void setBlocker(Thread t, Object arg) {

// Even though volatile, hotspot doesn't need a write barrier here.

UNSAFE.putObject(t, parkBlockerOffset, arg);

}