import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.BlockingDeque;
public class Test {
    public static void main(String[] args) throws InterruptedException {
        //不能直接newBlockingDeque，因為它是一個接口，要向上轉(zhuǎn)型
        //LinkedBlockingDeque內(nèi)部是基于鏈表方式來實現(xiàn)的
        BlockingDeque<String> queue=new LinkedBlockingDeque<>(10);//此處可以指定一個具體的數(shù)字，這里的的10代表隊列的最大容量
        queue.put("hello");
        String elem=queue.take();
        System.out.println(elem);
        elem=queue.take();
        System.out.println(elem);
    }
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class TestDemo {
    public static void main(String[] args) {
        // 使用一個 BlockingQueue 作為交易場所
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>();
        // 此線程作為消費者
        Thread customer = new Thread() {
            @Override
            public void run() {
                while (true) {
                    // 取隊首元素
                    try {
                        Integer value = queue.take();
                        System.out.println("消費元素: " + value);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        customer.start();
        // 此線程作為生產(chǎn)者
        Thread producer = new Thread() {
            @Override
            public void run() {
                for (int i = 1; i <= 10000; i++) {
                    System.out.println("生產(chǎn)了元素: " + i);
                    try {
                        queue.put(i);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        producer.start();
        try {
            customer.join();
            producer.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Test2 {
    static class BlockingQueue {
    private int[] items = new int[1000];    // 此處的1000相當(dāng)于隊列的最大容量, 此處暫時不考慮擴(kuò)容的問題.
    private int head = 0;//定義隊頭
    private int tail = 0;//定義隊尾
    private int size = 0;//數(shù)組大小
    private Object locker = new Object();

    // put 用來入隊列
    public void put(int item) throws InterruptedException {
        synchronized (locker) {
            while (size == items.length) {
                // 隊列已經(jīng)滿了，阻塞隊列開始阻塞
                locker.wait();
            }
            items[tail] = item;
            tail++;
            // 如果到達(dá)末尾, 就回到起始位置.
            if (tail >= items.length) {
                tail = 0;
            }
            size++;
            locker.notify();
        }
    }
    // take 用來出隊列
    public int take() throws InterruptedException {
        int ret = 0;
        synchronized (locker) {
            while (size == 0) {
                // 對于阻塞隊列來說, 如果隊列為空, 再嘗試取元素, 就要阻塞
                locker.wait();
            }
            ret = items[head];
            head++;
            if (head >= items.length) {
                head = 0;
            }
            size--;
            // 此處的notify 用來喚醒 put 中的 wait
            locker.notify();
        }
        return ret;
    }
}

    public static void main(String[] args) throws InterruptedException {
        BlockingQueue queue = new BlockingQueue();
        // 消費者線程
        Thread consumer = new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        int elem = queue.take();
                        System.out.println("消費元素: " + elem);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        consumer.start();

        // 生產(chǎn)者線程
        Thread producer = new Thread() {
            @Override
            public void run() {
                for (int i = 1; i < 10000; i++) {
                    System.out.println("生產(chǎn)元素: " + i);
                    try {
                        queue.put(i);
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        producer.start();
        consumer.join();
        producer.join();
    }
}