16-自定义阻塞队列

队列实现有两种方式：数组和链表。这里使用数组。

import java.util.Random;
import java.util.concurrent.ExecutionException;

public class App {
    static class MyBlockedQueue {
        private int first; // 队⾸
        private int last; // 队尾
        private int size; // 队列实际存储⻓度
        private int[] items; // 实际存储容器

        public MyBlockedQueue(int capaCity) {
            this.size = 0;
            this.first = 0;
            this.last = 0;
            this.items = new int[capaCity];
        }

        /**
         * ⼊列
         */
        public void offer(int val) throws InterruptedException {
            synchronized (this) {
                if (size == items.length) {
                    // 队列已满，阻塞等待
                    this.wait();
                }
                items[last] = val;
                last++;
                size++;
                // 判断是否是最后⼀个元素
                if (last == items.length) {
                    last = 0;
                }
                this.notify();
            }
        }

        /**
         * 出列
         */
        public int poll() throws InterruptedException {
            int result = 0;
            synchronized (this) {
                if (size == 0) {
                    // 队列中已经没有数据了
                    this.wait();
                }
                result = items[first];
                first++;
                size--;
                if (first == items.length) {
                    // 已经是最后⼀个数据了
                    first = 0;
                }
                this.notify();
            }
            return result;
        }
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        MyBlockedQueue myBlockedQueue = new MyBlockedQueue(10);
        // 1.⽣产数据
        Thread t1 = new Thread(() -> {
            while (true) {
                // ⽣成随机数据
                int num = new Random().nextInt(10);
                try {
                    System.out.println("添加数据：" + num);
                    // 添加数据
                    myBlockedQueue.offer(num);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t1.start();

        // 2.消费数据
        Thread t2 = new Thread(() -> {
            while (true) {
                try {
                    int result = myBlockedQueue.poll();
                    System.out.println("消费数据：" + result);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t2.start();
    }
}