java.util.concurrent系列之--併發隊列ConcurrentLinkedQueue和阻塞隊列LinkedBlockingQueue用法

在Java多線程應用中，隊列的使用率很高，多數生產消費模型的首選數據結構就是隊列(先進先出)。Java提供的線程安全的Queue能夠分爲阻塞隊列和非阻塞隊列，其中阻塞隊列的典型例子是BlockingQueue，非阻塞隊列的典型例子是ConcurrentLinkedQueue，在實際應用中要根據實際須要選用阻塞隊列或者非阻塞隊列。

注：什麼叫線程安全？這個首先要明確。線程安全就是說多線程訪問同一代碼，不會產生不肯定的結果。

1、並行和併發區別

一、並行是指二者同時執行一件事，好比賽跑，兩我的都在不停的往前跑； 二、併發是指資源有限的狀況下，二者交替輪流使用資源，好比一段路(單核CPU資源)同時只能過一我的，A走一段後，讓給B，B用完繼續給A ，交替使用，目的是提升效率

2、LinkedBlockingQueue

因爲LinkedBlockingQueue實現是線程安全的，實現了先進先出等特性，是做爲生產者消費者的首選，LinkedBlockingQueue 能夠指定容量，也能夠不指定，不指定的話，默認最大是Integer.MAX_VALUE，其中主要用到put和take方法，put方法在隊列滿的時候會阻塞直到有隊列成員被消費，take方法在隊列空的時候會阻塞，直到有隊列成員被放進來。

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

/**
 * 多線程模擬實現生產者／消費者模型
 *  
 */
public class BlockingQueueTest2 {
    /**
     * 
     * 定義裝蘋果的籃子
     * 
     */
    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) {
        BlockingQueueTest2 test = new BlockingQueueTest2();

        // 創建一個裝蘋果的籃子
        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();
    }

}

3、ConcurrentLinkedQueue

ConcurrentLinkedQueue是Queue的一個安全實現．Queue中元素按FIFO原則進行排序．採用CAS操做，來保證元素的一致性。 LinkedBlockingQueue是一個線程安全的阻塞隊列，它實現了BlockingQueue接口，BlockingQueue接口繼承自java.util.Queue接口，並在這個接口的基礎上增長了take和put方法，這兩個方法正是隊列操做的阻塞版本。

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

public class ConcurrentLinkedQueueTest {
    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);
        ConcurrentLinkedQueueTest.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();
        }
    }
}

4、運行結果：

costtime 2360ms

改用while (queue.size()>0)後

運行結果：cost time 46422ms

結果竟然相差那麼大，看了下ConcurrentLinkedQueue的API原來.size()是要遍歷一遍集合的，難怪那麼慢，因此儘可能要避免用size而改用isEmpty().

總結了下， 在單位缺少性能測試下，對本身的編程要求更加要嚴格，特別是在生產環境下更是要當心謹慎。

5、轉載地址

https://www.cnblogs.com/linjiqin/archive/2013/05/30/3108188.html