#阻塞队列（Array/Linked/Synchronous/Delay）

public interface BlockingQueue<E> extends Queue<E> {
    // 阻塞插入
    void put(E e) throws InterruptedException;
    
    // 阻塞移除
    E take() throws InterruptedException;
    
    // 超时插入
    boolean offer(E e, long timeout, TimeUnit unit) throws InterruptedException;
    
    // 超时移除
    E poll(long timeout, TimeUnit unit) throws InterruptedException;
    
    // 非阻塞插入（队列满则抛异常）
    boolean add(E e);
    
    // 非阻塞插入（队列满则返回 false）
    boolean offer(E e);
    
    // 非阻塞移除（队列空则返回 null）
    E poll();
}

// 固定容量，需要指定大小
BlockingQueue<String> queue = new ArrayBlockingQueue<>(100);

// 特点：
// - 有界队列
// - 基于数组实现
// - FIFO 顺序
// - 可选公平/非公平
BlockingQueue<String> fairQueue = new ArrayBlockingQueue<>(100, true);

// ArrayBlockingQueue 内部结构
public class ArrayBlockingQueue<E> {
    private final Object[] items;  // 数组存储
    private int takeIndex;         // 下一个读取位置
    private int putIndex;         // 下一个写入位置
    private int count;            // 元素数量
    
    private final ReentrantLock lock;  // 重入锁
    
    private final Condition notEmpty;   // 非空条件
    private final Condition notFull;    // 非满条件
}

// 线程池队列配置
ThreadPoolExecutor executor = new ThreadPoolExecutor(
    10, 20,
    60L, TimeUnit.SECONDS,
    new ArrayBlockingQueue<>(100),  // 有界，不会 OOM
    Executors.defaultThreadFactory(),
    new ThreadPoolExecutor.AbortPolicy()
);

// 可选容量（默认 Integer.MAX_VALUE）
BlockingQueue<String> queue1 = new LinkedBlockingQueue<>();  // 无界！
BlockingQueue<String> queue2 = new LinkedBlockingQueue<>(1000);  // 有界

// 特点：
// - 基于链表实现
// - 默认无界（容量 Integer.MAX_VALUE）
// - 插入和移除使用不同的锁
// - 比 ArrayBlockingQueue 吞吐量更高

// LinkedBlockingQueue 内部结构
public class LinkedBlockingQueue<E> {
    private final int capacity;  // 容量
    private final AtomicInteger count = new AtomicInteger(0);  // 元素计数
    
    private Node<E> head;         // 头节点（哑节点）
    private Node<E> last;         // 尾节点
    
    private final ReentrantLock takeLock = new ReentrantLock();  // 取锁
    private final Condition notEmpty = takeLock.newCondition();
    
    private final ReentrantLock putLock = new ReentrantLock();   // 放锁
    private final Condition notFull = putLock.newCondition();
}

// 危险：无界队列
BlockingQueue<String> queue = new LinkedBlockingQueue<>();

// 问题：
// 1. 生产者速度 > 消费者速度时
// 2. 队列无限增长
// 3. 内存暴涨
// 4. OOM

// 同步队列，不存储元素
BlockingQueue<String> queue = new SynchronousQueue<>();

// 特点：
// - 不存储元素
// - 每个 put 必须等待一个 take，反之亦然
// - 用于两个线程之间的直接传递

// 场景1：Executors.newCachedThreadPool
ExecutorService cachedExecutor = Executors.newCachedThreadPool();
// 内部使用 SynchronousQueue
// 每个任务必须立即被线程取走

// 场景2：线程间直接传递
public class DirectTransfer {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new SynchronousQueue<>();
        
        Thread producer = new Thread(() -> {
            try {
                System.out.println("准备发送...");
                queue.put("Hello");  // 阻塞
                System.out.println("已发送");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        Thread consumer = new Thread(() -> {
            try {
                Thread.sleep(1000);
                String msg = queue.take();  // 等待
                System.out.println("收到: " + msg);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        
        producer.start();
        consumer.start();
    }
}

// 延迟队列
BlockingQueue<DelayedTask> queue = new DelayQueue<>();

// 特点：
// - 只有超过延迟时间的元素才能被取出
// - 基于 PriorityQueue 实现
// - 用于定时任务调度

public class DelayedTask implements Delayed {
    private final String taskName;
    private final long delayTime;
    private final long expireTime;  // 到期时间
    
    public DelayedTask(String taskName, long delayTime, TimeUnit unit) {
        this.taskName = taskName;
        this.delayTime = unit.toNanos(delayTime);
        this.expireTime = System.nanoTime() + this.delayTime;
    }
    
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(expireTime - System.nanoTime(), TimeUnit.NANOSECONDS);
    }
    
    @Override
    public int compareTo(Delayed o) {
        DelayedTask other = (DelayedTask) o;
        return Long.compare(this.expireTime, other.expireTime);
    }
}

// 使用
BlockingQueue<DelayedTask> queue = new DelayQueue<>();

queue.put(new DelayedTask("Task1", 5, TimeUnit.SECONDS));
queue.put(new DelayedTask("Task2", 2, TimeUnit.SECONDS));

// 2秒后取出 Task2
DelayedTask task2 = queue.take();  // 阻塞2秒

// 再过3秒取出 Task1
DelayedTask task1 = queue.take();  // 再阻塞3秒

public class DelayedTaskScheduler {
    private final DelayQueue<Task> queue = new DelayQueue<>();
    
    public void schedule(Runnable task, long delay, TimeUnit unit) {
        queue.put(new Task(task, delay, unit));
    }
    
    public void start() {
        while (true) {
            try {
                Task task = queue.take();  // 等待任务到期
                task.execute();
            } catch (InterruptedException e) {
                break;
            }
        }
    }
}

// 优先级队列
BlockingQueue<Integer> queue = new PriorityBlockingQueue<>();

queue.put(5);
queue.put(1);
queue.put(3);

System.out.println(queue.take());  // 输出 1
System.out.println(queue.take());  // 输出 3
System.out.println(queue.take());  // 输出 5

// 双向阻塞队列
BlockingQueue<String> deque = new LinkedBlockingDeque<>();

// 可以从任意一端插入和移除
deque.putFirst("A");
deque.putLast("B");
deque.takeFirst();  // "A"
deque.takeLast();   // "B"

// 线程池队列选择

// 场景1：资源受限，任务重要 → ArrayBlockingQueue
new ArrayBlockingQueue<>(100)

// 场景2：高吞吐量，可以接受任务丢失 → LinkedBlockingQueue（无界）
// 不推荐！容易 OOM

// 场景3：线程池需要立即执行 → SynchronousQueue
new SynchronousQueue<>()

// 场景4：定时任务 → DelayQueue
new DelayQueue<>()

// 场景5：优先级任务 → PriorityBlockingQueue
new PriorityBlockingQueue<>()