阻塞队列大保健

阻塞队列

前言

多线程环境中，通过队列可以很容易实现数据共享，比如经典的“生产者”和“消费者”模型中，通过队列可以很便利地实现两者之间的数据共享。假设我们有若干生产者线程，另外又有若干个消费者线程。如果生产者线程需要把准备好的数据共享给消费者线程，利用队列的方式来传递数据，就可以很方便地解决他们之间的数据共享问题。但如果生产者和消费者在某个时间段内，万一发生数据处理速度不匹配的情况呢？理想情况下，如果生产者产出数据的速度大于消费者消费的速度，并且当生产出来的数据累积到一定程度的时候，那么生产者必须暂停等待一下（阻塞生产者线程），以便等待消费者线程把累积的数据处理完毕，反之亦然。然而，在concurrent包发布以前，在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。好在此时，强大的concurrent包横空出世了，而他也给我们带来了强大的BlockingQueue。（在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会自动被唤醒）

概念

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-184bBwGM-1624889620865)(C:\Users\Administrator\Desktop\学习混子\pic\000.png)]

特点

• 通过一个共享的队列，可以使得数据由队列的一端输入，从另外一端输出
• 当阻塞队列是空的时候，从队列中获取元素的操作会被阻塞
• 当阻塞队列是满的时候，从队列中添加元素的操作会被阻塞

常用的队列主要有以下两种：（当然通过不同的实现方式，还可以延伸出很多不同类型的队列，DelayQueue就是其中的一种）

先进先出（FIFO）：先插入的队列的元素也最先出队列，类似于排队的功能。从某种程度上来说这种队列也体现了一种公平性。

后进先出（LIFO）：后插入队列的元素最先出队列，这种队列优先处理最近发生的事件。

常用方法

	抛出异常	返回Boolean	一直阻塞	超时退出
插入方法	add(o)	offer(o)	put(o)	offer(o, timeout, timeunit)
移除方法	remove(o)	poll()	take(o)	poll(o, timeout, timeunit)
检查方法	element()	peek()	—	—

1. 抛出异常

   • add: 插入数据时，如果阻塞队列满，那么抛出异常IllegalStateException

     否则插入成功返回true。当使用有界（capacity-restricted queue）阻塞队列时，建议使用offer方法。

     • IllegalStateException - if the element cannot be added at this time due to capacity restrictions
     • ClassCastException - if the class of the specified element prevents it from being added to this queue
     • NullPointerException - if the specified element is null
     • IllegalArgumentException - if some property of the specified element prevents it from being added to this queue

   • remove: 删除数据时，如果队列中有此数据，删除成功返回true。如果包含一个或者多个object，那么只移除一个就返回true。**注意：**remove(o)是BlockingQueue接口的方法，remove()是Queue接口的方法。

   • element: 如果队列为空，那么抛出异常NoSuchElementException。如果队列不为空，查询返回队列头部的数据，但是不移除数据，这点不同于remove()，element同样是Queue接口的方法。

2. 返回特殊值

   • offer: 插入数据时，如果阻塞队列没满，那么插入成功返回true，否则返回false。当使用有界（capacity-restricted queue）阻塞队列时，建议使用offer方法，不建议会抛出异常的add方法。
   • poll: 此方法是Queue接口的。如果队列不为空，查询、移除并返回队列头部元素。如果队列为空，那么返回null。
   • peek: 此方法是Queue接口的。如果队列为空，返回null，这点不同于poll。如果队列不为空，查询返回队列头部的数据，但是不移除数据，这点不同于remove()。

3. 一直阻塞

   • put: 插入数据时，如果队列已满，那么阻塞等待队列可用，等待期间如果被中断，那么抛出InterruptedException。
   • take: 查询、删除并返回队列头部元素，如果队列为空，那么阻塞等待队列可用，等待期间如果被中断，那么抛出InterruptedException。

4. 超时退出

   • offer: 插入数据时，如果队列已满，那么阻塞指定时间等待队列可用，等待期间如果被中断，那么抛出InterruptedException。如果插入成功，那么返回true，如果在达到指定时间后仍然队列不可用，那么返回false。
   • poll: 查询、删除并返回队列头部元素，如果队列为空，那么阻塞指定时间等待队列可用，等待期间如果被中断，那么抛出InterruptedException。如果删除成功，那么返回队列头部元素，如果在达到指定时间后仍然队列不可用，那么返回null。

Queue队列不能插入null，否则会抛出NullPointerException。

架构

实现类

BlockingQueue 接口的实现类都在 J.U.C （java.util.concurrent）包中，主要有七个实现类：

• ArrayBlockingQueue
• LinkedBlockingQueue
• SynchronousQueue
• PriorityBlockingQueue
• DelayQueue
• LinkedBlockingDeque
• LinkedTransferQueue

ArrayBlockingQueue

ArrayBlockingQueue是一个用数组实现的有界阻塞队列。此队列按照先进先出（FIFO）的原则对元素进行排序。

通过构造函数可以看出，底层用到了ReetrantLock，默认为非公平锁。

LinkedBlockingQueue

一个由链表结构组成的有界队列，此队列的长度为Integer.MAX_VALUE，也可以设置容量。此队列按照先进先出的顺序进行排序。同样也利用 ReentrantLock 实现线程安全，使用 Condition 来阻塞和唤醒线程。

SynchronousQueue

SynchronousQueue 最大的不同之处在于，它的容量为 0，所以没有一个地方来暂存元素，导致每次取数据都要先阻塞，直到有数据被放入；同理，每次放数据的时候也会阻塞，直到有消费者来取。

SynchronousQueue 不需要去持有元素，它所做的就是直接传递（direct handoff）。由于每当需要传递的时候，SynchronousQueue 会把元素直接从生产者传给消费者，在此期间并不需要做存储，所以如果运用得当，它的效率是很高的。

SynchronousQueue的一个使用场景是在线程池里。Executors.newCachedThreadPool()就使用了SynchronousQueue，这个线程池根据需要（新任务到来时）创建新的线程，如果有空闲线程则会重复使用，线程空闲了60秒后会被回收。

PriorityBlockingQueue

一个支持线程优先级排序的无界队列，默认自然序进行排序，也可以自定义实现compareTo()方法来指定元素排序规则，不能保证同优先级元素的顺序。插入队列的对象必须是可比较大小的，也就是 Comparable 的，否则会抛出 ClassCastException 异常。

public class PriorityBlockingQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<Node> priorityBlockingQueue = new PriorityBlockingQueue<>(10, new Node());
        priorityBlockingQueue.offer(new Node(2));
        priorityBlockingQueue.offer(new Node(3));
        priorityBlockingQueue.offer(new Node(1));
        for (int i = 0; i < 3; i++) {
            Node node = priorityBlockingQueue.poll();
            System.out.println(node.toString());
        }
    }

    static class Node implements Comparator<Node> {

        private Integer value;

        public Node() {
        }

        public Node(Integer value) {
            this.value = value;
        }

        public Integer getValue() {
            return value;
        }

        public void setValue(Integer value) {
            this.value = value;
        }

        @Override
        public int compare(Node o1, Node o2) {
            return o1.getValue() - o2.getValue();
        }
    }
}

结果为：

Node{value=1}
Node{value=2}
Node{value=3}

DelayQueue

DelayQueue 这个队列比较特殊，具有“延迟”的功能。我们可以设定让队列中的任务延迟多久之后执行，比如 10 秒钟之后执行，这在例如“30 分钟后未付款自动取消订单”等需要延迟执行的场景中被大量使用。

它是无界队列，放入的元素必须实现 Delayed 接口，而 Delayed 接口又继承了 Comparable 接口，所以自然就拥有了比较和排序的能力。

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

可以看出这个 Delayed 接口继承自 Comparable。这里的 getDelay 方法返回的是“还剩下多长的延迟时间才会被执行”，如果返回 0 或者负数则代表任务已过期。元素会根据延迟时间的长短被放到队列的不同位置，越靠近队列头代表越早过期，DelayQueue 内部使用了 PriorityQueue 的能力来进行排序。

class DelayNode implements Delayed {
    private static final long NANO_ORIGIN = System.nanoTime();
    private Integer value;
    private long time;

    public DelayNode() {
    }

    public DelayNode(Integer value, long time) {
        this.value = value;
        this.time = time;
    }

    public Integer getValue() {
        return value;
    }

    public void setValue(Integer value) {
        this.value = value;
    }

    public long getTime() {
        return time;
    }

    public void setTime(long time) {
        this.time = time;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return time - unit.toSeconds(delayTime());
    }

    @Override
    public int compareTo(Delayed o) {
        if (o instanceof DelayNode) {
            return value - ((DelayNode) o).getValue();
        } else {
            return 0;
        }
    }

    private static long delayTime() {
        return System.nanoTime() - NANO_ORIGIN;
    }

    @Override
    public String toString() {
        return "DelayNode{" +
                "value=" + value +
                ", time=" + time +
                '}';
    }
}

public class MyTest4 {
    private static final long NANO_ORIGIN = System.nanoTime();

    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<DelayNode> blockingQueue = new DelayQueue<>();
        blockingQueue.offer(new DelayNode(1,2));
        blockingQueue.offer(new DelayNode(2,3));
        blockingQueue.offer(new DelayNode(2,3));
        blockingQueue.offer(new DelayNode(2,9));
        for (int i = 0; i < 10; i++) {
            System.out.printf("时间[%d]\n", i + 1);
            Thread.sleep(1000);
            System.out.println(blockingQueue.poll());
        }
    }
}

结果是：

时间[1]
null
时间[2]
DelayNode{value=1, time=2}
时间[3]
null
时间[4]
null
时间[5]
null
时间[6]
null
时间[7]
null
时间[8]
null
时间[9]
DelayNode{value=2, time=9}
时间[10]
DelayNode{value=2, time=3}
时间[11]
DelayNode{value=2, time=3}
时间[12]
null
时间[13]
null
时间[14]
null
时间[15]

LinkedTransferQueue

LinkedTransferQueue是一个由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列，LinkedTransferQueue多了tryTransfer和transfer方法。

（1）transfer方法

如果当前有消费者正在等待接收元素（消费者使用take()方法或带时间限制的poll()方法时），transfer方法可以把生产者传入的元素立刻transfer（传输）给消费者。如果没有消费者在等待接收元素，transfer方法会将元素存放在队列的tail节点，并等到该元素被消费者消费了才返回

（2）tryTransfer方法

tryTransfer方法是用来试探生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回false。和transfer方法的区别是tryTransfer方法无论消费者是否接收，方法立即返回，而transfer方法是必须等到消费者消费了才返回。

对于带有时间限制的tryTransfer（E e，long timeout，TimeUnit unit）方法，试图把生产者传入的元素直接传给消费者，但是如果没有消费者消费该元素则等待指定的时间再返回，如果超时还没消费元素，则返回false，如果在超时时间内消费了元素，则返回true

LinkedBlockingDeque

LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列，即可以从队列的两端插入和移除元素。双向队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。

相比于其他阻塞队列，LinkedBlockingDeque多了addFirst、addLast、peekFirst、peekLast等方法，以first结尾的方法，表示插入、获取获移除双端队列的第一个元素。以last结尾的方法，表示插入、获取获移除双端队列的最后一个元素。

LinkedBlockingDeque是可选容量的，在初始化时可以设置容量防止其过度膨胀，如果不设置，默认容量大小为Integer.MAX_VALUE。

阻塞的实现

ReentranLock + Condition 实现队列的阻塞，ReentranLock 是锁，Condition是条件状态，通过等待/通知机制，来实现线程之间的通信。

ReentranLock + Condition的等待/通知机制和Object的wait()与notify()是类似的，通过synchronized，在锁中使用wait()与notify()达到线程之间通信，在ReentranLock 的lock()和unlock()之间通过类似的await()和signal()达到线程之间的通信。

在阻塞队列中A调用put()方法的时候，如果队列已满，则A线程挂起，等待恢复，如果B线程调用take()后，消耗一个队列元素后，会通知put()方法中挂起的A线程，因为这个时候B线程已经消耗一个元素可以在向队列中添加元素。相反如果队列一空 B线程调用tack()方法会阻塞，当A线程调用put()调用后通知tack()方法中的B线程，有元素可以获取。这就是阻塞的实现过程。

下面查看ArrayBlockingQueue 源码来分析这一实现过程

ArrayBlockingQueue的成员变量

构造函数初始化，默认使用非公平锁

查看put()方法

enqueue()

查看take()方法

dequeue()

生产者消费者

class Resource {
    public volatile boolean flag = true;
    private AtomicInteger integer = new AtomicInteger(0);
    private BlockingQueue blockingQueue = null;

    public Resource(BlockingQueue<String> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    public void produce() throws InterruptedException {
        while (flag) {
            String s = integer.getAndIncrement() + "";
            boolean offer = blockingQueue.offer(s);
            if (offer) {
                System.out.println("插入阻塞队列成功，值=" + s);
            } else {
                System.out.println("插入阻塞队列失败");
            }
            Thread.sleep(1000);
        }
    }

    public void consume() throws InterruptedException {
        String result = null;
        while (flag) {
            result = (String) blockingQueue.poll(2L, TimeUnit.SECONDS);
            if (ObjectUtils.isEmpty(result)) {
                System.out.println("阻塞队列为null");
                flag = false;
            } else {
                System.out.println("获取阻塞队列成功，值=" + result);
            }
        }
    }


}

public class MyTest5 {
    public static void main(String[] args) throws InterruptedException {
        Resource resource = new Resource(new ArrayBlockingQueue<>(10));
        new Thread(() -> {
            try {
                resource.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "a").start();

        new Thread(() -> {
            try {
                resource.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "b").start();

        Thread.sleep(5000);
        resource.flag = false;
        System.out.println("5s结束");

    }

(InterruptedException e) {
e.printStackTrace();
}
}, “a”).start();

    new Thread(() -> {
        try {
            resource.consume();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }, "b").start();

    Thread.sleep(5000);
    resource.flag = false;
    System.out.println("5s结束");

}