本章主要對Semaphore進行學習。

1.Semaphore簡介

Semaphore，是JDK1.5的java.util.concurrent併發包中提供的一個併發工具類。

所謂Semaphore即 訊號量 的意思。

這個叫法並不能很好地表示它的作用，更形象的說法應該是許可證管理器。

其作用在JDK註釋中是這樣描述的：

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是一個計數訊號量。
• 從概念上將，Semaphore包含一組許可證。
• 如果有需要的話，每個acquire()方法都會阻塞，直到獲取一個可用的許可證。
• 每個release()方法都會釋放持有許可證的執行緒，並且歸還Semaphore一個可用的許可證。
• 然而，實際上並沒有真實的許可證物件供執行緒使用，Semaphore只是對可用的數量進行管理維護。

2.Semaphore方法說明

Semaphore的方法如下：

——Semaphore(permits)

初始化許可證數量的建構函式

——Semaphore(permits,fair)

初始化許可證數量

——isFair()

是否公平模式FIFO

——availablePermits()

獲取當前可用的許可證數量

——acquire()

當前執行緒嘗試去阻塞的獲取1個許可證。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

• 當前執行緒獲取了1個可用的許可證，則會停止等待，繼續執行。
• 當前執行緒被中斷，則會丟擲InterruptedException異常，並停止等待，繼續執行。

——acquire(permits)

當前執行緒嘗試去阻塞的獲取permits個許可證。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

• 當前執行緒獲取了n個可用的許可證，則會停止等待，繼續執行。
• 當前執行緒被中斷，則會丟擲InterruptedException異常，並停止等待，繼續執行。

——acquierUninterruptibly()

當前執行緒嘗試去阻塞的獲取1個許可證(不可中斷的)。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

• 當前執行緒獲取了1個可用的許可證，則會停止等待，繼續執行。

——acquireUninterruptibly(permits)

當前執行緒嘗試去阻塞的獲取permits個許可證。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

• 當前執行緒獲取了n個可用的許可證，則會停止等待，繼續執行。

——tryAcquire()

當前執行緒嘗試去獲取1個許可證。

此過程是非阻塞的，它只是在方法呼叫時進行一次嘗試。

如果當前執行緒獲取了1個可用的許可證，則會停止等待，繼續執行，並返回true。

如果當前執行緒沒有獲得這個許可證，也會停止等待，繼續執行，並返回false。

——tryAcquire(permits)

當前執行緒嘗試去獲取permits個許可證。

此過程是非阻塞的，它只是在方法呼叫時進行一次嘗試。

如果當前執行緒獲取了permits個可用的許可證，則會停止等待，繼續執行，並返回true。

如果當前執行緒沒有獲得permits個許可證，也會停止等待，繼續執行，並返回false。

——tryAcquire(timeout,TimeUnit)

當前執行緒在限定時間內，阻塞的嘗試去獲取1個許可證。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

• 當前執行緒獲取了可用的許可證，則會停止等待，繼續執行，並返回true。
• 當前執行緒等待時間timeout超時，則會停止等待，繼續執行，並返回false。
• 當前執行緒在timeout時間內被中斷，則會丟擲InterruptedException一次，並停止等待，繼續執行。

——tryAcquire(permits,timeout,TimeUnit)

當前執行緒在限定時間內，阻塞的嘗試去獲取permits個許可證。

此過程是阻塞的，它會一直等待許可證，直到發生以下任意一件事：

• 當前執行緒獲取了可用的permits個許可證，則會停止等待，繼續執行，並返回true。
• 當前執行緒等待時間timeout超時，則會停止等待，繼續執行，並返回false。
• 當前執行緒在timeout時間內被中斷，則會丟擲InterruptedException一次，並停止等待，繼續執行。

——release()

當前執行緒釋放1個可用的許可證。

——release(permits)

當前執行緒釋放permits個可用的許可證。

——drainPermits()

當前執行緒獲得剩餘的所有可用許可證。

——hasQueuedThreads()

判斷當前Semaphore物件上是否存在正在等待許可證的執行緒。

——getQueueLength()

獲取當前Semaphore物件上是正在等待許可證的執行緒數量。

3.Semaphore方法練習

練習目的：熟悉Semaphore的各類方法的用法。

例項程式碼：

//new Semaphore(permits)：初始化許可證數量的建構函式
Semaphore semaphore = new Semaphore(5);

//new Semaphore(permits,fair):初始化許可證數量和是否公平模式的建構函式
semaphore = new Semaphore(5, true);

//isFair()：是否公平模式FIFO
System.out.println("是否公平FIFO：" + semaphore.isFair());

//availablePermits():獲取當前可用的許可證數量
System.out.println("獲取當前可用的許可證數量：開始---" + semaphore.availablePermits());

//acquire():獲取1個許可證
//---此執行緒會一直阻塞，直到獲取這個許可證，或者被中斷(丟擲InterruptedException異常)。
semaphore.acquire();
System.out.println("獲取當前可用的許可證數量：acquire 1 個---" + semaphore.availablePermits());

//release()：釋放1個許可證
semaphore.release();
System.out.println("獲取當前可用的許可證數量：release 1 個---" + semaphore.availablePermits());

//acquire(permits):獲取n個許可證
//---此執行緒會一直阻塞，直到獲取全部n個許可證,或者被中斷(丟擲InterruptedException異常)。
semaphore.acquire(2);
System.out.println("獲取當前可用的許可證數量：acquire 2 個---" + semaphore.availablePermits());

//release(permits):釋放n個許可證
semaphore.release(2);
System.out.println("獲取當前可用的許可證數量：release 1 個---" + semaphore.availablePermits());

//hasQueuedThreads():是否有正在等待許可證的執行緒
System.out.println("是否有正在等待許可證的執行緒：" + semaphore.hasQueuedThreads());

//getQueueLength():正在等待許可證的佇列長度(執行緒數量)
System.out.println("正在等待許可證的佇列長度(執行緒數量)：" + semaphore.getQueueLength());

Thread.sleep(10);
System.out.println();
//定義final的訊號量
Semaphore finalSemaphore = semaphore;
new Thread(() -> {
    //drainPermits():獲取剩餘的所有的許可證
    int permits = finalSemaphore.drainPermits();
    System.out.println(Thread.currentThread().getName() + "獲取了剩餘的全部" + permits + "個許可證.");
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //釋放所有的許可證
    finalSemaphore.release(permits);
    System.out.println(Thread.currentThread().getName() + "釋放了" + permits + "個許可證.");
}).start();

Thread.sleep(10);
new Thread(() -> {
    try {
        //有一個執行緒正在等待獲取1個許可證
        finalSemaphore.acquire();
        System.out.println(Thread.currentThread().getName() + "獲取了1個許可證.");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //釋放1個許可證
    finalSemaphore.release();
    System.out.println(Thread.currentThread().getName() + "釋放了1個許可證.");

}).start();
Thread.sleep(10);
System.out.println();
System.out.println("獲取當前可用的許可證數量：drain 剩餘的---" + finalSemaphore.availablePermits());
System.out.println("是否有正在等待許可證的執行緒：" + finalSemaphore.hasQueuedThreads());
System.out.println("正在等待許可證的佇列長度(執行緒數量)：" + finalSemaphore.getQueueLength());
System.out.println();

Thread.sleep(10);
new Thread(() -> {
    try {
        //有一個執行緒正在等待獲取2個許可證
        finalSemaphore.acquire(2);
        System.out.println(Thread.currentThread().getName() + "獲取了2個許可證.");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //釋放兩個許可證
    finalSemaphore.release(2);
    System.out.println(Thread.currentThread().getName() + "釋放了2個許可證.");
}).start();
Thread.sleep(10);
System.out.println();
System.out.println("獲取當前可用的許可證數量：drain 剩餘的---" + finalSemaphore.availablePermits());
System.out.println("是否有正在等待許可證的執行緒：" + finalSemaphore.hasQueuedThreads());
System.out.println("正在等待許可證的佇列長度(執行緒數量)：" + finalSemaphore.getQueueLength());
System.out.println();

Thread.sleep(5000);
System.out.println();
System.out.println("獲取當前可用的許可證數量：---" + finalSemaphore.availablePermits());
System.out.println("是否有正在等待許可證的執行緒：" + finalSemaphore.hasQueuedThreads());
System.out.println("正在等待許可證的佇列長度(執行緒數量)：" + finalSemaphore.getQueueLength());

執行結果：

是否公平FIFO：true
獲取當前可用的許可證數量：開始---5
獲取當前可用的許可證數量：acquire 1 個---4
獲取當前可用的許可證數量：release 1 個---5
獲取當前可用的許可證數量：acquire 2 個---3
獲取當前可用的許可證數量：release 1 個---5
是否有正在等待許可證的執行緒：false
正在等待許可證的佇列長度(執行緒數量)：0

Thread-0獲取了剩餘的全部5個許可證.

獲取當前可用的許可證數量：drain 剩餘的---0
是否有正在等待許可證的執行緒：true
正在等待許可證的佇列長度(執行緒數量)：1


獲取當前可用的許可證數量：drain 剩餘的---0
是否有正在等待許可證的執行緒：true
正在等待許可證的佇列長度(執行緒數量)：2

Thread-0釋放了5個許可證.
Thread-2獲取了2個許可證.
Thread-1獲取了1個許可證.
Thread-1釋放了1個許可證.
Thread-2釋放了2個許可證.

獲取當前可用的許可證數量：---5
是否有正在等待許可證的執行緒：false
正在等待許可證的佇列長度(執行緒數量)：0

4.Semaphore應用場景-例項

Semaphore經常用於限制獲取某種資源的執行緒數量。

場景說明：

• 模擬學校食堂的視窗打飯過程
• 學校食堂有2個打飯視窗
• 學校中午有20個學生 按次序 排隊打飯
• 每個人打飯時耗費時間不一樣
• 有的學生耐心很好，他們會一直等待直到打到飯
• 有的學生耐心不好，他們等待時間超過了心裡預期，就不再排隊，而是回宿舍吃泡麵了
• 有的學生耐心很好，但是突然接到通知，說是全班聚餐，所以也不用再排隊，而是去吃大餐了

重點分析

• 食堂有2個打飯視窗：需要定義一個permits=2的Semaphore物件。
• 學生 按次序 排隊打飯：此Semaphore物件是公平的。
• 有20個學生：定義20個學生執行緒。
• 打到飯的學生：呼叫了acquireUninterruptibly()方法，無法被中斷
• 吃泡麵的學生：呼叫了tryAcquire(timeout,TimeUnit)方法，並且等待時間超時了
• 吃大餐的學生：呼叫了acquire()方法，並且被中斷了

例項程式碼：

定義2個視窗的食堂

/**
 * 打飯視窗
 * 2：   2個打飯視窗
 * true：公平佇列-FIFO
 */
static Semaphore semaphore = new Semaphore(2, true);

定義打飯學生

/**
 * <p>打飯學生</p>
 *
 * @author hanchao 2018/3/31 19:45
 **/
static class Student implements Runnable {
    private static final Logger LOGGER = Logger.getLogger(Student.class);
    //學生姓名
    private String name;
    //打飯許可
    private Semaphore semaphore;
    /**
     * 打飯方式
     * 0    一直等待直到打到飯
     * 1    等了一會不耐煩了，回宿舍吃泡麵了
     * 2    打飯中途被其他同學叫走了，不再等待
     */
    private int type;

    public Student(String name, Semaphore semaphore, int type) {
        this.name = name;
        this.semaphore = semaphore;
        this.type = type;
    }

    /**
     * <p>打飯</p>
     *
     * @author hanchao 2018/3/31 19:49
     **/
    @Override
    public void run() {
        //根據打飯情形分別進行不同的處理
        switch (type) {
            //打飯時間
            //這個學生很有耐心，它會一直排隊直到打到飯
            case 0:
                //排隊
                semaphore.acquireUninterruptibly();
                //進行打飯
                try {
                    Thread.sleep(RandomUtils.nextLong(1000, 3000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //將打飯機會讓後後面的同學
                semaphore.release();
                //打到了飯
                LOGGER.info(name + " 終於打到了飯.");
                break;

            //這個學生沒有耐心，等了1000毫秒沒打到飯，就回宿舍泡麵了
            case 1:
                //排隊
                try {
                    //如果等待超時，則不再等待，回宿舍吃泡麵
                    if (semaphore.tryAcquire(RandomUtils.nextInt(6000, 16000), TimeUnit.MILLISECONDS)) {
                        //進行打飯
                        try {
                            Thread.sleep(RandomUtils.nextLong(1000, 3000));
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        //將打飯機會讓後後面的同學
                        semaphore.release();
                        //打到了飯
                        LOGGER.info(name + " 終於打到了飯.");
                    } else {
                        //回宿舍吃泡麵
                        LOGGER.info(name + " 回宿舍吃泡麵.");
                    }
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                }
                break;

            //這個學生也很有耐心，但是他們班突然宣佈聚餐，它只能放棄打飯了
            case 2:
                //排隊
                try {
                    semaphore.acquire();
                    //進行打飯
                    try {
                        Thread.sleep(RandomUtils.nextLong(1000, 3000));
                    } catch (InterruptedException e) {
                        //e.printStackTrace();
                    }
                    //將打飯機會讓後後面的同學
                    semaphore.release();
                    //打到了飯
                    LOGGER.info(name + " 終於打到了飯.");
                } catch (InterruptedException e) {
                    //e.printStackTrace();
                    //被叫去聚餐，不再打飯
                    LOGGER.info(name + " 全部聚餐，不再打飯.");
                }
                break;
            default:
                break;
        }
    }
}

編寫食堂打飯過程：

/**
* <p>食堂打飯</p>
 *
 * @author hanchao 2018/3/31 21:13
 **/
public static void main(String[] args) throws InterruptedException {
    //101班的學生
    Thread[] students101 = new Thread[5];
    for (int i = 0; i < 20; i++) {
        //前10個同學都在耐心的等待打飯
        if (i < 10) {
            new Thread(new Student("打飯學生" + i, SemaphoreDemo.semaphore, 0)).start();
        } else if (i >= 10 && i < 15) {//這5個學生沒有耐心打飯，只會等1000毫秒
            new Thread(new Student("泡麵學生" + i, SemaphoreDemo.semaphore, 1)).start();
        } else {//這5個學生沒有耐心打飯
            students101[i - 15] = new Thread(new Student("聚餐學生" + i, SemaphoreDemo.semaphore, 2));
            students101[i - 15].start();
        }
    }
    //
    Thread.sleep(5000);
    for (int i = 0; i < 5; i++) {
        students101[i].interrupt();
    }
}

執行結果：

2018-04-01 21:13:16 INFO - 打飯學生1 終於打到了飯.
2018-04-01 21:13:16 INFO - 打飯學生0 終於打到了飯.
2018-04-01 21:13:18 INFO - 打飯學生2 終於打到了飯.
2018-04-01 21:13:18 INFO - 打飯學生3 終於打到了飯.
2018-04-01 21:13:19 INFO - 聚餐學生15 全部聚餐，不再打飯.
2018-04-01 21:13:19 INFO - 聚餐學生19 全部聚餐，不再打飯.
2018-04-01 21:13:19 INFO - 聚餐學生17 全部聚餐，不再打飯.
2018-04-01 21:13:19 INFO - 聚餐學生18 全部聚餐，不再打飯.
2018-04-01 21:13:19 INFO - 聚餐學生16 全部聚餐，不再打飯.
2018-04-01 21:13:19 INFO - 打飯學生4 終於打到了飯.
2018-04-01 21:13:20 INFO - 打飯學生5 終於打到了飯.
2018-04-01 21:13:21 INFO - 泡麵學生13 回宿舍吃泡麵.
2018-04-01 21:13:21 INFO - 泡麵學生11 回宿舍吃泡麵.
2018-04-01 21:13:21 INFO - 打飯學生7 終於打到了飯.
2018-04-01 21:13:22 INFO - 打飯學生6 終於打到了飯.
2018-04-01 21:13:23 INFO - 打飯學生9 終於打到了飯.
2018-04-01 21:13:24 INFO - 打飯學生8 終於打到了飯.
2018-04-01 21:13:24 INFO - 泡麵學生10 終於打到了飯.
2018-04-01 21:13:26 INFO - 泡麵學生14 終於打到了飯.
2018-04-01 21:13:26 INFO - 泡麵學生12 終於打到了飯.