【多线程】Java中的阻塞队列（1）

一、阻塞队列

什么是阻塞队列？

阻塞队列（BlockingQueue）是一个支持两个附加操作的队列，这两个附加的操作是：在队列为空时，获取元素的线程会等待队列变为非空。当队列满时，存储元素的队列会等待队列可用。阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。

二、BlockingQueue的核心方法

1. 放入数据

• offer（anObject）：表示如果可能的话，将anObject加到BlockingQueue里，即如果BlockingQueue可以容纳，则返回true，否则返回false（本方法不阻塞当前执行方法的线程）
• offer（(E o, long timeout, TimeUnit unit）：可以设定等待的时间，如果在指定的时间内，还不能往队列中加入BlockingQueue，则返回失败
• put（anObject）：把anObject加到BlockingQueue里，如果BlockQueue没有空间，则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续 

1. 获取数据

•  poll（time）：取走BlockingQueue里排在首位的对象，若不能立即取出，则可以等time参数规定的时间，取不到时返回null
• poll（long timeout, TimeUnit unit）：从BlockingQueue取出一个队首的对象，如果在指定时间内，队列一旦有数据可取，则立即返回队列中的数据，否则直到时间超时还没有数据可取，返回失败
• take（）：取走BlockingQueue里排在首位的对象，若BlockingQueue为空，阻断进入等待状态直到BlockingQueue有新的数据被加入
• drainTo（）：一次性从BlockingQueue获取所有可用的数据对象（还可以指定获取数据的个数），通过该方法，可以提升获取数据效率；不需要多次分批加锁或释放锁

三、常见BlockingQueue

1、ArrayBlockingQueue

基于数组的阻塞队列实现，在ArrayBlockingQueue内部，维护了一个定长数组，以便缓存队列中的数据对象，这是一个常用的阻塞队列，除了一个定长数组外，ArrayBlockingQueue内部还保存着两个整形变量，分别标识着队列的头部和尾部在数组中的位置

ArrayBlockingQueue在生产者放入数据和消费者获取数据，都是共用同一个锁对象，由此也意味着两者无法真正并行运行，这点尤其不同于LinkedBlockingQueue；ArrayBlockingQueue和LinkedBlockingQueue间还有一个明显的不同之处在于，前者在插入或删除元素时不会产生或销毁任何额外的对象实例，而后者则会生成一个额外的Node对象。这在长时间内需要高效并发的处理大批量数据的系统中，其对于GC的影响还是存在一定的区别。而在创建ArrayBlockingQueue时，我们还可以控制对象的内部锁是否采用公平锁，默认采用非公平锁

ArrayBlockingQueue实现简单的生产者消费者模型：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

class Apple {
    public Apple() {
    }
}

public class AppleTest {//启动两个线程额，队列最大容量为5
    private final static BlockingQueue<Apple> queue = new ArrayBlockingQueue<Apple>(5);

    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
              new Thread(new AppleProducer(queue)).start();
              new Thread(new AppleConsumer(queue)).start();
        }
    }
}


//生产者
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class AppleProducer implements Runnable {

    private final BlockingQueue<Apple> queue;

    public AppleProducer(BlockingQueue<Apple> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                TimeUnit.MILLISECONDS.sleep(100);
                queue.put(new Apple());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("生产了一个苹果，当前队列的容量为：" + queue.size());
        }
    }
}

//消费者
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class AppleConsumer implements Runnable {
    private final BlockingQueue<Apple> queue;
    public AppleConsumer(BlockingQueue<Apple> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                TimeUnit.MILLISECONDS.sleep(1000);
                queue.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("吃掉了一个苹果，当前队列的容量为：" + queue.size());
        }
    }
}

2、LinkedBlockingQueue

基于链表的阻塞队列，同ArrayBlockingQueue类似，其内部也维持着一个数据缓冲队列（该队列由一个链表构成），当生产者往队列中放入一个数据时，队列会从生产者手中获取数据，并缓存在队列内部，而生产者立即返回；只有当队列缓冲区达到最大值缓存容量时（LinkecBlockingQueue可以通过构造函数指定该值），才会阻塞生产者队列，直到消费者从队列中消费掉一份数据，生产者线程会被唤醒，反之对于消费者这端的处理也基于同样的原理。而LinkedBlockingQueue之所以能够高效的处理并发数据，还因为其对于生产者端和消费者端分别采用了独立的锁来控制数据同步，这也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。

总结：ArrayBlockingQueue和LinkedBlockingQueue的区别

• 队列大小有所不同，ArrayBlockingQueue是有界的初始化必须指定大小，而LinkedBlockingQueue可以是有界的也可以是无界的(Integer.MAX_VALUE)，对于后者而言，当添加速度大于移除速度时，在无界的情况下，可能会造成内存溢出等问题。
• 数据存储容器不同，ArrayBlockingQueue采用的是数组作为数据存储容器，而LinkedBlockingQueue采用的则是以Node节点作为连接对象的链表。（操作不同  操作数组  操作 链表）
• 由于ArrayBlockingQueue采用的是数组的存储容器，因此在插入或删除元素时不会产生或销毁任何额外的对象实例，而LinkedBlockingQueue则会生成一个额外的Node对象。这可能在长时间内需要高效并发地处理大批量数据的时，对于GC可能存在较大影响。
• 两者的实现队列添加或移除的锁不一样，ArrayBlockingQueue实现的队列中的锁是没有分离的，即添加操作和移除操作采用的同一个ReenterLock锁，而LinkedBlockingQueue实现的队列中的锁是分离的，其添加采用的是putLock，移除采用的则是takeLock，这样能大大提高队列的吞吐量，也意味着在高并发的情况下生产者和消费者可以并行地操作队列中的数据，以此来提高整个队列的并发性能。

3、DelayQueue

DelayQueue是一个支持延时获取元素的无界阻塞队列，队列使用PriorityQueue来实现，队列中的元素必须实现Delayed接口，在创建元素时可以指定多久才能从队列中获取当前元素，只有在延时期满时才能从队列中提取元素。

DelayQueue封装了一个PriorityQueue，这个PriorityQueue会对队列中的ScheduleFutureTask进行排序。排序时，time小的排在前面（时间早的任务将被先执行）。如果两个ScheduledFutureTask的time相同，就比较sequenceNumber，sequenceNumber小的排在前面（也就是说，如果两个任务的执行时间相同，那么先提交的任务就将被先执行）。

代码实现：

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class DelayedQueneTest {
    public static void main(String[] args) throws InterruptedException {
        Item item1 = new Item("item1", 10, TimeUnit.SECONDS);
        Item item2 = new Item("item2",5, TimeUnit.SECONDS);
        Item item3 = new Item("item3",15, TimeUnit.SECONDS);
        DelayQueue<Item> queue = new DelayQueue<>();
        queue.put(item1);
        queue.put(item2);
        queue.put(item3);
        System.out.println("begin time:" + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
        for (int i = 0; i < 3; i++) {
            //先被取出的元素一定是延时时间最短的
            Item take = queue.take();  //队头元素取出
            System.out.format("name:{%s}, time:{%s}\n",take.name, LocalDateTime.now().format(DateTimeFormatter.ISO_DATE_TIME));
        }
    }
}

class Item implements Delayed {
    /* 触发时间*/
    private long time;
    String name;

    public Item(String name, long time, TimeUnit unit) {
        this.name = name;
        this.time = System.currentTimeMillis() + (time > 0? unit.toMillis(time): 0);
        //8：06   + 5S = 8:06:05
        //添加元素那一时刻的时间 + 上延时时间
    }

    @Override
    public long getDelay(TimeUnit unit) {  //延时规则
            //8:06:05  8:06:05
        return time - System.currentTimeMillis();   //判断是否超过延时时间的方法
    }

    @Override
    public int compareTo(Delayed o) {  //通过这个方法进行比较，比较出哪个应该是队头元素
        Item item = (Item) o;
        long diff = this.time - item.time;
        if (diff <= 0) {// 改成>=会造成问题
            return -1;
        }else {
            return 1;
        }
    }

    @Override
    public String toString() {
        return "Item{" +
                "time=" + time +
                ", name='" + name + '\'' +
                '}';
    }
}

运行结果：

4、SynchronousQueue

SynchronousQueue可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素，非常适合传递性场景。SynchronousQueue的吞吐量高于ArrayBlockingQueue和LinkedBlockingQueue。

SynchronousQueue采用队列TransferQueue来实现公平性策略，采用堆栈TransferStack来实现非公平性策略，SynchronousQueue的put、take操作都是委托这两个类来实现的。

 

参考内容：https://www.cnblogs.com/tjudzj/p/4454490.html