BlockingQueue - LinkedBlockingQueue

​
LinkedBlockingQueue是一个可以有界、也可以无界的阻塞队列，以FIFO（先进先出）的方式访问队列。

head是队首节点，是进入队列时间最长的节点，tail是队尾节点，是进入队列时间最短的节点。

节点从队尾加入队列，从head出队。

LinkedBlockingQueue#主要属性

***节点：***通过内部类Node定义节点：

static class Node<E> {
	E item;
	Node<E> next;	
	Node(E x) { item = x; }
}

很简单，主要属性就两个：

next:下一节点。

item：节点包含的数据。

capacity： 队列容量，无界队列值为Integer.MAX_VALUE。

count： 队列当前节点数，AtomicInteger类型。

head： 头节点。

last： 尾结点。

takeLock： ReentrantLock，出队锁，也就是从队列获取数据的锁。

notEmpty： takeLock的Condition，协助获取数据的线程排队。

putLock： ReentrantLock，入队锁，数据加入队列的锁。

notFull： putLock的Condition，协助加入队列的线程排队。

构造方法

无参构造方法创建一个无边界空队列。

public LinkedBlockingQueue() {
	this(Integer.MAX_VALUE);
}

带容量参数capacity的构造方法创建一个有界空队列

public LinkedBlockingQueue(int capacity) {
	if (capacity <= 0) throw new IllegalArgumentException();
	this.capacity = capacity;
	last = head = new Node<E>(null);
}

集合参数构造器创建一个无界队列，将参数的集合初始化到队列中：

public LinkedBlockingQueue(Collection<? extends E> c) {
	this(Integer.MAX_VALUE);
	final ReentrantLock putLock = this.putLock;
	putLock.lock(); // Never contended, but necessary for visibility
	try {
		int n = 0;
		for (E e : c) {
			if (e == null)
				throw new NullPointerException();
			if (n == capacity)
				throw new IllegalStateException("Queue full");
			enqueue(new Node<E>(e));
			++n;
		}
		count.set(n);
	} finally {
		putLock.unlock();
	}
}

需要注意创建的队列中必然会包含一个dummy性质的head节点，所以出队列的时候这个head节点肯定也需要跳过。

put方法

元素加入队列的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);
	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();
}

首先创建Node，并尝试通过putLock.lockInterruptibly();为当前线程获取对队列的写入锁。如果获取到则会立即返回，否则当前线程阻塞等待。

拿到写入锁之后，判断如果当前队列已达容量上线（count.get() == capacity）的话，在notFull上阻塞等待。

否则，如果容量未满或者其他出队线程（从队列take数据的线程成功拿走数据之后）释放出来队列容量后唤醒当前线程后，当前节点enqueue(node)加入队列尾部。然后累加当前队列容量count，并判断如果容量未满的话，唤醒在notFull上等待容量的其他进程。

之后释放putLock锁。

最后，如果加入的节点是队列的第一个节点（c==0,空队列加入），这种情况下可能会有等待take数据的线程在阻塞等待，所以调用signalNotEmpty()唤醒阻塞的take线程。

take方法

获取数据的take方法：

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

首先获取takeLock，获取不到则阻塞等待，获取到则立即返回。

拿到take锁之后，判断如果当前队列是空队列（count.get() == 0）的话，在notEmpty上阻塞等待。

否则，如果队列不空或者其他写入线程（参考put方法，put完成之后唤醒take阻塞线程）写入队列后唤醒当前线程后，调用dequeue方法获取数据。然后重新计算（减）当前队列容量count，并判断如果队列不空的话，唤醒在notEmpty上等待数据的其他take进程。

之后释放takeLock锁。

最后，如果take之前队列已满（c == capacity），这种情况下可能会有等待put数据的线程在阻塞等待，signalNotFull()唤醒阻塞的put线程。

最后将通过dequeue()方法取出的数据返回。

dequeue()方法

获取head的次节点，获取该节点的item返回，之后头节点移出队列，次节点变成头节点，并且将变成头节点的次节点（此时其数据item已经被获取到）item置空。

private E dequeue() {
	// assert takeLock.isHeldByCurrentThread();
	// assert head.item == null;
	Node<E> h = head;
	Node<E> first = h.next;
	h.next = h; // help GC
	head = first;
	E x = first.item;
	first.item = null;
	return x;
}

从出队方法dequeue()我们需要明白以下两点：

1. 数据是从次节点（头节点的next节点）获取到的，因为头节点是dummy节点

2. 头节点移出队列，次节点清理变为dummy节点之后，再变为头节点（勇敢的站在头部装B）

3. dequeue方法是take加锁之后调用的，所以，不需要再上锁了

小结

比SynchronousQueue的源码简单多了。不过我们只分析了他的两个主要方法，对于集合类的其他方法，LinkedBlockingQueue也是支持的，代码逻辑也都相对比较简单，需要注意某些操作比如remove、contains等是需要同时获取putLock和takeLock的。其他的写入方法比如offer、数据获取方法比如poll，代码逻辑和put、take大同小异，很容易理解。

只不过阻塞队列LinkedBlockingQueue也是提供非阻塞方法的，比如poll、offer，如果offer的时候队列已满、或者poll的时候空队列，则立即返回false。

对代码理解有阻碍的地方应该是ReentrantLock和Condition，是理解LinkedBlockingQueue源码的前提。你可以参考 Java并发编程 Lock Condition & ReentrantLock（一），以及 Java并发编程 Lock Condition & ReentrantLock（二）

Thanks a lot!

​