Java併發編程學習系列三：輔助類與阻塞隊列

輔助類

CountDownLatch

減法計數器，位於 java.util.concurrent 包下，咱們看一下關於它的定義。

主要方法有：

首先咱們看一個簡單的案例：

public class CountDownLatchDemo {

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(6);

        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"get out");
                countDownLatch.countDown();//計數器減1
            },String.valueOf(i)).start();

        }
        //計算器歸零，await被喚醒
        countDownLatch.await();//等待計數器歸零，才向下繼續執行
        System.out.println("end");
    }
}
複製代碼

執行結果爲：

0get out
1get out
2get out
3get out
5get out
4get out
end
複製代碼

來個複雜點的，好比說有這樣一個場景：一個大巴司機來接送一羣工人去工做，只有當司機到了，工人們才能夠出發準備去工做；一樣的，只有等工人們都完成工做以後，司機才能接他們回去。轉換爲代碼設計：

使用兩倒計時鎖：

• 第一個是一個開始信號，防止任何工人進入，直到司機準備好才能進入；
• 第二個是一個完成信號，容許司機等待，直到全部的工人已經完成。

public class DriverTest {

    static final int N = 10;

    public static void main(String[] args) throws InterruptedException {
        CountDownLatch startSignal = new CountDownLatch(1);
        CountDownLatch doneSignal = new CountDownLatch(N);

        for (int i = 0; i < N; ++i){
            new Thread(new Worker(startSignal, doneSignal),"工人"+(i+1)+"號").start();
        }

        doSomethingElse1();            // don't let run yet
        startSignal.countDown();      // let all threads proceed
        doneSignal.await();           // wait for all to finish
        doSomethingElse2();
    }

    public static void doSomethingElse1() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        System.out.println("司機來送工人去工做");
    }

    public static void doSomethingElse2() throws InterruptedException {
        TimeUnit.SECONDS.sleep(1);
        System.out.println("司機來接工人回去");
    }
}

class Worker implements Runnable {
    private final CountDownLatch startSignal;
    private final CountDownLatch doneSignal;
    Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
        this.startSignal = startSignal;
        this.doneSignal = doneSignal;
    }
    public void run() {
        try {
            startSignal.await();
            doWork();
            doneSignal.countDown();
        } catch (InterruptedException ex) {} // return;
    }

    void doWork() throws InterruptedException {
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName()+"開始工做......");
    }
}
複製代碼

執行結果爲：

司機來送工人去工做
工人4號開始工做......
工人6號開始工做......
工人8號開始工做......
工人3號開始工做......
工人7號開始工做......
工人9號開始工做......
工人2號開始工做......
工人1號開始工做......
工人10號開始工做......
工人5號開始工做......
司機來接工人回去
複製代碼

CyclicBarrier

加法計數器，與 CountDownLatch 做用相反。

主要方法有：

public class CyclicBarrierDemo {

    public static void main(String[] args) {

        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("召喚神龍");
        });

        for (int i = 0; i < 7; i++) {
            final int temp = i+1;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"個龍珠");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();

        }
    }
}
複製代碼

Semaphore

計數器信號量。

如下是個搶車位的案例，假設有6我的去搶3個車位，誰先搶到誰佔用，直到離開下一我的再去搶用。

public class SemaphoreDemo {

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);

        for (int i = 0; i < 6; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"搶到了車位！");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"離開了車位！");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            }).start();

        }
    }
}
複製代碼

semaphore.acquire() 方法表示從該信號量獲取許可證，假設已經滿了，則等待，直到有許可證被釋放。

semaphore.release() 方法表示釋放許可證，將其返回到信號量。同時喚醒那些還在等待的線程。

做用：多個共享資源互斥的使用，併發限流，控制最大線程數。

阻塞隊列

BlockingQueue

概念

如下是官方文檔對於阻塞隊列的介紹：

咱們來看一下 BlockingQueue 的接口圖：

• ArrayBlockingQueue： 由 數 組 結 構 組 成 的 有 界 阻 塞 隊 列 。
• LinkedBlockingQueue：由鏈表結構組成的有界（默認值爲：integer.MAX_VALUE）阻塞隊列。
• PriorityBlockingQueue：支持優先級排序的無界阻塞隊列
• DelayQueue：使用優先級隊列實現的延遲無界阻塞隊列。
• SynchronousQueue：不存儲元素的阻塞隊列，也即單個元素的隊列。
• LinkedTransferQueue：由鏈表組成的無界阻塞隊列。
• LinkedBlockingDeque：由鏈表組成的雙向阻塞隊列。

阻塞隊列是一個隊列，在數據結構中起的做用以下圖：

當隊列是空的，從隊列中獲取元素的操做將會被阻塞。直到其餘線程往空的隊列插入新的元素。

當隊列是滿的，從隊列中添加元素的操做將會被阻塞。直到其餘線程從隊列中移除一個或多個元素或者徹底清空，使隊列變得空閒起來並後續新增。

做用

在多線程領域：所謂阻塞，在某些狀況下會掛起線程（即阻塞），一旦條件知足，被掛起的線程又會自動被喚起。

爲何須要 BlockingQueue？

好處是咱們不須要關心何時須要阻塞線程，何時須要喚醒線程，由於這一切BlockingQueue 都給你一手包辦了。

在 concurrent 包發佈之前，在多線程環境下，咱們每一個程序員都必須本身去控制這些細節，尤爲還要兼顧效率和線程安全，而這會給咱們的程序帶來不小的複雜度。

核心方法

經常使用 API

對上述內容的詳細解釋以下：

咱們對上述內容進行代碼展現，首先是拋出異常狀況下的插入和移除方法使用：

public class BlockingQueueTest {

    public static void main(String[] args) throws InterruptedException {

        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        //java.lang.IllegalStateException: Queue full
        System.out.println(blockingQueue.add("A"));
        System.out.println(blockingQueue.add("B"));
        System.out.println(blockingQueue.add("C"));
//        System.out.println(blockingQueue.add("D")); //此時隊列已滿，報錯 java.lang.IllegalStateException: Queue full

        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
//        System.out.println(blockingQueue.remove()); //隊列已空，報錯java.util.NoSuchElementException
    }
}
複製代碼

返回特殊值

public class BlockingQueueTest {

    public static void main(String[] args) throws InterruptedException {

        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        System.out.println(blockingQueue.offer("A"));
        System.out.println(blockingQueue.offer("B"));
        System.out.println(blockingQueue.offer("C"));
        System.out.println(blockingQueue.offer("D"));//隊列已滿，插入失敗，返回false

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());//隊列已空，返回null
    }
}
複製代碼

一直阻塞

public class BlockingQueueTest {

    public static void main(String[] args) throws InterruptedException {

        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        blockingQueue.put("A");
        blockingQueue.put("B");
        blockingQueue.put("C");
//        blockingQueue.put("D"); //隊列已滿，會一直阻塞下去

        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());//返回正常值
//        System.out.println(blockingQueue.take());//隊列已空，會一直阻塞
    }
}
複製代碼

超時等待

public class BlockingQueueTest {

    public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(3);

        blockingQueue.offer("A");
        blockingQueue.offer("B");
        blockingQueue.offer("C");
//        blockingQueue.offer("D",2, TimeUnit.SECONDS);//隊列已滿，則等待2s後結束

        blockingQueue.poll();
        blockingQueue.poll();
        blockingQueue.poll();
//        blockingQueue.poll(3,TimeUnit.SECONDS); //隊列已空，等待3s後結束
    }
}
複製代碼

SynchronousQueue

同步隊列 SynchronousQueue 沒有容量。

與其餘的 BlockingQueue 不一樣，SynchronousQueue 是一個不存儲元素的 BlockingQueue 。每個 put 操做必需要等待一個 take 操做，不然不能繼續添加元素，反之亦然。

public class SynchronousQueueDemo {

    public static void main(String[] args) {
        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();//同步隊列

        new Thread(()->{
            try {
                System.out.println(Thread.currentThread().getName()+"put 1");
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName()+"put 2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName()+"put 3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T1").start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"get data:"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"get data:"+blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"get data:"+blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"T2").start();
    }

}
複製代碼

執行結果爲：

T1put 1
T2get data:1
T1put 2
T2get data:2
T1put 3
T2get data:3
複製代碼

參考文獻

BlockingQueue（阻塞隊列）詳解

Java阻塞隊列詳解

Java併發編程：Callable、Future和FutureTask