import java.util.LinkedList;
import java.util.concurrent.TimeUnit;
/**
 * 自定義阻塞隊(duì)列實(shí)現(xiàn)：輪詢版本
 * 
 * @param <T> 隊(duì)列中存儲(chǔ)的元素類型
 */
public class WhileQueue<T> {
    // 用來存儲(chǔ)元素的容器
    private final LinkedList<T> queue = new LinkedList<>();
    // 隊(duì)列的最大容量
    private final int MAX_SIZE = 1;
    /**
     * 將元素添加到隊(duì)列中
     * 
     * @param resource 要插入的元素
     * @throws InterruptedException 如果當(dāng)前線程被中斷
     */
    public void put(T resource) throws InterruptedException {
        // 如果隊(duì)列滿了，生產(chǎn)者線程將進(jìn)入輪詢等待狀態(tài)
        while (queue.size() >= MAX_SIZE) {
            System.out.println("生產(chǎn)者：隊(duì)列已滿，無法插入...");
            TimeUnit.MILLISECONDS.sleep(1000); // 線程等待1秒鐘再重試
        }
        // 插入元素到隊(duì)列的前面
        System.out.println("生產(chǎn)者：插入" + resource + "!!!");
        queue.addFirst(resource);
    }
    /**
     * 從隊(duì)列中取出元素
     * 
     * @throws InterruptedException 如果當(dāng)前線程被中斷
     */
    public void take() throws InterruptedException {
        // 如果隊(duì)列為空，消費(fèi)者線程將進(jìn)入輪詢等待狀態(tài)
        while (queue.size() <= 0) {
            System.out.println("消費(fèi)者：隊(duì)列為空，無法取出...");
            TimeUnit.MILLISECONDS.sleep(1000); // 線程等待1秒鐘再重試
        }
        // 從隊(duì)列的末尾取出元素
        System.out.println("消費(fèi)者：取出消息!!!");
        queue.removeLast();
        TimeUnit.MILLISECONDS.sleep(5000); // 模擬消費(fèi)操作需要時(shí)間
    }
}

/**
 * 測(cè)試類：創(chuàng)建生產(chǎn)者和消費(fèi)者線程來測(cè)試WhileQueue的功能
 */
public class Test {
    public static void main(String[] args) {
        // 創(chuàng)建一個(gè)WhileQueue實(shí)例
        WhileQueue<String> queue = new WhileQueue<>();
        // 創(chuàng)建并啟動(dòng)生產(chǎn)者線程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    try {
                        queue.put("消息" + i); // 插入消息到隊(duì)列
                    } catch (InterruptedException e) {
                        e.printStackTrace(); // 捕獲并打印中斷異常
                    }
                }
            }
        }).start();
        // 創(chuàng)建并啟動(dòng)消費(fèi)者線程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    try {
                        queue.take(); // 從隊(duì)列中取出消息
                    } catch (InterruptedException e) {
                        e.printStackTrace(); // 捕獲并打印中斷異常
                    }
                }
            }
        }).start();
    }
}

import java.util.LinkedList;
/**
 * 自定義阻塞隊(duì)列實(shí)現(xiàn)：使用 wait/notify
 * 
 * @param <T> 隊(duì)列中存儲(chǔ)的元素類型
 */
public class WaitNotifyQueue<T> {
    // 用來存儲(chǔ)元素的容器
    private final LinkedList<T> queue = new LinkedList<>();
    // 隊(duì)列的最大容量
    private final int MAX_SIZE = 1;
    /**
     * 將元素添加到隊(duì)列中
     * 
     * @param resource 要插入的元素
     * @throws InterruptedException 如果當(dāng)前線程被中斷
     */
    public synchronized void put(T resource) throws InterruptedException {
        // 當(dāng)隊(duì)列滿時(shí)，生產(chǎn)者線程進(jìn)入等待狀態(tài)
        while (queue.size() >= MAX_SIZE) {
            System.out.println("生產(chǎn)者：隊(duì)列已滿，無法插入...");
            this.wait(); // 釋放鎖，并進(jìn)入等待狀態(tài)
        }
        // 插入元素到隊(duì)列的前面
        System.out.println("生產(chǎn)者：插入" + resource + "!!!");
        queue.addFirst(resource);
        this.notify(); // 喚醒等待的消費(fèi)者線程
    }
    /**
     * 從隊(duì)列中取出元素
     * 
     * @throws InterruptedException 如果當(dāng)前線程被中斷
     */
    public synchronized void take() throws InterruptedException {
        // 當(dāng)隊(duì)列為空時(shí)，消費(fèi)者線程進(jìn)入等待狀態(tài)
        while (queue.size() <= 0) {
            System.out.println("消費(fèi)者：隊(duì)列為空，無法取出...");
            this.wait(); // 釋放鎖，并進(jìn)入等待狀態(tài)
        }
        // 從隊(duì)列的末尾取出元素
        System.out.println("消費(fèi)者：取出消息!!!");
        queue.removeLast();
        this.notify(); // 喚醒等待的生產(chǎn)者線程
    }
}

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionQueue<T> {
    // 容器，用來裝東西
    private final LinkedList<T> queue = new LinkedList<>();
    private final int CAPACITY = 10; // 隊(duì)列容量
    // 顯式鎖（相對(duì)地，synchronized鎖被稱為隱式鎖）
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition producerCondition = lock.newCondition();
    private final Condition consumerCondition = lock.newCondition();
    public void put(T resource) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() >= CAPACITY) {
                // 隊(duì)列滿了，不能再塞東西了，等待消費(fèi)者取出數(shù)據(jù)
                System.out.println("生產(chǎn)者：隊(duì)列已滿，無法插入...");
                // 生產(chǎn)者阻塞
                producerCondition.await();
            }
            System.out.println("生產(chǎn)者：插入" + resource + "!!!");
            queue.addFirst(resource);
            // 生產(chǎn)完畢，喚醒消費(fèi)者
            consumerCondition.signal();
        } finally {
            lock.unlock();
        }
    }
    public void take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() <= 0) {
                // 隊(duì)列空了，不能再取東西，等待生產(chǎn)者插入數(shù)據(jù)
                System.out.println("消費(fèi)者：隊(duì)列為空，無法取出...");
                // 消費(fèi)者阻塞
                consumerCondition.await();
            }
            System.out.println("消費(fèi)者：取出消息!!!");
            queue.removeLast();
            // 消費(fèi)完畢，喚醒生產(chǎn)者
            producerCondition.signal();
        } finally {
            lock.unlock();
        }
    }
}

public class BlockingQueue<T> {
    private final LinkedList<T> queue = new LinkedList<>();
    private int MAX_SIZE = 1;
    private int remainCount = 0;
    public BlockingQueue(int capacity) {
        if (capacity <= 0) {
            throw new IllegalArgumentException("size最小為1");
        }
        this.MAX_SIZE = capacity;
    }
    public synchronized void put(T resource) throws InterruptedException {
        while (queue.size() >= MAX_SIZE) {
            this.wait();
        }
        queue.addFirst(resource);
        remainCount++;
        this.notifyAll();
    }
    public synchronized T take() throws InterruptedException {
        while (queue.size() <= 0) {
            this.wait();
        }
        T resource = queue.removeLast();
        remainCount--;
        this.notifyAll();
        return resource;
    }
}