并发编程系列（六）：阻塞队列

一、生产者消费者的实际使用
生产者消费者模式在分布式消息队列中用到较多，比如 ActiveMQ、kafka、RabbitMQ 等等，消息队列的使用可以使得程序之间实现解耦，提升程序响应的效率。
如果我们把多线程环境比作是分布式的话，那么线程与线程之间也可以使用这种消息队列的方式进行数据通信和解耦。

二、阻塞队列使用案例
注册成功后增加积分
用户注册时，在注册成功以后发放积分。这个场景一般来说，我们会这么去实现

这样实现会有两个问题：

1.性能，在注册环节中，假如添加用户用时1s，增加积分用时1s，那么注册结果返回可能花费≥2s时间，当访问量较大时，性能较低。可以将增加积分这块与添加用户分开执行，返回结果依赖添加用户，而不跟增加积分强相关。
2.耦合，添加用户和增加积分可以看做是两个领域。增加积分并不是注册必须要具备的功能，但是一旦增加积分这个逻辑出现异常，就会导致注册失败。这种耦合在程序设计的时候是一定要规避的。
因此我们可以通过异步的方式来实现。

eg.旧的串行执行方式

public class UserService {
    public boolean register(){
        User user=new User();
        user.setName("Mic");
        addUser(user);
        sendPoints(user);
        return true;
    }
    public static void main(String[] args) {
        new UserService().register();
    }
    private void addUser(User user){
        System.out.println("添加用户：" + user);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void sendPoints(User user){
        System.out.println("发送积分给指定用户：" + user);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

优化后流程如下：

eg.阻塞队列方式

public class UserService {
    private final ExecutorService single = Executors.newSingleThreadExecutor();
    private volatile boolean isRunning = true;
    private ArrayBlockingQueue arrayBlockingQueue=new ArrayBlockingQueue(10);
    {
        init();
    }
    public void init(){
        single.execute(()->{
            while(isRunning){
                try {
                    // 阻塞的方式获取队列中的数据
                    User user = (User)arrayBlockingQueue.take();
                    sendPoints(user);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
    public boolean register(){
        User user=new User();
        user.setName("Mic");
        addUser(user);
        arrayBlockingQueue.add(user); // 添加到异步队列
        return true;
    }
    public static void main(String[] args) {
        new UserService().register();
    }
    private void addUser(User user){
        System.out.println("添加用户：" + user);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    private void sendPoints(User user){
        System.out.println("发送积分给指定用户：" + user);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

阻塞队列的应用场景
比较多的仍然是对于生产者消费者场景的应用，但是由于分布式架构的普及，大家更多的关注在分布式消息队列上。所以其实如果把阻塞队列比作成分布式消息队列的话，那么所谓的生产者和消费者其实就是基于阻塞队列的解耦。
另外，阻塞队列是一个 FIFO 的队列，所以对于希望在线程级别需要实现对目标服务的顺序访问的场景中，也可以使用。

 

三、J.U.C包中的阻塞队列
在 Java8 中，提供了 7 个阻塞队列

• ArrayBlockingQueue  数组实现的有界阻塞队列, 此队列按照先进先出（FIFO）的原则对元素进行排序。
• LinkedBlockingQueue  链表实现的有界阻塞队列, 此队列的默认和最大长度为Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行排序
• PriorityBlockingQueue  支持优先级排序的无界阻塞队列, 默认情况下元素采取自然顺序升序排列。也可以自定义类实现 compareTo()方法来指定元素排序规则，或者初始化 PriorityBlockingQueue 时，指定构造参数 Comparator 来对元素进行排序。
• DelayQueue  优先级队列实现的无界阻塞队列
• SynchronousQueue  不存储元素的阻塞队列, 每一个 put 操作必须等待一个 take 操作，否则不能继续添加元素。
• LinkedTransferQueue  链表实现的无界阻塞队列
• LinkedBlockingDeque  链表实现的双向阻塞队列

阻塞队列的操作方法
在阻塞队列中，提供了四种处理方式
1. 插入操作

• add(e)：添加元素到队列中，如果队列满了，继续插入元素会报错，IllegalStateException。
• offer(e)：添加元素到队列，同时会返回元素是否插入成功的状态，如果成功则返回 true
• put(e)：当阻塞队列满了以后，生产者继续通过 put 添加元素，队列会一直阻塞生产者线程，知道队列可用
• offer(e,time,unit)：当阻塞队列满了以后继续添加元素，生产者线程会被阻塞指定时间，如果超时，则线程直接退出

2. 移除操作

• remove()：当队列为空时，调用 remove 会返回 false，如果元素移除成功，则返回 true
• poll()：当队列中存在元素，则从队列中取出一个元素，如果队列为空，则直接返回 null
• take()：基于阻塞的方式获取队列中的元素，如果队列为空，则 take 方法会一直阻塞，直到队列中有新的数据可以消费
• poll(time,unit)：带超时机制的获取数据，如果队列为空，则会等待指定的时间再去获取元素返回