java.阻塞队列

在生产者和消费者模型中：
解决了生产者和消费者的生产消费耦合问题，，因为生产者和消费者不会直接进行通讯，通讯的任务就交给阻塞队列来完成，阻塞队列就好比一个缓冲区域，当生产者把面包生产出来之后直接丢给阻塞队列，而消费者需要购买面包时也是直接去阻塞队列里面找，消费者不会去找生产者要面包，这样就平衡了双方的处理

示例：

import java.util.Random;
import java.util.concurrent.PriorityBlockingQueue;

public class NormalTest {
    public static void main(String[] args) {
        PriorityBlockingQueue<Integer> queue = new PriorityBlockingQueue(20);
        // 加入阻塞队列
        for (int i = 0; i < 20; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        int num = new Random().nextInt(100) + 1;
                        System.out.println(num);
                        queue.offer(num);
                    }
                }
            }).start();
        }
        
        // 从阻塞队列取出
        for (int i = 0; i < 20; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        // num 的值为再边界为100
                        System.out.println(queue.poll());
                    }
                }
            }).start();
        }
    }
}

自己实现的版本：

package lesson07;

import java.util.Random;

public class MyBlockingQueue<E> {

    private Object[] elements;

    // 添加元素时的位置
    private int addIndex;

    // 取出元素时的位置
    private int takeIndex;

    // 队列大小
    private int size;

    public MyBlockingQueue(int capacity) {
        elements = new Object[capacity];
    }

    public synchronized E poll() {
        E element = null;
        try {
            while (size == 0) {
                wait();
            }
            element = (E) elements[takeIndex];
            takeIndex = (takeIndex + 1) % elements.length;
            size--;
            notifyAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return element;
    }

    public synchronized void offer(E element) {
        try {
            while (size == elements.length) {
                wait();
            }
            elements[addIndex] = element;
            addIndex = (addIndex + 1) % elements.length;
            size++;
            notifyAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        MyBlockingQueue<Integer> queue = new MyBlockingQueue<>(20);
        for (int i = 0; i < 20; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        // num 的值为再边界为100
                        int num = new Random().nextInt(100) + 1;
                        System.out.println(num);
                        queue.offer(num);
                    }
                }
            }).start();
        }

        for (int i = 0; i < 20; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        // num 的值为再边界为100
                        System.out.println(queue.poll());
                    }
                }
            }).start();
        }
    }
}