摘要：前言之前學(xué)多線程的時(shí)候沒(méi)有學(xué)習(xí)線程的同步工具類輔助類。而其它線程完成自己的操作后，調(diào)用使計(jì)數(shù)器減。信號(hào)量控制一組線程同時(shí)執(zhí)行。

之前學(xué)多線程的時(shí)候沒(méi)有學(xué)習(xí)線程的同步工具類(輔助類)。ps:當(dāng)時(shí)覺(jué)得暫時(shí)用不上，認(rèn)為是挺高深的知識(shí)點(diǎn)就沒(méi)去管了..

在前幾天，朋友發(fā)了一篇比較好的Semaphore文章過(guò)來(lái)，然后在瀏覽博客的時(shí)候又發(fā)現(xiàn)面試還會(huì)考，那還是挺重要的知識(shí)點(diǎn)。于是花了點(diǎn)時(shí)間去了解一下。

Java為我們提供了三個(gè)同步工具類：

CountDownLatch(閉鎖)

CyclicBarrier(柵欄)

Semaphore(信號(hào)量)

這幾個(gè)工具類其實(shí)說(shuō)白了就是為了能夠更好控制線程之間的通訊問(wèn)題~

A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.

簡(jiǎn)單來(lái)說(shuō)：CountDownLatch是一個(gè)同步的輔助類，允許一個(gè)或多個(gè)線程一直等待，直到其它線程完成它們的操作。

它常用的API其實(shí)就兩個(gè):await()和countDown()

使用說(shuō)明：

count初始化CountDownLatch，然后需要等待的線程調(diào)用await方法。await方法會(huì)一直受阻塞直到count=0。而其它線程完成自己的操作后，調(diào)用countDown()使計(jì)數(shù)器count減1。當(dāng)count減到0時(shí)，所有在等待的線程均會(huì)被釋放

說(shuō)白了就是通過(guò)count變量來(lái)控制等待，如果count值為0了(其他線程的任務(wù)都完成了)，那就可以繼續(xù)執(zhí)行。

例子：3y現(xiàn)在去做實(shí)習(xí)生了，其他的員工還沒(méi)下班，3y不好意思先走，等其他的員工都走光了，3y再走。

import java.util.concurrent.CountDownLatch;

public class Test {

    public static void main(String[] args) {

        final CountDownLatch countDownLatch = new CountDownLatch(5);

        System.out.println("現(xiàn)在6點(diǎn)下班了.....");

        // 3y線程啟動(dòng)
        new Thread(new Runnable() {
            @Override
            public void run() {
           
                try {
                    // 這里調(diào)用的是await()不是wait()
                    countDownLatch.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("...其他的5個(gè)員工走光了，3y終于可以走了");
            }
        }).start();

        // 其他員工線程啟動(dòng)
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("員工xxxx下班了");
                    countDownLatch.countDown();
                }
            }).start();
        }
    }
}

輸出結(jié)果：

再寫(xiě)個(gè)例子：3y現(xiàn)在負(fù)責(zé)倉(cāng)庫(kù)模塊功能，但是能力太差了，寫(xiě)得很慢，別的員工都需要等3y寫(xiě)好了才能繼續(xù)往下寫(xiě)。

import java.util.concurrent.CountDownLatch;

public class Test {

    public static void main(String[] args) {

        final CountDownLatch countDownLatch = new CountDownLatch(1);

        // 3y線程啟動(dòng)
        new Thread(new Runnable() {
            @Override
            public void run() {

                try {
                    Thread.sleep(5);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("3y終于寫(xiě)完了");
                countDownLatch.countDown();

            }
        }).start();

        // 其他員工線程啟動(dòng)
        for (int i = 0; i < 5; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("其他員工需要等待3y");
                    try {
                        countDownLatch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("3y終于寫(xiě)完了，其他員工可以開(kāi)始了！");
                }
            }).start();
        }
    }
}

輸出結(jié)果：

參考資料：

https://blog.csdn.net/qq_19431333/article/details/68940987

https://blog.csdn.net/panweiwei1994/article/details/78826072

http://www.importnew.com/15731.html

A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.  CyclicBarriers are useful in programs involving a fixed sized party of threads that must occasionally wait for each other. The barrier is called cyclic because it can be re-used after the waiting threads are released.

簡(jiǎn)單來(lái)說(shuō)：CyclicBarrier允許一組線程互相等待，直到到達(dá)某個(gè)公共屏障點(diǎn)。叫做cyclic是因?yàn)楫?dāng)所有等待線程都被釋放以后，CyclicBarrier可以被重用(對(duì)比于CountDownLatch是不能重用的)

使用說(shuō)明：

CountDownLatch注重的是等待其他線程完成，CyclicBarrier注重的是：當(dāng)線程到達(dá)某個(gè)狀態(tài)后，暫停下來(lái)等待其他線程，所有線程均到達(dá)以后，繼續(xù)執(zhí)行。

例子：3y和女朋友約了去廣州夜上海吃東西，由于3y和3y女朋友住的地方不同，自然去的路徑也就不一樣了。于是他倆約定在體育西路地鐵站集合，約定等到相互見(jiàn)面的時(shí)候就發(fā)一條朋友圈。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Test {

    public static void main(String[] args) {

        final CyclicBarrier CyclicBarrier = new CyclicBarrier(2);
        for (int i = 0; i < 2; i++) {

            new Thread(() -> {

                String name = Thread.currentThread().getName();
                if (name.equals("Thread-0")) {
                    name = "3y";
                } else {
                    name = "女朋友";
                }
                System.out.println(name + "到了體育西");
                try {

                    // 兩個(gè)人都要到體育西才能發(fā)朋友圈
                    CyclicBarrier.await();
                    // 他倆到達(dá)了體育西，看見(jiàn)了對(duì)方發(fā)了一條朋友圈：
                    System.out.println("跟" + name + "去夜上海吃東西~");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

測(cè)試結(jié)果：

玩了一天以后，各自回到家里，3y和女朋友約定各自洗澡完之后再聊天

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class Test {

    public static void main(String[] args) {

        final CyclicBarrier CyclicBarrier = new CyclicBarrier(2);
        for (int i = 0; i < 2; i++) {

            new Thread(() -> {

                String name = Thread.currentThread().getName();
                if (name.equals("Thread-0")) {
                    name = "3y";
                } else {
                    name = "女朋友";
                }
                System.out.println(name + "到了體育西");
                try {

                    // 兩個(gè)人都要到體育西才能發(fā)朋友圈
                    CyclicBarrier.await();
                    // 他倆到達(dá)了體育西，看見(jiàn)了對(duì)方發(fā)了一條朋友圈：
                    System.out.println("跟" + name + "去夜上海吃東西~");

                    // 回家
                    CyclicBarrier.await();
                    System.out.println(name + "洗澡");

                    // 洗澡完之后一起聊天
                    CyclicBarrier.await();

                    System.out.println("一起聊天");

                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

測(cè)試結(jié)果：

參考資料：

https://blog.csdn.net/panweiwei1994/article/details/78827000

Semaphores are often used to restrict the number of threads than can access some (physical or logical) resource.

A counting semaphore.  Conceptually, a semaphore maintains a set of permits.  Each {@link #acquire} blocks if necessary until a permit is available, and then takes it.  Each {@link #release} adds a permit,potentially releasing a blocking acquirer.However, no actual permit objects are used; the {@code Semaphore} just
keeps a count of the number available and acts accordingly.

Semaphore(信號(hào)量)實(shí)際上就是可以控制同時(shí)訪問(wèn)的線程個(gè)數(shù)，它維護(hù)了一組"許可證"。

當(dāng)調(diào)用acquire()方法時(shí)，會(huì)消費(fèi)一個(gè)許可證。如果沒(méi)有許可證了，會(huì)阻塞起來(lái)

當(dāng)調(diào)用release()方法時(shí)，會(huì)添加一個(gè)許可證。

這些"許可證"的個(gè)數(shù)其實(shí)就是一個(gè)count變量罷了~

3y女朋友開(kāi)了一間賣酸奶的小店，小店一次只能容納5個(gè)顧客挑選購(gòu)買(mǎi)，超過(guò)5個(gè)就需要排隊(duì)啦~~~

import java.util.concurrent.Semaphore;

public class Test {

    public static void main(String[] args) {

        // 假設(shè)有50個(gè)同時(shí)來(lái)到酸奶店門(mén)口
        int nums = 50;

        // 酸奶店只能容納10個(gè)人同時(shí)挑選酸奶
        Semaphore semaphore = new Semaphore(10);

        for (int i = 0; i < nums; i++) {
            int finalI = i;
            new Thread(() -> {
                try {
                    // 有"號(hào)"的才能進(jìn)酸奶店挑選購(gòu)買(mǎi)
                    semaphore.acquire();

                    System.out.println("顧客" + finalI + "在挑選商品，購(gòu)買(mǎi)...");

                    // 假設(shè)挑選了xx長(zhǎng)時(shí)間，購(gòu)買(mǎi)了
                    Thread.sleep(1000);

                    // 歸還一個(gè)許可，后邊的就可以進(jìn)來(lái)購(gòu)買(mǎi)了
                    System.out.println("顧客" + finalI + "購(gòu)買(mǎi)完畢了...");
                    semaphore.release();



                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();

        }

    }
}

輸出結(jié)果：

反正每次只能5個(gè)客戶同時(shí)進(jìn)酸奶小店購(gòu)買(mǎi)挑選。

參考資料：

https://blog.csdn.net/qq_19431333/article/details/70212663

https://blog.csdn.net/panweiwei1994/article/details/78827248

Java為我們提供了三個(gè)同步工具類：

CountDownLatch(閉鎖)

某個(gè)線程等待其他線程執(zhí)行完畢后，它才執(zhí)行(其他線程等待某個(gè)線程執(zhí)行完畢后，它才執(zhí)行)

CyclicBarrier(柵欄)

一組線程互相等待至某個(gè)狀態(tài)，這組線程再同時(shí)執(zhí)行。

Semaphore(信號(hào)量)

控制一組線程同時(shí)執(zhí)行。

本文簡(jiǎn)單的介紹了一下這三個(gè)同步工具類是干嘛用的，要深入還得看源碼或者借鑒其他的資料。

最后補(bǔ)充一下之前的思維導(dǎo)圖知識(shí)點(diǎn)：

參考資料：

《Java并發(fā)編程實(shí)戰(zhàn)》

http://www.cnblogs.com/dolphin0520/p/3920397.html

https://zhuanlan.zhihu.com/p/27829595

如果文章有錯(cuò)的地方歡迎指正，大家互相交流。習(xí)慣在微信看技術(shù)文章，想要獲取更多的Java資源的同學(xué)，可以關(guān)注微信公眾號(hào):Java3y。為了大家方便，剛新建了一下qq群：742919422，大家也可以去交流交流。謝謝支持了！希望能多介紹給其他有需要的朋友

文章的目錄導(dǎo)航：

https://zhongfucheng.bitcron.com/post/shou-ji/wen-zhang-dao-hang