自定义阻塞队列

自定义阻塞队列

1. 特性

阻塞队列是一种特殊的队列，在队列原有的先进先出特性的基础上，它增加了以下特性：

• 当阻塞队列中数据已满时，此时进行入队列操作的线程会进入阻塞状态，一直阻塞到队列中数据不为满状态(其它线程执行了出队列操作)后才能继续执行
• 当阻塞队列中数据为空时，此时进行出队列操作的线程会进入阻塞状态，一直阻塞到队列中数据不为空(其它线程执行了入队列操作)后才能继续执行

2. 作用

阻塞队列能够起到解耦合与削峰填谷的作用，举个栗子🌰：

假设我们对外提供了一个购物网站，现在用户向我们的网站发送了服务请求，所有请求都会先通过入口服务器A来转发请求，且A自身也执行一定业务处理，然后A将请求转发到服务器B上或服务器C上来执行请求并返回响应：

在这种情况下，A和B，A和C之间的关系是密切相连的(A中有调用B的代码，B中有调用A的代码)，若这个时候服务器B出现了故障，服务收到了影响，可能会间接的导致服务器A也收到影响甚至宕机，这种现象对用户或我们来说是非常不友好的！

对此我们可以给服务器A与其它服务器之间添加一个阻塞队列，专门用来进行请求的存储与消费：

服务器A可以将请求保存到队列中，然后其它服务器可以从队列里获取数据，而不会与A产生直接联系，以此来达到解耦合的作用

还有一种特殊的情况，当用户发出的请求特别多时(如双十一)，这个时候服务器B和服务器C对请求的处理速度远远抵不上请求的生成速度，这样子可能会导致服务器的崩溃然后就宕机了，对此我们可以引入阻塞队列(记得它的特性)：当阻塞队列中的请求已经满了后再进来的线程会进入阻塞，直达服务器把把队列中的部分请求消化掉了才能继续添加请求，以此来达到削峰填谷的作用

3. 自定义阻塞队列

java本身也为我们提供了阻塞队列的数据结构：

• ArrayBlockingQueue：基于数组的阻塞队列
• LinkedBlockingQueue：基于链表的阻塞队列
• PriorityBlockingQueue：基于优先级队列的阻塞队列

这里就不探讨上面现成的阻塞队列了，而是自己来定义一个阻塞队列！

实现阻塞队列需要三个步骤：

1. 实现普通队列
2. 解决线程安全问题
3. 实现阻塞功能

3.1 实现普通队列

这里我们通过数组的形式实现队列，且为环形队列(为了方便操作这里统一存储数据为字符串):

class MyBlockingQueue {

    private String[] elems = null;

    private int head = 0; // 头指针，指向队首元素
    private int tail = 0; // 尾指针，指向队尾元素的下一位
    private int size = 0; // 当前队列存储数据大小

    public MyBlockingQueue(int capacity) {
        elems = new String[capacity];
    }

    /**
     * 入队操作
     */
    public void put(String elem) {
        
        if (size >= elems.length) {
            // 当前队列已满，进入阻塞
        }
        
        // 队列未满，将数据添加进队列中
        elems[tail] = elem;
        tail++;
        if (tail >= elems.length) {
            // 因为为循环队列，当尾指针超过当前队列最大容量时，重新回到队列起始下标(不一定为队首)
            tail = 0; 
        }
        size++;
    }

    /**
     * 出队操作
     */
    public String take() {
        
        if (size <= 0) {
            // 当前队列为空，进入阻塞
        }
        
        // 队列非空，将队首元素出队
        String ret = elems[head];
        head++;
        if (head >= elems.length) {
            // 因为为循环队列，当头指针超过当前队列最大容量时，重新回到队列起始下标
            head = 0;
        }
        size--;
        return ret;
    }
}

3.2 解决线程安全问题

在上述代码的基础上，我们需要解决可能出现的线程安全问题，因为这里的出队和入队操作都存在对变量进行修改的操作，对此可以通过加锁的方式来解决问题：

class MyBlockingQueue {

    private String[] elems = null;

    private int head = 0; // 头指针，指向队首元素
    private int tail = 0; // 尾指针，指向队尾元素的下一位

    private int size = 0; // 当前队列存储数据大小
    
    private Object locker = new Object(); // 定义锁对象

    public MyBlockingQueue(int capacity) {
        elems = new String[capacity];
    }

    /**
     * 入队操作
     */
    public void put(String elem) {
        
        synchronized(locker) {
            if (size >= elems.length) { 
                // 当前队列已满，进入阻塞
            }

            // 队列未满，将数据添加进队列中
            elems[tail] = elem;
            tail++;
            if (tail >= elems.length) {
                // 因为为循环队列，当尾指针超过当前队列最大容量时，重新回到队列起始下标(不一定为队首)
                tail = 0;
            }
            size++;
        }
    }

    /**
     * 出队操作
     */
    public String take() {
        
        synchronized (locker) {
            if (size <= 0) {
                // 当前队列为空，进入阻塞
            }

            // 队列非空，将队首元素出队
            String ret = elems[head];
            head++;
            if (head >= elems.length) {
                // 因为为循环队列，当头指针超过当前队列最大容量时，重新回到队列起始下标
                head = 0;
            }
            size--;
            return ret; 
        }
    }
}

注：对当前队列容量大小的判断也要加入锁中，因为可能出现队列剩下最后一个位，线程1判断符合入队条件后进入，但在未将数据入队时线程2也执行了入队操作，则可能出现超额入队的问题

3.3 添加阻塞功能

在上述代码的基础上我们添加阻塞功能，可以通过wait和notify来使线程阻塞还有唤醒：

class MyBlockingQueue {

    private String[] elems = null;

    private int head = 0; // 头指针，指向队首元素
    private int tail = 0; // 尾指针，指向队尾元素的下一位

    private int size = 0; // 当前队列存储数据大小

    private Object locker = new Object(); // 定义锁对象

    public MyBlockingQueue(int capacity) {
        elems = new String[capacity];
    }

    /**
     * 入队操作
     */
    public void put(String elem) throws InterruptedException {

        synchronized(locker) {
            if (size >= elems.length) {
                // 当前队列已满，进入阻塞
                locker.wait();
            }

            // 队列未满，将数据添加进队列中
            elems[tail] = elem;
            tail++;
            if (tail >= elems.length) {
                // 因为为循环队列，当尾指针超过当前队列最大容量时，重新回到队列起始下标(不一定为队首)
                tail = 0;
            }
            size++;
            locker.notify(); // 队列已添加数据，释放因为队列为空却执行出队操作而进入阻塞的线程
        }
    }

    /**
     * 出队操作
     */
    public String take() throws InterruptedException {

        synchronized (locker) {
            if (size <= 0) {
                // 当前队列为空，进入阻塞
                locker.wait();
            }

            // 队列非空，将队首元素出队
            String ret = elems[head];
            head++;
            if (head >= elems.length) {
                // 因为为循环队列，当头指针超过当前队列最大容量时，重新回到队列起始下标
                head = 0;
            }
            size--;
            locker.notify(); // 队列已出数据，释放因队列已满却执行入队操作而进入阻塞的线程
            return ret;
        }
    }
}

上述代码总体上看没什么问题，但仔细观察可以发现，还存在着一个问题：

当出队操作执行notify操作后，假设因线程已满而进入阻塞状态的线程1被唤醒，此时size未满，能够正常入队，执行入队流程，可到最后一步时，它也执行了一次notify操作，因为唤醒的线程是随机的，此时也是因为线程已满而进入阻塞状态的线程2也有可能被唤醒，那就糟糕了，此时它已经结束了对队列大小状态的if语句判断，相当于会直接进入wait语句下面的操作，再次进行一次入队操作，而此时队列又已满，这样就出现了超额错误！！

解决方法：

将if换成while，每次都会进行循环判断，这样就能防止因被错误唤醒而继续执行入队操作：

class MyBlockingQueue {

    private String[] elems = null;

    private int head = 0; // 头指针，指向队首元素
    private int tail = 0; // 尾指针，指向队尾元素的下一位

    private int size = 0; // 当前队列存储数据大小

    private Object locker = new Object(); // 定义锁对象

    public MyBlockingQueue(int capacity) {
        elems = new String[capacity];
    }

    /**
     * 入队操作
     */
    public void put(String elem) throws InterruptedException {

        synchronized(locker) {
            while (size >= elems.length) {
                // 当前队列已满，进入阻塞
                locker.wait();
            }

            // 队列未满，将数据添加进队列中
            elems[tail] = elem;
            tail++;
            if (tail >= elems.length) {
                // 因为为循环队列，当尾指针超过当前队列最大容量时，重新回到队列起始下标(不一定为队首)
                tail = 0;
            }
            size++;
            locker.notify(); // 队列已添加数据，释放因为队列为空却执行出队操作而进入阻塞的线程
        }
    }

    /**
     * 出队操作
     */
    public String take() throws InterruptedException {

        synchronized (locker) {
            while (size <= 0) {
                // 当前队列为空，进入阻塞
                locker.wait();
            }

            // 队列非空，将队首元素出队
            String ret = elems[head];
            head++;
            if (head >= elems.length) {
                // 因为为循环队列，当头指针超过当前队列最大容量时，重新回到队列起始下标
                head = 0;
            }
            size--;
            locker.notify(); // 队列已出数据，释放因队列已满却执行入队操作而进入阻塞的线程
            return ret;
        }
    }
}

构造一个生产者消费者模型来进行测试：

public class BlockingQueueTest {

    public static void main(String[] args) {
        
        // 自定义的阻塞队列
        MyBlockingQueue queue = new MyBlockingQueue(100);
		
        // 生产者
        Thread t1 = new Thread(() -> {
            int n = 1;
            while (true) {
                try {
                    queue.put(String.valueOf(n)); // 入队列
                    Thread.sleep(500);
                    System.out.println("生成数据：" + n);
                    n++;
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
		
        // 消费者
        Thread t2 = new Thread(() -> {
            while (true) {
                try {
                    String n = queue.take(); // 出队列
                    Thread.sleep(1000);
                    System.out.println("消费数据：" + n);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        t1.start();
        t2.start();
    }
}

执行结果如下，我们自定义的阻塞队列能够正常的使用了：

以上便是对阻塞队列的介绍与使用了，如果这些内容对大家有帮助的话请给一个三连关注吧💕( •̀ ω •́ )✧( •̀ ω •́ )✧✨