阻塞队列

基本概念

  阻塞队列首先是一个队列，当队列是空的时候，从队列获取元素的操作将会被阻塞，当队列是满的时候，从队列插入元素的操作将会被阻塞。消息中间件底层用的就是阻塞队列。

BlockingQueue是个接口，实际上用到的并发队列是BlockingQueue的各种实现。BlockingQueue继承自Queue，满足先进先出。

public interface BlockingQueue< E> extends Queue< E> {}

  BlockingQueue对插入操作、移除操作、获取元素操作提供了四种不同的方法用于不同的场景中使用：1、抛出异常；2、返回特殊值（null 或 true/false，取决于具体的操作）；3、阻塞等待此操作，直到这个操作成功；4、阻塞等待此操作，直到成功或者超时指定时间
  BlockingQueue 不接受 null 值的插入。BlockingQueue 是设计用来实现生产者-消费者队列的。BlockingQueue 的实现都是线程安全的，但是批量的集合操作如 addAll, containsAll, retainAll 和 removeAll 不一定是原子操作。如 addAll有可能在添加了一些元素后中途抛出异常，此时 BlockingQueue 中已经添加了部分元素，这个是允许的，取决于具体的实现。

阻塞队列好处： 在多线程领域，所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒。

阻塞队列和生产者-消费者模式
  阻塞队列（Blocking queue）提供了可阻塞的put和take方法，它们与可定时的offer和poll是等价的。如果Queue已经满了，put方法会被阻塞直到有空间可用；如果Queue是空的，那么take方法会被阻塞，直到有元素可用。Queue的长度可以有限，也可以无限；无限的Queue永远不会充满，所以它的put方法永远不会阻塞。
  阻塞队列支持生产者-消费者设计模式。生产者-消费者模式将生产者和消费者之间相互解耦。生产者把数据放入队列，并使数据可用，当消费者为适当的行为做准备时会从队列中获取数据。生产者不需要知道消费者的身份或者数量甚至根本没有消费者。类似地，消费者也不需要知道生产者是谁，以及是谁给它们安排的工作。BlockingQueue可以使用任意数量的生产者和消费者，从而简化了生产者-消费者设计的实现。最常见的生产者-消费者设计是将线程池与工作队列相结合。

阻塞队列BlockingQueue种类

ArrayBlockingQueue

  由数组结构组成的有界阻塞队列。ArrayBlockingQueue中只有take和put是阻塞的，其他方法都是直接返回，同时可以看到ArrayBlockingQueue中的lock是一个粒度很大的全局锁，每个操作方法都需要先获得锁，类似于hashtable的synchronized，不过也因为此，这里的size统计很精准

// 用于存放元素的数组
final Object[] items;
// 下一次读取操作的位置
int takeIndex;
// 下一次写入操作的位置
int putIndex;
// 队列中元素数量
int count;
// 锁保证出入队原子性
final ReentrantLock lock;
// 出队同步，等待满足非空
private final Condition notEmpty;
// 入队同步，等待满足非满
private final Condition notFull;

主要通过上面的俩个条件Condition来实现生产者与消费者的协调，condition用来与lock共同实现线程的等待通知机制。
构造函数

public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }
public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);//默认是使用ReentrantLock的非公平锁
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

offer

public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
}
private void enqueue(E x) {
        final Object[] items = this.items;
        // 元素入队
        items[putIndex] = x;
        // putIndex达到最大，调整
        if (++putIndex == items.length)
            // 队列前边的已被取走，所以putIndex达到最大可以再从0开始
            putIndex = 0;
        count++;
        // 此时满足非空，可以唤醒一个notEmpty等待队列上的元素
        notEmpty.signal();
}
1、保证元素非空
2、获得锁
3、如果队列满了，返回false，添加失败；否则，添加成功，返回true
4、释放锁，前边说过释放锁的语义，把修改的共享变量值刷回主内存 注意队列满是元素个数等于count，而非使用put/takeindex判断

put

public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length)
                // 不满足非满，等待
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }
    //如果队列满了就阻塞挂起在notFull条件队列上

以阻塞的put方法为例，首先获取锁，判断数组中元素是否已经满了，满了的话调用notFull的await方法，直到有消费者消费掉元素后调用notFull的signal方法后队列有剩余空间才能继续入队。数组有空闲容量的情况下调用enqueue方法，将元素放入数组后，调用notEmpty的signal方法，告诉消费者队列中已经有元素了，可以来消费了。

poll

public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
}
private E dequeue() {
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        // 此时取走一个元素，可以唤醒notFull上的一个线程    
        notFull.signal();
        return x;
}
//拿锁，然后取走元素，更新takeIndex，唤醒botFull，最后释放锁

take

public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }
//相比poll，take中队列是空时会阻塞挂起，poll则没有阻塞直接返回null

逻辑基本就是和put方法相反的，数组为空时，await等待，直到队列有元素时notEmpty.notify通知进行消费，消费之后通知生产者队列有空余位置。
peek

public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return itemAt(takeIndex); 
        } finally {
            lock.unlock();
        }
}
	final E itemAt(int i) {
        return (E) items[i];
    }
//同样peek也没有阻塞，直接返回队列头部元素；空的话返回null

LinkedBlockingQueue

  由链表结构组成的阻塞队列（默认大小Integer.MAX_VALUE）。LinkedBlockingQueue内部通过单链表实现，使用头尾节点进行入队和出队操作，分别采用两把锁，所以出队和入队可以同时进行的。

属性

	private final int capacity;
    // 队列中元素数量
    private final AtomicInteger count = new AtomicInteger();
    // 链表头
    private transient Node<E> head;
    // 链表尾
    private transient Node<E> last;
    //  take，poll, peek 等读操作的方法需要获取到这个锁
    private final ReentrantLock takeLock = new ReentrantLock();
    // 等非空条件满足的condition
    private final Condition notEmpty = takeLock.newCondition();
    // put, offer 等写操作的方法需要获取到这个锁
    private final ReentrantLock putLock = new ReentrantLock();
    // 等不满条件满足的condition
    private final Condition notFull = putLock.newCondition();

包括写锁和读锁，所以写操作之间和读操作之间是不会有并发问题的。
构造方法

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

构造函数中初始化了一个头节点，那么第一个元素入队的时候，队列中就会有两个元素。读取元素时，也总是获取头节点后面的一个节点。count 的计数值不包括这个头节点。
put

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 {
            // 如果队列满了，等待notFull条件满足
            while (count.get() == capacity) {
                notFull.await();
            }
            // 满足notFull，新增节点入队
            enqueue(node);
            c = count.getAndIncrement();
            if (c + 1 < capacity)
                // 如果此时仍然没满，唤醒等待在notFull上的一个线程
                notFull.signal();
        } finally {
            putLock.unlock();
        }
        if (c == 0)
            // c==0即元素入队前是空的，那么所有的读线程都在等待 notEmpty 这个条件，等待唤醒，这里做一次唤醒操作
            signalNotEmpty();
}
private void enqueue(Node<E> node) {
        // 让last指向新增元素，注意是在获取锁的情况下进行的，不存在并发问题
        last = last.next = node;
}
//如果队列满了需要等待不满，满足条件则入队。

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();
        }
        c==capacity的话，此时取走一个，就可以唤醒阻塞在notFull上的线程了
        if (c == capacity)
            signalNotFull();
        return x;
}
// 这里直接把头节点置null且指向自己，头节点的item值为null，变为新的头节点
private E dequeue() {
        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;
}
//如果队列空则等待非空，满足条件取出队列头

size

public int size() {
        return count.get();
}

其他方法大同小异，都是不再阻塞

SychronousQueue

  不存储元素的阻塞队列，即单个元素队列。同步队列指的是当一个线程往队列中写入一个元素时，写入操作不会立即返回，需要等待另一个线程来将这个元素拿走；同理，当一个读线程做读操作的时候，同样需要一个相匹配的写线程的写操作。Synchronous 指读线程和写线程需要同步，一个读线程匹配一个写线程。因此这个队列其实不存在，不提供任何空间来存储元素。数据必须从某个写线程交给某个读线程，而不是写到某个队列中等待被消费，使用上可以选择公平模式和非公平模式。

PriorityBlockingQueue

  支持优先级排序的无界阻塞队列，基于数组，数据结构为二叉堆，数组第一个也是树的根节点总是最小值。优先级队列，要实现优先级就涉及到比较大小，所以插入队列的对象必须是可以比较大小的。同样不可插入null。是无界队列，因为大小并不是固定，支持扩容操作，所以put方法不会阻塞。

DelayQueue

  无界延时队列，可以在指定时间后取出任务。使用PriorityQueue实现的延迟无界阻塞队列。延迟队列中每个元素都有过期时间，从队列获取元素时，只能获取过期元素。可以运用于以下场景：

• 缓存系统的设计 使用此队列缓存元素有效期，开一个线程查询队列，一旦获取到，表示缓存有效期到了
• 定时任务调度 使用此队列保存当天会执行的任务和时间，一旦获取到任务就执行，比如TimeQueue

该队列中的元素必须实现Delayed接口，同时必须实现compareTo方法指定元素顺序，比如让延时时间最长的元素在队列末尾。

public interface Delayed extends Comparable<Delayed> {
    long getDelay(TimeUnit unit);
}

该方法返回当前元素还需多长时间可用，去延迟队列中获取元素时，若元素没有到达延时时间就阻塞。


put的时候其实是调用了PriorityQueue的offer方法，PriorityQueue为优先级队列，底层由堆实现，DelayQueue将最先执行的任务放在队头。

取出方法首先取出队头元素判断delay时间是否小于等于0，若是则代表立即执行，若不是调用condition的awaitNanos等待相应时间后再执行。这里getDelay方法的实现是比较重要的

LinkedTransferQueue

由链表结构组成的无界阻塞队列。基于链表实现的无界Transfer队列。TransferQueue是一个生产者有可能等待消费者去接收的阻塞队列，它主要有俩个方法，transfer：如果当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法时），transfer方法可以把生产者传入的元素立刻transfer给消费者。如果没有消费者在等待接收元素，transfer方法会将元素存放在队列的tail节点，并等到该元素被消费者消费了才返回；tryTransfer：用来试探生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回false。和transfer方法的区别是tryTransfer方法无论消费者是否接收，方法立即返回。而transfer方法是必须等到消费者消费了才返回。对于带有时间限制的tryTransfer(E e, long timeout, TimeUnit unit)方法，则是试图把生产者传入的元素直接传给消费者，但是如果没有消费者消费该元素则等待指定的时间再返回，如果超时还没消费元素，则返回false，如果在超时时间内消费了元素，则返回true。

LinkedBlockingDeque

由链表结构组成的双端阻塞队列。