訊號量 semaphore

訊號量（semaphore）與之前介紹的管道，訊息佇列的等 IPC 的思想不同，訊號量是一個計數器，用來為多個程序或執行緒提供對共享資料的訪問。

訊號量的原理

常用的訊號量是二值訊號量，它控制單個共享資源，初始值為 1，操作如下：
1. 測試該訊號量是否可用
2. 若訊號量為 1，則當前程序使用共享資源，並將訊號量減 1（加鎖）
3. 若訊號量為 0，則當前程序不可以使用共享資源並休眠，必須等待訊號量為 1 時程序才能繼續執行（解鎖）

要注意因為是使用訊號量來保護共享資源，所以訊號量本身的操作不能被打斷，即必須是原子操作，因此由核心來實現訊號量。

檢視訊號量

類似訊息佇列和共享記憶體，我們也可以使用 ipcs 命令來檢視當前系統的訊號量資源：

ipcs -s

------ Semaphore Arrays --------
key        semid      owner      perms      nsems     

目前我的系統中沒有訊號量，在後面例子中會使用這個命令來檢視建立的訊號量。

訊號量的基本操作

Linux 核心提供了一套對訊號量的操作，包括獲取，設定，操作訊號量，下面就來學習具體的 API。

1. 獲取訊號量

使用 semget 來建立或獲取一個與 key 有關的訊號量。

#include <sys/types.h>
 

#include <sys/ipc.h>
#include <sys/sem.h>

/*
 * key：返回的 ID 與 key 有關係
 * nsems：訊號量的值
 * semflg：建立標記
 * return：成功返回訊號量 ID，失敗返回 -1，並設定 erron
 */
int semget(key_t key, int nsems, int semflg);

關於引數的詳細解釋參考 man semget

2. 操作訊號量

使用 semop 可以對一個訊號量加 1 或者減 1：

#include <sys/types.h>
#include <sys/ipc.h>
 

#include <sys/sem.h>

/*
 * semid：訊號量 ID
 * sops：對訊號量的操作
 * nsops：要操作的訊號數量
 * return：成功返回 0，失敗返回 -1，並設定 erron
 */
int semop(int semid, struct sembuf *sops, size_t nsops);

sembuf 表示了對訊號量操作的屬性：

struct sembuf {
    /* 訊號量的個數，除非使用多個訊號量，否則設定為 0 */
    unsigned short sem_num;  

    /* 訊號量的操作，-1 表示 p 操作，1 表示 v 操作 */
    short          sem_op;   

    /* 通常設定為 SEM_UNDO，使得 OS 能夠跟蹤訊號量並在沒有釋放時自動釋放 */
    short          sem_flg;  
};

在進行訊號量的 pv 操作時都是使用這個結構作為引數，詳細解釋參考 man semop。

3. 設定訊號量

使用 semctl 可以設定一個訊號量的初始值：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

/*
 * semid：要設定的訊號量 ID
 * semnum：要設定的訊號量的個數
 * cmd：設定的屬性
 */
int semctl(int semid, int semnum, int cmd, ...);

第 4 個引數的型別是 union semun 結構：

union semun {
    int              val;    /* Value for SETVAL */
    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    unsigned short  *array;  /* Array for GETALL, SETALL */
};

在使用訊號量時必須手動定義這個結構，並且在初始化設定訊號量（SETVAL）時需要使用這個引數，詳細解釋可以參考 man semctl。

例子：使用訊號量進行程序間的同步

下面來學習一個實際使用訊號量來進行程序間通訊的例子，例子實現的功能是：一個程式的兩個例項同步訪問同一段程式碼，先來看看使用的關鍵的函式。

1. 獲取訊號量

在這個例子中將獲取訊號量包裝成一個函式 sem_get：

// 建立或獲取一個訊號量
int sem_get(int sem_key) {
    int sem_id = semget(sem_key, 1, IPC_CREAT | 0666);

    if (sem_id == -1) {
        printf("sem get failed.\n");
        exit(-1);
    } else {
        printf("sem_id = %d\n", sem_id);
        return sem_id;
    }
}

建立或者獲取成功列印訊號量的 id，否則列印錯誤資訊。

2. 初始化訊號量

我們只初始化一個訊號量，並設定 val = 1：

// 初始化訊號量
int set_sem(int sem_id) {
    union semun sem_union;  
    sem_union.val = 1;  
    if(semctl(sem_id, 0, SETVAL, sem_union) == -1) {
        fprintf(stderr, "Failed to set sem\n");  
        return 0;  
    }
    return 1;  
}

主要使用了 union semun 作為第 4 個引數，其中 sem_union.val = 1，並且第 3 個引數必須為 SETVAL。

3. 刪除訊號量

雖然可以指定 OS 自動釋放訊號量，但這個還是要介紹手動釋放的方法：

// 刪除訊號量  
void del_sem(int sem_id) {  
    union semun sem_union;  
    if(semctl(sem_id, 0, IPC_RMID, sem_union) == -1)  
        fprintf(stderr, "Failed to delete sem, sem has been del.\n");  
}

第 3 個引數指定 IPC_RMID 來刪除訊號量。

4. 訊號量的 PV 操作

下面的函式將訊號量的 val 減 1，實現了 PV 操作：

// 減 1，加鎖，P 操作
void sem_down(int sem_id) {
    if (-1 == semop(sem_id, &sem_lock, 1))
        fprintf(stderr, "semaphore lock failed.\n");
}

// 加 1，解鎖，V 操作
void sem_up(int sem_id) {
    if (-1 == semop(sem_id, &sem_unlock, 1))
        fprintf(stderr, "semaphore unlock failed.\n");
}

5. main 函式

最後來看看主程式的邏輯，先建立或獲取訊號量，然後在第一次呼叫時初始化，接著執行 PV 操作，最後在第二次呼叫後刪除訊號量：

int main(int argc, char **argv) {
    int sem_id = sem_get(12);

    // 第一次呼叫多加一個引數，第二次呼叫不加引數，僅在第一次呼叫時建立訊號量
    if (argc > 1 && (!set_sem(sem_id))) {
        printf("set sem failed.\n");
        return -1;
    }

    // P 操作
    sem_down(sem_id);
    printf("sem lock...\n");

    printf("do something...\n");
    sleep(10);

    // V 操作
    sem_up(sem_id);
    printf("sem unlock...\n");

    // 第二次呼叫後刪除訊號量
    if (argc == 1)
        del_sem(sem_id);

    return 0;
}

6. 編譯，執行，測試

先編譯：

gcc sem.c -o sem

在第一個終端執行，我們多加一個無用的引數來表示這是第一次執行：

./sem 1

sem_id = 0
sem lock...
do something...
# 10 s 等待
sem unlock...

我們使用 ipcs -s 檢視一下當前系統中的訊號量：

ipcs -s

------ Semaphore Arrays --------
key        semid      owner      perms      nsems     
0x0000000c 0          orange     666        1         

看到使用者 orange 已經成功建立了一個許可權為 666 ，ID 為 0 的訊號量了，再開啟第二個終端，不加額外的引數再執行一次：

./sem

sem_id = 0
# 第一個終端列印完 sem unlock 後
sem lock...
do something...
# 10 s 等待
sem unlock...

因為是第二次執行，所以最後訊號量會被刪除，我們再來看看 ipcs -s 的結果：

ipcs -s

------ Semaphore Arrays --------
key        semid      owner      perms      nsems     

可以看到訊號量被成功刪除了，這個效果親自執行測試後可以理解的更加深刻，這兩個程序是同步訪問 do something 這部分程式碼的，第二個程序會等待第一個程序 unlock 後再執行，建議你[下載程式碼]({{ site.url }}/file/sem/sem.c)實際執行一下。

拓展：訊號量在 Linux 核心中的實現機制

最後，我們再來簡單分析下訊號量在 Linux 核心中的實現機制，瞭解機制可以幫助我們更好的理解和使用訊號量。其實核心中的共享記憶體，訊息佇列和訊號量的實現機制幾乎是相同的，訊號量也是開闢一片記憶體，然後對連結串列進行操作。

1. glibc 訊號量函式分析

int semget (key, nsems, semflg)
key_t key;
int nsems;
int semflg;
{
    return INLINE_SYSCALL (ipc, 5, IPCOP_semget, key, nsems, semflg, NULL);
}

semget 函式直接使用 INLINE_SYSCALL 進行系統呼叫陷入核心，semop 和 semctl 也是類似，下面來看看核心中的實現。

2. semget 分析

semget 函式為訊號量開闢一片新的記憶體，核心中的呼叫如下，也是使用了 ipc_ops 這個資料結構：

其中回調了 newary 這個函式，它完成訊號量的建立和獲取：

可以看出，整個過程與訊息佇列和共享記憶體幾乎相同。

3. semop 分析

semop 對訊號量進行 PV 操作，其中主要是對 sem_op 進行加 1 或者減 1，大體的過程如下：

4. semctl 分析

semctl 對訊號量進行控制，主要是使用 switch 來判斷當前的命令然後執行相應的操作：

要注意的是，主要的處理邏輯在 semctl_main 這個函式中，其中每個 cmd 都有具體的執行邏輯，有興趣可以詳細分析。

結語

本次就簡單地介紹了訊號量的基本操作和核心的實現機制，對與訊號量的應用並沒有介紹太多，更多的應用方法還需要在實際工作中去實踐。建議你將共享記憶體，訊息佇列和訊號量自己總結對照分析一遍，看看它們的實現機制是不是幾乎相同的，這可以加深你對他們的理解，瞭解些原理總是有些好處的。那我們下次再見，謝謝你的閱讀。

本文原創釋出於微信公眾號「cdeveloper」，程式設計、職場，人生，關注並回復關鍵字「linux」、「機器學習」等獲取免費學習資料。