import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;

public class BlockingQueueDemo {
    public static void main(String[] args) {
        // 创建容量为3的有界阻塞队列
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(3);

        // 启动1个生产者线程
        new Thread(new Producer(queue), "生产者").start();
        // 启动1个消费者线程
        new Thread(new Consumer(queue), "消费者").start();
    }

    // 生产者：向队列中放入数据
    static class Producer implements Runnable {
        private final ArrayBlockingQueue<Integer> queue;

        public Producer(ArrayBlockingQueue<Integer> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            Random random = new Random();
            while (true) {
                int num = random.nextInt(100); // 生成随机数
                try {
                    queue.put(num); // 队列满时阻塞
                    System.out.println(Thread.currentThread().getName() + " 放入：" + num + "，当前队列大小：" + queue.size());
                    Thread.sleep(500); // 模拟生产耗时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 消费者：从队列中取数据
    static class Consumer implements Runnable {
        private final ArrayBlockingQueue<Integer> queue;

        public Consumer(ArrayBlockingQueue<Integer> queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    int num = queue.take(); // 队列空时阻塞
                    System.out.println(Thread.currentThread().getName() + " 取出：" + num + "，当前队列大小：" + queue.size());
                    Thread.sleep(1000); // 模拟消费耗时（比生产慢）
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class BlockingQueueMethods {
    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(2);

        // 1. 阻塞式方法：put（满则等）、take（空则等）
        queue.put("A");
        queue.put("B"); // 队列已满，再put会阻塞（此处若再加put会卡住）
        System.out.println("阻塞式放入后：" + queue); // [A, B]

        String s1 = queue.take();
        System.out.println("阻塞式取出：" + s1 + "，剩余：" + queue); // [B]

        // 2. 非阻塞式方法：add（满则抛异常）、remove（空则抛异常）
        boolean addOk = queue.add("C"); // 队列有空间，添加成功
        System.out.println("add成功：" + addOk + "，队列：" + queue); // [B, C]

        try {
            queue.add("D"); // 队列已满，add会抛IllegalStateException
        } catch (IllegalStateException e) {
            System.out.println("add失败：队列已满");
        }

        // 3. 超时式方法：offer（满则等超时）、poll（空则等超时）
        boolean offerOk = queue.offer("D", 1, TimeUnit.SECONDS); // 等待1秒，若仍满则返回false
        System.out.println("offer超时后是否成功：" + offerOk); // false（1秒内队列未空）

        String s2 = queue.poll(1, TimeUnit.SECONDS); // 等待1秒，取出B
        System.out.println("poll超时取出：" + s2 + "，剩余：" + queue); // [C]
    }
}

import java.util.concurrent.LinkedBlockingQueue;

public class LinkedBlockingQueueDemo {
    public static void main(String[] args) throws InterruptedException {
        // 无界队列（默认容量极大，可视为无限）
        LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>();

        // 快速放入1000个元素（不会阻塞，因为无界）
        for (int i = 0; i < 1000; i++) {
            queue.put("任务" + i);
        }
        System.out.println("放入1000个任务后，队列大小：" + queue.size()); // 1000

        // 取出第一个任务
        System.out.println("取出：" + queue.take()); // 任务0
    }
}

import java.util.concurrent.SynchronousQueue;

public class SynchronousQueueDemo {
    public static void main(String[] args) {
        SynchronousQueue<String> queue = new SynchronousQueue<>();

        // 生产者线程：放入元素后会阻塞，直到被取走
        new Thread(() -> {
            try {
                System.out.println("生产者：准备放入数据");
                queue.put("同步数据"); // 必须等待消费者取走，否则一直阻塞
                System.out.println("生产者：数据被取走，继续执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        // 消费者线程：1秒后取数据
        new Thread(() -> {
            try {
                Thread.sleep(1000); // 延迟1秒
                String data = queue.take(); // 取走数据，释放生产者
                System.out.println("消费者：取出数据：" + data);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}