[[394557]]

大家好，我是 Semaphore，我的中文名字叫“信號量”，我來自 JUC 家族(java.util.concurrent)。

我們家族有很多優(yōu)秀的成員，比如：CountDownLatch：等待其他線程都執(zhí)行完再執(zhí)行某線程，CyclicBarrier：循環(huán)阻塞一組線程，直到某個事件達成，當(dāng)然我也不比他們?nèi)跖? 罒ω罒。

以下是我的個人簡歷，希望各位讀者老爺們給個好評和三連，先在此謝過了~

基本信息

• 姓名：Semaphore
• 中文名：(計數(shù))信號量
• 出生日期：JDK 1.5
• 籍貫：JUC(java.util.concurrent)
• 用途：Java 中的一個同步器，與 CountDownLatch 和 CyclicBarrier 不同，Semaphore 是用來管理許可證的，線程在調(diào)用 acquire() 方法時，如果沒有許可證，那么線程就會阻塞等待，直到有許可證時才能繼續(xù)執(zhí)行。許可證使用 release() 方法來發(fā)布(發(fā)布一個許可證)，調(diào)用 acquire() 方法時，如果有證書會減少許可證并繼續(xù)執(zhí)行后面的代碼，如果沒有證書只能阻塞等待許可證，而 Semaphore 在創(chuàng)建時會聲明許可證的最大數(shù)量。

專業(yè)技能

我的專業(yè)技能就是“管理證書”，使用此技能可以輕松的實現(xiàn)「限流」功能。

什么是限流?

比如五一小長假快到了，到那時會有大量的人去各個景區(qū)游玩，但是每個景區(qū)能容納的人是有限的，比如大西安的大唐芙蓉園，它的日承載量是 6 萬人次，也就是說每天最多能讓 6 萬來這里游玩，但五一的時候會來很多的人，比如突然來了 10 萬人，那這個時候就只能「限流」排隊等待入園了。

也就說，大唐芙蓉園會讓 6 萬人先進去玩，剩余的人在門口等待排隊，當(dāng)有人從里面出來的時候，才允許另一個排隊的人進去。工作人員會把人數(shù)始終控制在 6 萬人以下，這樣做的目的是為了讓游玩的人有一個好的體驗，不至于造成一些意外事故，比如踩踏事件什么的，一定程度上保證了社會的穩(wěn)定，也便于景區(qū)良好的口碑建立和日后的正常運營，而這種排隊限制最大人數(shù)的行為就是「限流」。

再來舉個例子，比如以車輛的限號來說，它也是限流的一種常見場景。這樣做的好處，一方面是可以保護環(huán)境盡可能少一些碳排放，另一方面能有效的緩解上、下班高峰時段的擁堵情況。尤其是在大西安，很難想象如果不限號，那么會堵成什么樣?(PS：讓原本本不富裕的生活更是雪上加霜...)

咱們再從生活中的事例回到程序當(dāng)中，假設(shè)一個程序只能為 10W 人提供服務(wù)，突然有一天因為某個熱點事件，造成了系統(tǒng)短時間內(nèi)的訪問量迅速增加到了 50W，那么導(dǎo)致的直接結(jié)果是系統(tǒng)崩潰，任何人都不能用系統(tǒng)了，顯然只有少人數(shù)能用遠比所有人都不能用更符合我們的預(yù)期，因此這個時候我們要使用「限流」了。

使用Semaphore實現(xiàn)限流

Semaphore 在創(chuàng)建的時候可以設(shè)置證書的數(shù)量，相當(dāng)于設(shè)置了限流的最大值，再通過 release() 方法來發(fā)放證書，通過 acquire() 方法來阻塞并等待證書，這樣就通過控制證書的方式來實現(xiàn)限流功能了。

項目經(jīng)驗

接下來，咱們使用代碼的方式來演示 Semaphore 的使用。我們以停車場的限流為例，假設(shè)整個停車場只有 2 個車位(車位雖少，但足矣說明問題)，但來停車的卻有 5 輛車，顯然車位不夠用了，此時需要保證停車場最多只能有 2 輛車，接下來咱們使用 Semaphore 來實現(xiàn)車輛的限流功能，具體實現(xiàn)代碼如下：

import java.util.Date; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.Semaphore; 
 
/** 
 * Author：磊哥 
 * By：Java中文社群 
 */ 
public class SemaphoreExample { 
    // 創(chuàng)建信號量 
    static Semaphore semaphore = new Semaphore(2); 
 
    public static void main(String[] args) { 
 
        // 創(chuàng)建 5 個固定的線程數(shù) 
        ExecutorService threadPool = Executors.newFixedThreadPool(5); 
 
        // 定義執(zhí)行任務(wù) 
        Runnable runnable = new Runnable() { 
            @Override 
            public void run() { 
                // 拿到當(dāng)前線程的名稱 
                String tname = Thread.currentThread().getName(); 
                System.out.println(String.format("老司機：%s，停車場外排隊，時間：%s", 
                        tname, new Date())); 
                try { 
                    // 執(zhí)行此行，讓所有線程先排隊等待進入停車場 
                    Thread.sleep(100); 
                    // 執(zhí)行阻塞 
                    semaphore.acquire(); 
                    System.out.println(String.format("老司機：%s，已進入停車場，時間：%s", 
                            tname, new Date())); 
                    Thread.sleep(1000); 
                    System.out.println(String.format("老司機：%s，離開停車場，時間：%s", 
                            tname, new Date())); 
                    // 釋放鎖 
                    semaphore.release(); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
            } 
        }; 
 
        // 執(zhí)行任務(wù) 1 
        threadPool.submit(runnable); 
 
        // 執(zhí)行任務(wù) 2 
        threadPool.submit(runnable); 
 
        // 執(zhí)行任務(wù) 3 
        threadPool.submit(runnable); 
 
        // 執(zhí)行任務(wù) 4 
        threadPool.submit(runnable); 
 
        // 執(zhí)行任務(wù) 5 
        threadPool.submit(runnable); 
 
        // 等線程池任務(wù)執(zhí)行完之后關(guān)閉 
        threadPool.shutdown(); 
    } 
} 

以上代碼的執(zhí)行結(jié)果如下：

從上述的結(jié)果我們可以看出，當(dāng)有 5 輛車同時需要進入停車場時，因為停車場的停車位只有 2 個，所以停車場最多只能容納 2 輛車。此時我們通過 Semaphore 的 acquire 方法(阻塞等待)和 release 方法(頒發(fā)一個證書)順利的實現(xiàn)了限流的功能，讓停車場的車輛數(shù)始終控制在 2 輛車以下(等于或小于 2 輛車)。

個人評價

我(Semaphore)實現(xiàn)證書控制手段有兩種，一種公平模式和非公平模式，當(dāng)然為了執(zhí)行的性能考慮，默認情況下我采取的是非公平的方式，具體實現(xiàn)可見源碼：

public Semaphore(int permits) { 
    sync = new NonfairSync(permits); // 非公平模式 
} 

關(guān)于公平模式和非公平模式

所謂的公平模式就是以調(diào)用 acquire() 的先后順序來決定獲取許可證的順序的，公平模式遵循先進先出(FIFO)原則;而非公平模式是搶占式的，也就是有可能一個新的獲取線程恰好在一個許可證釋放時得到了這個許可證，而前面還有等待的線程。

顯然使用非公平的模式性能更高，因為它會把許可證發(fā)放給剛好準備好的線程，而不用再根據(jù)先后順序去“叫號”了。

使用公平模式

當(dāng)然，你可以手動選擇使用公平模式來運行 Semaphore，Semaphore 提供了兩個構(gòu)造函數(shù)，源碼如下：

public Semaphore(int permits) { 
    sync = new NonfairSync(permits); 
} 
public Semaphore(int permits, boolean fair) { 
    sync = fair ? new FairSync(permits) : new NonfairSync(permits); 
} 

如果想用公平模式就可以使用第二個構(gòu)造函數(shù) Semaphore(int permits, boolean fair)，將 fair 值設(shè)置為 true 就是公平模式來獲取證書了。

其他補充

我還提供了一些其他方法，用于實現(xiàn)更多的功能，詳情如下：

• int availablePermits()：返回此信號量中當(dāng)前可用的許可證數(shù)。
• int getQueueLength()：返回正在等待獲取許可證的線程數(shù)。
• boolean hasQueuedThreads()：是否有線程正在等待獲取許可證。
• boolean isFair()：查詢 Semaphore 使用的是公平模式還是非公平模式，如果此信號量使用的是公平模式則返回 true。
• void release(int permits)：釋放給定數(shù)量的許可證，將其返回到信號量。
• tryAcquire()：從這個信號量獲得許可證，只有在調(diào)用時可以使用該許可證。
• tryAcquire(int permits)：從這個信號量獲取給定數(shù)量的許可證，只有在調(diào)用時全部可用。
• tryAcquire(int permits, long timeout, TimeUnit unit)：從該信號量獲取給定數(shù)量的許可證，如果在給定的等待時間內(nèi)全部可用，并且當(dāng)前線程尚未 interrupted。
• tryAcquire(long timeout, TimeUnit unit)：如果在給定的等待時間內(nèi)可用，并且當(dāng)前線程尚未 到達 interrupted，則從該信號量獲取許可。
• void reducePermits(int reduction) ：減少可用的許可證數(shù)量 reduction 個，它是 protected 方法。
• Collection getQueuedThreads() ：返回所有等待獲取許可證的線程集合，它是 protected 方法。

總結(jié)

Semaphore 信號量是用來管理一組證書的，默認情況下它采取的是非公平的方式來管理證書，這樣做的目的是為了實現(xiàn)高性能。Semaphore 中包含了兩個重要的方法：release() 方法發(fā)布一個許可證書;acquire() 方法阻塞并等待一個證書。當(dāng)線程調(diào)用了 acquire() 方法只有擁有了證書才能繼續(xù)執(zhí)行，因此可以使用 Semaphore 來實現(xiàn)限流。