LinkedBlockingQueue源码解析

基于单向链表实现，将每一个元素封装成一个Node，Node有当前值，还有一个next指针，一般成为无界队列，LinkedBlockingQueue内部提供了读锁和写锁，读写不互斥，而且记录数据条数的属性是Atomic原子类。

核心属性介绍

public class LinkedBlockingQueue<E> extends AbstractQueue<E>
  implements BlockingQueue<E>, java.io.Serializable {

  static class Node<E> {
    E item;
    Node<E> next;
    Node(E x) {
      item = x; 
    }
  }
  // 指定队列的长度，如果不传值，默认为Integer.MAX
  private final int capacity;

  // 记录数据条数
	private final AtomicInteger count = new AtomicInteger();

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

	// 省略了很多代码...
}

主要方法简介

1、入队操作

• add(E): 如果满了，扔异常，数据丢弃

• offer(E): 入队成功返回true，入队失败返回false，数据被丢弃

• put(E): 入队失败线程挂起，直到入队成功

• offer(E, time, unit): 入队失败线程等待指定时间返回false，数据丢弃

2、出队操作

• remove()：出队失败抛出异常

• poll()：出队失败返回null

• take()：出队失败一直挂起，直到有元素出队

• poll(time, unit)：出队失败等待指定时间后返回null

源码解析

add(E)

public boolean add(E e) {
	// 直接调用offer进行处理，如果offer返回了false(队列满了)，抛异常 IllegalStateException
  if (offer(e))
    return true;
  else
    throw new IllegalStateException("Queue full");
}

offer(E)

public boolean offer(E e) {
	// 判空
  if (e == null) throw new NullPointerException();
  // 获取当前队列元素个数
  final AtomicInteger count = this.count;
  // 队列满直接返回false
  if (count.get() == capacity)
    return false;

  int c = -1;
  // 封装Node
  Node<E> node = new Node<E>(e);
  // 获取入队锁
  final ReentrantLock putLock = this.putLock;
  putLock.lock();
  try {
  	// 如果队列不满，直接入队操作，并且count+1
    if (count.get() < capacity) {
      enqueue(node);
      c = count.getAndIncrement();
      // 队列入队之后未满，则唤醒入队被挂起的线程
      if (c + 1 < capacity)
        notFull.signal();
    }
  } finally {
  	// 释放入队锁
    putLock.unlock();
  }
  // c == 0 说明添加数据之前，队列是空的，唤醒可能阻塞的出队线程
  if (c == 0)
    signalNotEmpty();
  return c >= 0;
}

private void enqueue(Node<E> node) {
	// 加到队尾
  last = last.next = node;
}

offer(E, time, unit)

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 {
  	// 队列满了，等待指定时间之后返回false
    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();
  }
  // c == 0 说明添加数据之前，队列是空的，唤醒可能阻塞的出队线程
  if (c == 0)
    signalNotEmpty();
  return true;
}

put(E)

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();
  }
  // c == 0 说明添加数据之前，队列是空的，唤醒可能阻塞的出队线程
  if (c == 0)
    signalNotEmpty();
}

remove()

public E remove() {
	// 直接调用poll，如果返回null，则抛异常 NoSuchElementException
  E x = poll();
  if (x != null)
    return x;
  else
    throw new NoSuchElementException();
}

poll()

public E poll() {
	// 如果队列count==0，则返回null
  final AtomicInteger count = this.count;
  if (count.get() == 0)
    return null;
  E x = null;
  int c = -1;
  // 获取出队锁
  final ReentrantLock takeLock = this.takeLock;
  takeLock.lock();
  try {
  	// 队列中有元素
    if (count.get() > 0) {
    	// 出队操作
      x = dequeue();
      c = count.getAndDecrement();
      // 如果出队之后还有元素，则可以唤醒其他出队阻塞的线程
      if (c > 1)
        notEmpty.signal();
    }
  } finally {
  	// 释放锁
    takeLock.unlock();
  }
  // 表示本次出队之前队列是满的，可能存在入队线程阻塞，唤醒入队线程
  if (c == capacity)
    signalNotFull();
  return x;
}

private E dequeue() {
  // 队首出队操作
  Node<E> h = head;
  Node<E> first = h.next;
  h.next = h; // 有利于GC
  head = first;
  E x = first.item;
  first.item = null; // 有利于GC
  return x;
}

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

poll(time, unit)

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 {
  	// 队列空，则等待指定时间之后，如果还是空队列，则会返回null
    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;
}