併發工具類——Semaphore

程式設計師自由之路發表於2020-05-11

本部落格系列是學習併發程式設計過程中的記錄總結。由於文章比較多，寫的時間也比較散，所以我整理了個目錄貼（傳送門），方便查閱。

併發程式設計系列部落格傳送門

Semaphore（[' seməf :(r)]）的主要作用是控制執行緒併發的數量。我們可以將Semaphore想象成景區的一個門衛，這個門衛負責發放景區入園的許可證。

景區為了遊客的入園觀賞體驗，決定最多允許200個有個同時在園內觀賞。那麼這個門衛在每天開園的時候手中都會有200張許可證，每當一個遊客要入園的時候門衛會給遊客發放一張許可證，當門衛手中的許可證發完之後再有遊客需要入園的話就必須等待。

當遊客觀賞完畢之後，出園的時候需要將許可證交還到門衛手上。門衛將這些交還的許可證再發等待的遊客，這些遊客就能順利入園了。

Semaphore的API簡介

Semaphore的API使用起來也比較簡單，常見的API簡介如下：

  • Semaphore(int permits):構造方法，建立具有給定許可數的計數訊號量並設定為非公平訊號量。
  • Semaphore(int permits,boolean fair):構造方法，當fair等於true時，建立具有給定許可數的計數訊號量並設定為公平訊號量。
  • void acquire():從此訊號量獲取一個許可前執行緒將一直阻塞。相當於一輛車佔了一個車位。
  • void acquire(int n):從此訊號量獲取給定數目許可，在提供這些許可前一直將執行緒阻塞。比如n=2，就相當於一輛車佔了兩個車位。
  • boolean tryAcquire(int permits, long timeout, TimeUnit unit)：嘗試獲取，在給定的時間內沒獲取到資源超時
  • void release():釋放一個許可，將其返回給訊號量。就如同車開走返回一個車位。
  • void release(int n):釋放n個許可。
  • int availablePermits()：當前可用的許可數。

Semaphore的常見用法

下面給出一個Oracle官方文件中的列子程式碼：

class Pool {
    // 可同時訪問資源的最大執行緒數
    private static final int MAX_AVAILABLE = 100; 
    private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);
    // 共享資源
    protected Object[] items = new Object[MAX_AVAILABLE];   
    protected boolean[] used = new boolean[MAX_AVAILABLE];
    public Object getItem() throws InterruptedException {
        available.acquire();
        return getNextAvailableItem();
    }
    public void putItem(Object x) {
        if (markAsUnused(x))
            available.release();
    }
    private synchronized Object getNextAvailableItem() {
        for (int i = 0; i < MAX_AVAILABLE; ++i) {
            if (!used[i]) {
                used[i] = true;
                return items[i];
            }
        }
        return null;
    }
    private synchronized boolean markAsUnused(Object item) {
        for (int i = 0; i < MAX_AVAILABLE; ++i) {
            if (item == items[i]) {
                if (used[i]) {
                    used[i] = false;
                    return true;
                } else
                    return false;
            }
        }
        return false;
    }
}

items陣列可以看成是我們的共享資源，當有執行緒嘗試使用共享資源時，我們要求執行緒先獲得“許可”（呼叫Semaphore 的acquire方法），這樣執行緒就擁有了許可權，否則就需要等待。當使用完資源後，執行緒需要呼叫Semaphore 的release方法釋放許可。

Semaphore並不能替代synchronized

有些書中提到：如果將Semaphore的許可證數量設定成1的話，就能實現synchronized的功能。其實這種說法是不對的。

下面使用Semaphore來控制對一個賬戶進行併發存錢和取錢的動作，如果Semaphore能實現synchronized的功能的話，賬戶最後的餘額應該還是10000，但程式碼執行後的結果並不是這樣。大家可以執行下面的程式碼看下結果。

public static final int THREAD_COUNT = 100;

    public static void main(String[] args) {
        BankAccount myAccount = new BankAccount("accountOfMG", 10000.00);
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        int var = new Random().nextInt(100);
                        Thread.sleep(var);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    double deposit = myAccount.deposit(1000.00);
                    System.out.println(Thread.currentThread().getName() + " balance1:" + deposit);
                }
            }).start();
        }
        for (int i = 0; i < THREAD_COUNT; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        int var = new Random().nextInt(100);
                        Thread.sleep(var);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    double deposit = myAccount.withdraw(1000.00);
                    System.out.println(Thread.currentThread().getName() + " balance2:" + deposit);

                }
            }).start();
        }
    }

    private static class BankAccount {

        Semaphore semaphore = new Semaphore(1);

        String accountName;
        double balance;

        public BankAccount(String accountName, double balance) {
                this.accountName = accountName;
                this.balance = balance;
        }

        public double deposit(double amount) {
            try {
                semaphore.acquire();
                balance = balance + amount;
                return balance;
            } catch (Exception e) {
                throw new RuntimeException("中斷...");
            } finally {
                semaphore.release();
            }
        }

        public double withdraw(double amount) {
            try {
                semaphore.acquire();
            balance = balance - amount;
            return balance;
            } catch (Exception e) {
                throw new RuntimeException("中斷...");
            } finally {
                semaphore.release();
            }
        }

    }

這裡Semaphore並不能實現synchronized的功能的原因是：Semaphore並不能保證共享變數的可見性。

實現原理

Semaphore底層原理還是基於AQS機制的。這邊就不具體分析了，感興趣的可以參考我前面關於AQS的文章。

簡單總結

  • Semaphore只能用來做執行緒同步——控制執行緒的執行順序，但是並不能保證執行緒安全；
  • Semaphore主要用來控制執行緒的併發數量，通常用在限流元件中。
  • Semaphore基於AQS機制實現。

相關文章