使用環境：

• 在Java多執行緒應用中，佇列的使用率很高，多數生產消費模型的首選資料結構就是佇列(先進先出)。Java提供的執行緒安全的Queue可以分為阻塞佇列和非阻塞佇列，其中阻塞佇列的典型例子是BlockingQueue，非阻塞佇列的典型例子是ConcurrentLinkedQueue，在實際應用中要根據實際需要選用阻塞佇列或者非阻塞佇列。
• 注：什麼叫執行緒安全？這個首先要明確。執行緒安全就是說多執行緒訪問同一程式碼，不會產生不確定的結果。

並行和併發區別

1、並行是指兩者同時做。
2、併發是指資源有限的情況下，兩者交替輪流使用資源，比如一段路(單核CPU資源)同時只能過一個人，A走一段後，讓給B，B用完繼續給A ，交替使用，目的是提高效率

LinkedBlockingQueue

由於LinkedBlockingQueue實現是執行緒安全的，實現了先進先出等特性，是作為生產者消費者的首選，LinkedBlockingQueue 可以指定容量，也可以不指定，不指定的話，預設最大是Integer.MAX_VALUE，其中主要用到put和take方法，put方法在佇列滿的時候會阻塞直到有佇列成員被消費，take方法在佇列空的時候會阻塞，直到有佇列成員被放進來。

package Test;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import
 
 java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

/**
 * 多執行緒模擬實現生產者／消費者模型
 *  
 * 
 */
public class Test {
    /**
     * 
     * 定義裝蘋果的籃子,類似於Proxy
     * 
     */
    public class Basket {
        // 籃子，能夠容納3個蘋果
        BlockingQueue<String> basket = new LinkedBlockingQueue<String>(3
 
);

        // 生產蘋果，放入籃子
        public void produce() throws InterruptedException {
            // put方法放入一個蘋果，若basket滿了，等到basket有位置
            basket.put("An apple");
        }

        // 消費蘋果，從籃子中取走
        public String consume() throws InterruptedException {
            // take方法取出一個蘋果，若basket為空，等到basket有蘋果為止(獲取並移除此佇列的頭部)
            return basket.take();
        }
    }

    // 定義蘋果生產者
    class Producer implements Runnable {
        private String instance;
        private Basket basket;

        public Producer(String instance, Basket basket) {
            this.instance = instance;
            this.basket = basket;
        }

        public void run() {
            try {
                while (true) {
                    // 生產蘋果
                    System.out.println("生產者準備生產蘋果：" + instance);
                    basket.produce();
                    System.out.println("!生產者生產蘋果完畢：" + instance);
                    // 休眠300ms
                    Thread.sleep(300);
                }
            } catch (InterruptedException ex) {
                System.out.println("Producer Interrupted");
            }
        }
    }

    // 定義蘋果消費者
    class Consumer implements Runnable {
        private String instance;
        private Basket basket;

        public Consumer(String instance, Basket basket) {
            this.instance = instance;
            this.basket = basket;
        }

        public void run() {
            try {
                while (true) {
                    // 消費蘋果
                    System.out.println("消費者準備消費蘋果：" + instance);
                    System.out.println(basket.consume());
                    System.out.println("!消費者消費蘋果完畢：" + instance);
                    // 休眠1000ms
                    Thread.sleep(1000);
                }
            } catch (InterruptedException ex) {
                System.out.println("Consumer Interrupted");
            }
        }
    }

    public static void main(String[] args) {
        Test test = new Test();

        // 建立一個裝蘋果的籃子
        Basket basket = test.new Basket();

        ExecutorService service = Executors.newCachedThreadPool();
        Producer producer = test.new Producer("生產者001", basket);
        Producer producer2 = test.new Producer("生產者002", basket);
        Consumer consumer = test.new Consumer("消費者001", basket);
        service.submit(producer);
        service.submit(producer2);
        service.submit(consumer);


        // 程式執行5s後，所有任務停止
//        try {
//            Thread.sleep(1000 * 5);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
//        service.shutdownNow();
    }

}

ConcurrentLinkedQueue

 ConcurrentLinkedQueue是Queue的一個安全實現．Queue中元素按FIFO原則進行排序．採用CAS操作，來保證元素的一致性。

LinkedBlockingQueue是一個執行緒安全的阻塞佇列，它實現了BlockingQueue介面，BlockingQueue介面繼承自java.util.Queue介面，並在這個介面的基礎上增加了take和put方法，這兩個方法正是佇列操作的阻塞版本。

package Test;

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestconcurrentLinkedQueue {
     private static ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<Integer>();
        private static int count = 2; // 執行緒個數
        //CountDownLatch，一個同步輔助類，在完成一組正在其他執行緒中執行的操作之前，它允許一個或多個執行緒一直等待。
        private static CountDownLatch latch = new CountDownLatch(count);

        public static void main(String[] args) throws InterruptedException {
            long timeStart = System.currentTimeMillis();
            ExecutorService es = Executors.newFixedThreadPool(4);
            TestconcurrentLinkedQueue.offer();
            for (int i = 0; i < count; i++) {
                es.submit(new Poll());
            }
            latch.await(); //使得主執行緒(main)阻塞直到latch.countDown()為零才繼續執行
            System.out.println("cost time " + (System.currentTimeMillis() - timeStart) + "ms");
            es.shutdown();
        }

        /**
         * 生產
         */
        public static void offer() {
            for (int i = 0; i < 100000; i++) {
                queue.offer(i);
            }
        }


        /**
         * 消費
         *  
         *
         */
        static class Poll implements Runnable {
            public void run() {
                // while (queue.size()>0) {
                while (!queue.isEmpty()) {
                    System.out.println(queue.poll());
                }
                latch.countDown();
            }
        }
}