countDownLatch

原創

风清_云扬

2020-02-22 20:20

1.背景：

countDownLatch是在java1.5被引入，跟它一起被引入的工具類還有CyclicBarrier、Semaphore、concurrentHashMap和BlockingQueue。
存在於java.util.cucurrent包下。

2.概念

countDownLatch這個類使一個線程等待其他線程各自執行完畢後再執行。
是通過一個計數器來實現的，計數器的初始值是線程的數量。每當一個線程執行完畢後，計數器的值就-1，當計數器的值爲0時，表示所有線程都執行完畢，然後在閉鎖上等待的線程就可以恢復工作了。

3.源碼

countDownLatch類中只提供了一個構造器：

//參數count爲計數值
public CountDownLatch(int count) {  };

類中有三個方法是最重要的：

//調用await()方法的線程會被掛起，它會等待直到count值爲0才繼續執行
public void await() throws InterruptedException { };   
//和await()類似，只不過等待一定的時間後count值還沒變爲0的話就會繼續執行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  
//將count值減1
public void countDown() { };

4.示例

普通示例：

public class CountDownLatchTest {

    public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(2);
        System.out.println("主線程開始執行…… ……");
        //第一個子線程執行
        ExecutorService es1 = Executors.newSingleThreadExecutor();
        es1.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                    System.out.println("子線程："+Thread.currentThread().getName()+"執行");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                latch.countDown();
            }
        });
        es1.shutdown();

        //第二個子線程執行
        ExecutorService es2 = Executors.newSingleThreadExecutor();
        es2.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("子線程："+Thread.currentThread().getName()+"執行");
                latch.countDown();
            }
        });
        es2.shutdown();
        System.out.println("等待兩個線程執行完畢…… ……");
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("兩個子線程都執行完畢，繼續執行主線程");
    }
}

結果集：

主線程開始執行…… ……
等待兩個線程執行完畢…… ……
子線程：pool-1-thread-1執行
子線程：pool-2-thread-1執行
兩個子線程都執行完畢，繼續執行主線程

模擬併發示例：

public class Parallellimit {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        CountDownLatch cdl = new CountDownLatch(100);
        for (int i = 0; i < 100; i++) {
            CountRunnable runnable = new CountRunnable(cdl);
            pool.execute(runnable);
        }
    }
}

 class CountRunnable implements Runnable {
    private CountDownLatch countDownLatch;
    public CountRunnable(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        try {
            synchronized (countDownLatch) {
                /*** 每次減少一個容量*/
                countDownLatch.countDown();
                System.out.println("thread counts = " + (countDownLatch.getCount()));
            }
            countDownLatch.await();
            System.out.println("concurrency counts = " + (100 - countDownLatch.getCount()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}