六：阻塞队列的理解

1.阻塞队列有哪些

强烈推荐参考：https://www.cnblogs.com/bjxq-cs88/p/9759571.html

队列	有界性	锁	数据结构
ArrayBlockingQueue	bounded(有界)	加锁	arrayList
LinkedBlockingQueue	optionally-bounded	加锁	linkedList
PriorityBlockingQueue	unbounded	加锁	heap
DelayQueue	unbounded	加锁	heap
SynchronousQueue	bounded	加锁	无
LinkedTransferQueue	unbounded	加锁	heap
LinkedBlockingDeque	unbounded	无锁	heap

下面分别简单介绍一下：

• ArrayBlockingQueue：是一个基于数组结构的有界阻塞队列，此队列按 FIFO（先进先出）对元素进行排序。
• LinkedBlokcingQueue：是一个基于链表结构的阻塞队列，此队列按 FIFO（先进先出）对元素进行排序，吞吐量通常要高于 ArrayBlockingQueue。
• SynchronousQueue：是一个不存储元素的阻塞队列，每个插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，吞吐量通常要高于 LinkedBlokcingQueue； 支持公平锁和非公平锁。SynchronousQueue的一个使用场景是在线程池里。Executors.newCachedThreadPool()就使用了SynchronousQueue，这个线程池根据需要（新任务到来时）创建新的线程，如果有空闲线程则会重复使用，线程空闲了60秒后会被回收。
• LinkedTransferQueue： 一个由链表结构组成的无界阻塞队列，相当于其它队列，LinkedTransferQueue队列多了transfer和tryTransfer方法。
• LinkedBlockingDeque： 一个由链表结构组成的双向阻塞队列。队列头部和尾部都可以添加和移除元素，多线程并发时，可以将锁的竞争最多降到一半。
• PriorityBlockingQueue： 一个支持线程优先级排序的无界队列，默认自然序进行排序，也可以自定义实现compareTo()方法来指定元素排序规则，不能保证同优先级元素的顺序。
• DelayQueue： 一个实现PriorityBlockingQueue实现延迟获取的无界队列，在创建元素时，可以指定多久才能从队列中获取当前元素。只有延时期满后才能从队列中获取元素。（DelayQueue可以运用在以下应用场景：1.缓存系统的设计：可以用DelayQueue保存缓存元素的有效期，使用一个线程循环查询DelayQueue，一旦能从DelayQueue中获取元素时，表示缓存有效期到了。2.定时任务调度。使用DelayQueue保存当天将会执行的任务和执行时间，一旦从DelayQueue中获取到任务就开始执行，从比如TimerQueue就是使用DelayQueue实现的。）

2.什么是阻塞队列

• 阻塞队列，顾名思义，首先它是一个队列，而一个阻塞队列在数据结构中所起的作用大致如图所示：

• 当阻塞队列是空时，从队列中获取元素的操作将会被阻塞。

• 当阻塞队列是满时，往队列里添加元素的操作将会被阻塞。

• 核心接口

  public interface BlockingQueue<E> extends Queue<E> {
      //将给定元素设置到队列中，如果设置成功返回true, 否则抛出异常。如果是往限定了长度的队列中设置值，推荐使用offer()方法。
      boolean add(E e);
      //将给定的元素设置到队列中，如果设置成功返回true, 否则返回false. e的值不能为空，否则抛出空指针异常。
      boolean offer(E e);
      //将元素设置到队列中，如果队列中没有多余的空间，该方法会一直阻塞，直到队列中有多余的空间。
      void put(E e) throws InterruptedException;
      //将给定元素在给定的时间内设置到队列中，如果设置成功返回true, 否则返回false.
      boolean offer(E e, long timeout, TimeUnit unit)
          throws InterruptedException;
      //从队列中获取值，如果队列中没有值，线程会一直阻塞，直到队列中有值，并且该方法取得了该值。
      E take() throws InterruptedException;
      //在给定的时间里，从队列中获取值，如果没有取到会抛出异常。
      E poll(long timeout, TimeUnit unit)
          throws InterruptedException;
      //获取队列中剩余的空间。
      int remainingCapacity();
      //从队列中移除指定的值。
      boolean remove(Object o);
      //判断队列中是否拥有该值。
      public boolean contains(Object o);
      //将队列中值，全部移除，并发设置到给定的集合中。
      int drainTo(Collection<? super E> c);
      //指定最多数量限制将队列中值，全部移除，并发设置到给定的集合中。
      int drainTo(Collection<? super E> c, int maxElements);
  }
  

• 核心方法

  方法\行为	抛异常	特定的值	阻塞	超时
  插入方法	add(o)	offer(o)	put(o)	offer(o, timeout, timeunit)
  移除方法	remove()	poll()	take()	poll(timeout, timeunit)
  检查方法	element()	peek()	不可用	不可用

• 行为解释：

  • 抛异常：如果操作不能马上进行，则抛出异常
  • 特定的值：如果操作不能马上进行，将会返回一个特殊的值，一般是 true 或者 false
  • 阻塞：如果操作不能马上进行，操作会被阻塞
  • 超时：如果操作不能马上进行，操作会被阻塞指定的时间，如果指定时间没执行，则返回一个特殊值，一般是 true 或者 false

• 插入方法：

  • add(E e)：添加成功返回true，失败抛 IllegalStateException 异常
  • offer(E e)：成功返回 true，如果此队列已满，则返回 false
  • put(E e)：将元素插入此队列的尾部，如果该队列已满，则一直阻塞

• 删除方法：

  • remove(Object o) ：移除指定元素,成功返回true，失败返回false
  • poll()：获取并移除此队列的头元素，若队列为空，则返回 null
  • take()：获取并移除此队列头元素，若没有元素则一直阻塞

• 检查方法：

  • element() ：获取但不移除此队列的头元素，没有元素则抛异常
  • peek() :获取但不移除此队列的头；若队列为空，则返回 null

3.SynchronousQueue

SynchronousQueue，实际上它不是一个真正的队列，因为它不会为队列中元素维护存储空间。与其他队列不同的是，它维护一组线程，这些线程在等待着把元素加入或移出队列。

public class SynchronousQueueDemo {

    public static void main(String[] args) {
        SynchronousQueue<Integer> synchronousQueue = new SynchronousQueue<>();
        new Thread(() -> {
            try {
                synchronousQueue.put(1);
                Thread.sleep(3000);
                synchronousQueue.put(2);
                Thread.sleep(3000);
                synchronousQueue.put(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                Integer val = synchronousQueue.take();
                System.out.println(val);
                Integer val2 = synchronousQueue.take();
                System.out.println(val2);
                Integer val3 = synchronousQueue.take();
                System.out.println(val3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

使用场景

• 生产者消费者模式
• 线程池
• 消息中间件

4.synchronized 和 Lock 区别

• 原始结构
  • synchronized 是关键字属于 JVM 层面，反应在字节码上是 monitorenter 和 monitorexit，其底层是通过 monitor 对象来完成，其实 wait/notify 等方法也是依赖 monitor 对象只有在同步快或方法中才能调用 wait/notify 等方法。
  • Lock 是具体类（java.util.concurrent.locks.Lock）是 api 层面的锁。
• 使用方法
  • synchronized 不需要用户手动去释放锁，当 synchronized 代码执行完后系统会自动让线程释放对锁的占用。
  • ReentrantLock 则需要用户手动的释放锁，若没有主动释放锁，可能导致出现死锁的现象，lock() 和 unlock() 方法需要配合 try/finally 语句来完成。
• 等待是否可中断
  • synchronized 不可中断，除非抛出异常或者正常运行完成。
  • ReentrantLock 可中断，设置超时方法 tryLock(long timeout, TimeUnit unit)，lockInterruptibly() 放代码块中，调用 interrupt() 方法可中断。
• 加锁是否公平
  • synchronized 非公平锁
  • ReentrantLock 默认非公平锁，构造方法中可以传入 boolean 值，true 为公平锁，false 为非公平锁。
• 锁可以绑定多个 Condition
  • synchronized 没有 Condition。
  • ReentrantLock 用来实现分组唤醒需要唤醒的线程们，可以精确唤醒，而不是像 synchronized 要么随机唤醒一个线程要么唤醒全部线程。