并发编程-阻塞队列二
阻塞队列介绍
队列
先进先出的线性表；一端进行插入，另一端进行删除；允许出队的一端为队头，允许入队的一端为队尾
包括数组、链表、延迟队列，天然适合生产者和消费者的模式
LinkedBlockingQueue
无界阻塞队列，可以指定容量，默认为 Integer.MAX_VALUE，先进先出，存取互不干扰
由于默认值特别大，也被称作无界队列，但是如果没有剩余内存，会抛出OOM错误。所以为了避免队列过大造成机器负载或内存爆满，使用时建议手动传队列大小
数据结构：链表。可以指定容量，默认为Integer.MAX_VALUE，内部类 Node 存储元素
锁分离：存取互不干扰，存取操作的是不同的Node对象。takeLock（取Node节点保证前驱后继不会乱）、putLock（存Node节点保证前驱后继不会乱）
阻塞对象：notEmpty（出队：队列count=0，无元素可取时，阻塞在该对象上）、notFull（入队：队列count=capacity，放不进去元素时，阻塞在该对象上）
入队：队尾入队，由last指针记录
出队：队首出队，由head指针记录
先进先出
线程池中为什么使用LinkedBlockingQueue而不用ArrayBlockingQueue？
锁分离：LinkedBlockingQueue入队和出队是两把锁，存取元素互不干扰
LinkedBlockingQueue使用
//指定队列的大小创建有界队列
BlockingQueue boundedQueue = new LinkedBlockingQueue<>(100);
//无界队列
BlockingQueue unboundedQueue = new LinkedBlockingQueue<>(); LinkedBlockingQueue原理
LinkedBlockingQueue内部由单链表实现，只能从head取元素，从tail添加元素。
LinkedBlockingQueue采用两把锁的锁分离技术实现入队出队互不阻塞，添加元素和获取元素都有独立的锁，也就是说LinkedBlockingQueue是读写分离的，读写操作可以并行执行。
数据结构
// 容量,指定容量就是有界队列
private final int capacity;
// 元素数量
private final AtomicInteger count = new AtomicInteger();
// 链表头 本身是不存储任何元素的，初始化时item指向null
transient Node head;
// 链表尾
private transient Node last;
// take锁 锁分离，提高效率
private final ReentrantLock takeLock = new ReentrantLock();
// notEmpty条件
// 当队列无元素时，take锁会阻塞在notEmpty条件上，等待其它线程唤醒
private final Condition notEmpty = takeLock.newCondition();
// put锁
private final ReentrantLock putLock = new ReentrantLock();
// notFull条件
// 当队列满了时，put锁会阻塞在notFull上，等待其它线程唤醒
private final Condition notFull = putLock.newCondition();
//典型的单链表结构
static class Node {
E item; //存储元素
Node next; //后继节点 单链表结构
Node(E x) { item = x; }
} 构造器
public LinkedBlockingQueue() {
// 如果没传容量，就使用最大int值初始化其容量
this(Integer.MAX_VALUE);
}
public LinkedBlockingQueue(int capacity) {
if (capacity <= 0) throw new IllegalArgumentException();
this.capacity = capacity;
// 初始化head和last指针为空值节点
last = head = new Node(null);
} 入队put方法
public void put(E e) throws InterruptedException {
// 不允许null元素
if (e == null) throw new NullPointerException();
int c = -1;
// 新建一个节点
Node node = new Node(e);
final ReentrantLock putLock = this.putLock;
final AtomicInteger count = this.count;
// 使用put锁加锁
putLock.lockInterruptibly();
try {
// 如果队列满了，就阻塞在notFull上等待被其它线程唤醒（阻塞生产者线程）
while (count.get() == capacity) {
notFull.await();
}
// 队列不满，就入队
enqueue(node);
c = count.getAndIncrement();// 队列长度加1，返回原值
// 如果现队列长度小于容量，notFull条件队列转同步队列，准备唤醒一个阻塞在notFull条件上的线程(可以继续入队)
// 这里为啥要唤醒一下呢？
// 因为可能有很多线程阻塞在notFull这个条件上，而取元素时只有取之前队列是满的才会唤醒notFull，此处不用等到取元素时才唤醒
if (c + 1 < capacity)
notFull.signal();
} finally {
putLock.unlock(); // 真正唤醒生产者线程
}
// 如果原队列长度为0，现在加了一个元素后立即唤醒阻塞在notEmpty上的线程
if (c == 0)
signalNotEmpty();
}
private void enqueue(Node node) {
// 直接加到last后面,last指向入队元素
last = last.next = node;
}
private void signalNotEmpty() {
final ReentrantLock takeLock = this.takeLock;
takeLock.lock();// 加take锁
try {
notEmpty.signal();// notEmpty条件队列转同步队列，准备唤醒阻塞在notEmpty上的线程
} finally {
takeLock.unlock(); // 真正唤醒消费者线程
}
} 出队take方法
public E take() throws InterruptedException {
E x;
int c = -1;
final AtomicInteger count = this.count;
final ReentrantLock takeLock = this.takeLock;
// 使用takeLock加锁
takeLock.lockInterruptibly();
try {
// 如果队列无元素，则阻塞在notEmpty条件上（消费者线程阻塞）
while (count.get() == 0) {
notEmpty.await();
}
// 否则，出队
x = dequeue();
c = count.getAndDecrement();//长度-1，返回原值
if (c > 1)// 如果取之前队列长度大于1，notEmpty条件队列转同步队列，准备唤醒阻塞在notEmpty上的线程，原因与入队同理
notEmpty.signal();
} finally {
takeLock.unlock(); // 真正唤醒消费者线程
}
// 为什么队列是满的才唤醒阻塞在notFull上的线程呢？
// 因为唤醒是需要加putLock的，这是为了减少锁的次数，所以，这里索性在放完元素就检测一下，未满就唤醒其它notFull上的线程
// 这也是锁分离带来的代价
// 如果取之前队列长度等于容量（已满），则唤醒阻塞在notFull的线程
if (c == capacity)
signalNotFull();
return x;
}
private E dequeue() {
// head节点本身是不存储任何元素的
// 这里把head删除，并把head下一个节点作为新的值
// 并把其值置空，返回原来的值
Node h = head;
Node first = h.next;
h.next = h; // 方便GC
head = first;
E x = first.item;
first.item = null;
return x;
}
private void signalNotFull() {
final ReentrantLock putLock = this.putLock;
putLock.lock();
try {
notFull.signal();// notFull条件队列转同步队列，准备唤醒阻塞在notFull上的线程
} finally {
putLock.unlock(); // 解锁，这才会真正的唤醒生产者线程
}
} LinkedBlockingQueue与ArrayBlockingQueue对比
LinkedBlockingQueue是一个阻塞队列，内部由两个ReentrantLock来实现出入队列的线程安 全，由各自的Condition对象的await和signal来实现等待和唤醒功能。它和ArrayBlockingQueue的 不同点在于：
-
队列大小不同。ArrayBlockingQueue是有界队列必须初始化容量；LinkedBlockingQueue指定容量是有界，不指定容量是无界队列，无界情况可能会OOM（添加速度大于移除速度时）
-
数据存储容量不同。ArrayBlockingQueue是数组结构；LinkedBlockingQueue是Node节点的链表结构
-
ArrayBlockingQueue在插入和删除时，不需要销毁额外的对象实例；LinkedBlockingQueue会产生额外的Node对象，在长时间高效并发处理大批量数据时，对GC可能造成较大影响
-
实现队列添加或移除的锁不一样。ArrayBlockingQueue中锁没有分离，添加和移除是同一把ReenterLock锁；LinkedBlockingQueue是锁分离，添加采用的是putLock，移除采用的是takeLock，大大提高队列的吞吐量，高并发的场景下可以并行操作。
DelayQueue
使用优先级队列实现的无界阻塞队列，支持延时获取元素
数据结构：用PriorityQueue存储，且元素必须实现 Delayed 接口，与PriorityBlockingQueue类似，没有阻塞
特点：不是先进先出，而是按照延迟时间的长短来排序，下一个即将执行的任务会排到队列的最前面。
锁：ReentrantLock
阻塞对象：Condition available
入队：不阻塞，无界队列，与优先级队列入队相同，available
出队：为空时阻塞；检查堆顶元素过期时间，小于等于0则出队，大于0说明没过期则阻塞；判断leader线程是否为空（为了保证优先级），不为空（已有线程阻塞）直接阻塞，为空则将当前线程置为leader，并按照过期时间进行阻塞
应用场景：
-
商城订单超时关闭，淘宝订单业务:下单之后如果三十分钟之内没有付款就自动取消订单
-
异步短信通知功能，饿了么订餐通知:下单成功后60s之后给用户发送短信通知
-
关闭空闲连接。服务器中，有很多客户端的连接，空闲一段时间之后需要关闭
-
缓存过期清除。缓存中的对象，超过了存活时间，需要从缓存中移出
-
任务超时处理。在网络协议滑动窗口请求应答式交互时，处理超时未响应的请求等
DelayQueue是无界队列，放入的元素必须实现 Delayed 接口，而 Delayed 接口又继承了 Comparable 接口，所以自然就拥有了比较和排序的能力：
public interface Delayed extends Comparable {
//getDelay 方法返回的是“还剩下多长的延迟时间才会被执行”，
//如果返回 0 或者负数则代表任务已过期。
//元素会根据延迟时间的长短被放到队列的不同位置，越靠近队列头代表越早过期。
long getDelay(TimeUnit unit);
} DelayQueue使用
DelayQueue 实现延迟订单
public class DelayQueueExample
{
public static void main(String[] args) throws InterruptedException
{
DelayQueue delayQueue = new DelayQueue<>();
// 添加三个订单，分别延迟 5 秒、2 秒和 3 秒
delayQueue.put(new Order("order1", System.currentTimeMillis(), 5000));
delayQueue.put(new Order("order2", System.currentTimeMillis(), 2000));
delayQueue.put(new Order("order3", System.currentTimeMillis(), 3000));
// 循环取出订单，直到所有订单都被处理完毕
while (!delayQueue.isEmpty())
{
Order order = delayQueue.take();
System.out.println("处理订单：" + order.getOrderId());
}
}
static class Order implements Delayed
{
private String orderId;
private long createTime;
private long delayTime;
public Order(String orderId, long createTime, long delayTime)
{
this.orderId = orderId;
this.createTime = createTime;
this.delayTime = delayTime;
}
public String getOrderId()
{
return orderId;
}
@Override
public long getDelay(TimeUnit unit)
{
long diff = createTime + delayTime - System.currentTimeMillis();
return unit.convert(diff, TimeUnit.MILLISECONDS);
}
@Override
public int compareTo(Delayed o)
{
long diff = this.getDelay(TimeUnit.MILLISECONDS) - o.getDelay(TimeUnit.MILLISECONDS);
return Long.compare(diff, 0);
}
}
} DelayQueue原理
数据结构
//用于保证队列操作的线程安全
private final transient ReentrantLock lock = new ReentrantLock();
// 优先级队列,存储元素，用于保证延迟低的优先执行
private final PriorityQueue q = new PriorityQueue();
// 用于标记当前是否有线程在排队（仅用于取元素时） leader 指向的是第一个从队列获取元素阻塞的线程
private Thread leader = null;
// 条件，用于表示现在是否有可取的元素 当新元素到达，或新线程可能需要成为leader时被通知
private final Condition available = lock.newCondition();
public DelayQueue() {}
public DelayQueue(Collection c) {
this.addAll(c);
} 入队put方法
public void put(E e) {
offer(e);
}
public boolean offer(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
// 入队
q.offer(e);
if (q.peek() == e) {
// 若入队的元素位于队列头部，说明当前元素延迟最小
// 将 leader 置空
leader = null;
// available条件队列转同步队列,准备唤醒阻塞在available上的线程
available.signal();
}
return true;
} finally {
lock.unlock(); // 解锁，真正唤醒阻塞的线程
}
}出队take方法
public E take() throws InterruptedException {
final ReentrantLock lock = this.lock;
lock.lockInterruptibly();
try {
for (;;) {
E first = q.peek();// 取出堆顶元素( 最早过期的元素，但是不弹出对象)
if (first == null)// 如果堆顶元素为空，说明队列中还没有元素，直接阻塞等待
available.await();//当前线程无限期等待，直到被唤醒，并且释放锁。
else {
long delay = first.getDelay(NANOSECONDS);// 堆顶元素的到期时间
if (delay <= 0)// 如果小于0说明已到期，直接调用poll()方法弹出堆顶元素
return q.poll();
// 如果delay大于0 ，则下面要阻塞了
// 将first置为空方便gc
first = null;
// 如果有线程争抢的Leader线程，则进行无限期等待。
if (leader != null)
available.await();
else {
// 如果leader为null，把当前线程赋值给它
Thread thisThread = Thread.currentThread();
leader = thisThread;
try {
// 等待剩余等待时间
available.awaitNanos(delay);
} finally {
// 如果leader还是当前线程就把它置为空，让其它线程有机会获取元素
if (leader == thisThread)
leader = null;
}
}
}
}
} finally {
// 成功出队后，如果leader为空且堆顶还有元素，就唤醒下一个等待的线程
if (leader == null && q.peek() != null)
// available条件队列转同步队列,准备唤醒阻塞在available上的线程
available.signal();
// 解锁，真正唤醒阻塞的线程
lock.unlock();
}
}如何选择适合的阻塞队列
选择策略
-
功能：是否需要优先级排序、延迟执行等
-
容量：需要根据任务数量来推算出合适的容量
-
能否扩容：业务有高峰期、低谷期。根据是否需要扩容，选择合适的队列
-
内存结构：数组/链表。数组没有链表的节点，空间利用率更高
-
性能：数组结构空间利用率更高；链表结构两把锁并发性能更高；直接传递优先考虑 SynchronousQueue
线程池对于阻塞队列的选择
线程池有很多种，不同种类的线程池会根据自己的特点，来选择适合自己的阻塞队列。
Executors类下的线程池类型：
-
FixedThreadPool（SingleThreadExecutor 同理）选取的是 LinkedBlockingQueue
-
CachedThreadPool 选取的是 SynchronousQueue
-
ScheduledThreadPool（SingleThreadScheduledExecutor同理）选取的是延迟队列