文章目錄

• 1 簡介
• 2 Posix信號量
• • 2.1 有名信號量
  • 2.2 無名信號量
  • 2.3 例程變種
  • • 2.3.1 多生產者單消費者
    • 2.3.2 多生產者多消費者
    • 2.3.3 多緩沖讀取
• 3 System V信號量
• • 3.1 System V信號量
  • 3.2 示例

1 簡介

??信號量是用于提供不用進程或者不同線程之間的同步手段的原語，分為：

• Posix 有名信號量：可用于進程或者線程間的同步；
• Posix基于內存的信號量（無名信號量）：存放于共享內存中，可用于進程或者線程的同步；
• System V信號量：在內核中維護，可用于進程或線程間的同步。

??另外信號量同時根據取值不同可分為：

• 二值信號量：取值只能是0或者1，可以實現類似互斥鎖的跨進程的鎖機制。
• 計數信號量：取值大于1。

??計數信號量具備兩種操作動作，稱為V（signal()）與P（wait()）（即部分參考書常稱的“PV操作”）。V操作會增加信號標S的數值，P操作會減少它。

• P操作，檢測信標值S：
  • 如果S <= 0，則阻塞直到S > 0，并將信標值S=S-1；
  • 如果S > 0，則直接S=S-1；
• V操作：直接增加信標值S=S+1。

??PV操作某種程度上等價于如下代碼只不過是原子的.

int p(int seq) {while(seq <= 0) ;return --seq; }int v(int seq) {return ++seq; }

??互斥鎖，信號量和條件變量的區別：

互斥鎖強調的是資源的訪問互斥，信號量強調進程或者線程之間的同步，條件變量常與互斥鎖同時使用，達到線程同步的目的：條件變量通過允許線程阻塞和等待另一個線程發送信號的方法彌補了互斥鎖的不足；

互斥鎖總是必須由給其上鎖的線程解鎖，信號量的掛出確不必由執行過它的等待操作的同一線程執行；

互斥鎖要么被鎖住，要么被解鎖（二值狀態，類似于二值信號量）；

既然信號量有一個與之關聯的狀態（它的數值），那么信號量的掛出操作總是被記住。然而當向一個條件變量發送信號時，如果沒有線程等待在該條件變量上，那么信號將丟失。

2 Posix信號量

2.1 有名信號量

#include <semaphore.h> sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value); int sem_close(sem_t *sem); int sem_unlink(const char *name); int sem_post(sem_t *sem); int sem_wait(sem_t *sem); int sem_trywait(sem_t *sem); int sem_getvalue(sem_t *sem, int *sval);

• sem_open：創建或者打開一個信號量；
  • name：信號量在文件系統上的文件名；
  • oflag：可以為0,O_CREAT或者O_CREAT|O_EXCL；
  • mode：信號量的權限位；
  • value：信號量的初值不能大于SEM_VALUE_MAX；
  • 返回自sem_t是一個該信號量的標識符的指針；
• sem_close：關閉一個信號量，但是并不刪除信號量，另外進程終止系統會自動關閉當前進程打開的信號量；
  • sem：信號量的指針，通過sem_open獲得；
• sem_unlink：刪除信號量，需要注意的是信號量同樣維護了一個引用計數，只有當引用計數為0時才會顯示的刪除；
  • name：信號量的在文件系統上的唯一標示；
• sem_post：V操作，將信號量的值+1，并喚醒等待信號量的任意線程；
  • sem：信號量的指針，通過sem_open獲得；
• sem_wait：P操作，如果當前信號量小于等于0則阻塞，將信號量的值-1，否則直接將信號量-1；
  • sem：信號量的指針，通過sem_open獲得；
• sem_trywait：非阻塞的sem_wait；
  • sem：信號量的指針，通過sem_open獲得；
• sem_getvalue：獲取當前信號量的值，如果當前信號量上鎖則返回0或者負值，其絕對值為信號量的值；
  • sem：信號量的指針，通過sem_open獲得；
  • sval：信號量的值；
• 以上的函數除了sem_open失敗返回SEM_FAILED，均是成功返回0，失敗返回-1并且設置errno。

??簡單的消費者-生產者問題：

#define BUFF_SIZE 5 typedef struct named_share {char buff[BUFF_SIZE];sem_t *lock;sem_t *nempty;sem_t *nstored;int items; }named_share;void* named_produce(void *arg) {named_share *ptr = arg;for(int i = 0;i < ptr->items;i++){lsem_wait(ptr->nempty);lsem_wait(ptr->lock); //鎖//生產物品ptr->buff[i % BUFF_SIZE] = rand() % 1000;printf("produce %04d into %2d\n", ptr->buff[i % BUFF_SIZE], i % BUFF_SIZE);sleep(rand()%2);lsem_post(ptr->lock); //解鎖lsem_post(ptr->nstored);}return NULL; }void* named_consume(void *arg) {named_share *ptr = arg;for(int i = 0;i < ptr->items;i++){lsem_wait(ptr->nstored);lsem_wait(ptr->lock); //鎖//生產物品printf("consume %04d at %2d\n", ptr->buff[i % BUFF_SIZE], i % BUFF_SIZE);ptr->buff[i % BUFF_SIZE] = -1;sleep(rand()%2);lsem_post(ptr->lock); //解鎖lsem_post(ptr->nempty);//iterator}return NULL; }void named_sem_test() {char *nempty_name = "nempty";char *nstored_name = "nstored";char *lock_name = "lock";int items = 10;int flag = O_CREAT | O_EXCL;named_share arg;srand(time(NULL));arg.items = items;memset(arg.buff, -1, sizeof(int) * BUFF_SIZE);arg.nempty = lsem_open(lpx_ipc_name(nempty_name), flag, FILE_MODE, BUFF_SIZE);arg.nstored = lsem_open(lpx_ipc_name(nstored_name), flag, FILE_MODE, 0);arg.lock = lsem_open(lpx_ipc_name(lock_name), flag, FILE_MODE, 1);pthread_t pid1, pid2;int val = 0;lsem_getvalue(arg.nstored, &val);lsem_getvalue(arg.nempty, &val);pthread_setconcurrency(2); lpthread_create(&pid1, NULL, named_produce, &arg);lpthread_create(&pid2, NULL, named_consume, &arg);lpthread_join(pid1, NULL);lpthread_join(pid2, NULL);lsem_unlink(lpx_ipc_name(nempty_name));lsem_unlink(lpx_ipc_name(nstored_name));lsem_unlink(lpx_ipc_name(lock_name)); }

??結果：

? build git:(master) ? ./main produce 0038 into 0 produce 0022 into 1 produce 0049 into 2 produce 0060 into 3 produce 0090 into 4 consume 0038 at 0 consume 0022 at 1 consume 0049 at 2 consume 0060 at 3 consume 0090 at 4 produce 0031 into 0 produce -056 into 1 produce -103 into 2 produce -047 into 3 produce -100 into 4 consume 0031 at 0 consume -056 at 1 consume -103 at 2 consume -047 at 3 consume -100 at 4

2.2 無名信號量

int sem_init(sem_t *sem, int pshared, unsigned int value); int sem_destroy(sem_t *sem);

• ```sem_init``：初始化一個無名信號量；
  • sem：信號量的指針；
  • pshared：標志是否共享：
    • pshared==0：該信號量只能在同一進程不同線程之間共享，當進程終止則消失；
    • pshared!=0：該信號量駐留與共享內存區，可以在不同進程之間進行共享；
  • value：信號量的初值；
  • 返回值出錯返回-1，成功并不返回0；
• sem_destroy：銷毀信號量。成功返回0，失敗返回-1。

??上面的程序的簡易修改：

void unnamed_sem_test() {int items = 10;named_share arg;srand(time(NULL));arg.items = items;memset(arg.buff, -1, sizeof(int) * BUFF_SIZE);arg.lock = (sem_t*)malloc(sizeof(sem_t));arg.nempty = (sem_t*)malloc(sizeof(sem_t));arg.nstored = (sem_t*)malloc(sizeof(sem_t));lsem_init(arg.lock, 0, 1);lsem_init(arg.nempty, 0, BUFF_SIZE);lsem_init(arg.nstored, 0, 0);pthread_t pid1, pid2;pthread_setconcurrency(2); lpthread_create(&pid1, NULL, named_produce, &arg);lpthread_create(&pid2, NULL, named_consume, &arg);lpthread_join(pid1, NULL);lpthread_join(pid2, NULL);lsem_destroy(arg.lock);lsem_destroy(arg.nempty);lsem_destroy(arg.nstored);SAFE_RELEASE(arg.lock);SAFE_RELEASE(arg.nempty);SAFE_RELEASE(arg.nstored); } ? build git:(master) ? ./main produce -120 into 0 produce -098 into 1 produce 0123 into 2 produce -058 into 3 produce 0028 into 4 consume -120 at 0 consume -098 at 1 consume 0123 at 2 consume -058 at 3 consume 0028 at 4 produce 0110 into 0 produce 0034 into 1 produce -068 into 2 produce -115 into 3 produce 0004 into 4 consume 0110 at 0 consume 0034 at 1 consume -068 at 2 consume -115 at 3 consume 0004 at 4

2.3 例程變種

2.3.1 多生產者單消費者

??多生產者單消費者需要關注的是不同生產者之間的進度同步。

typedef struct multp_singc_share {int i;sem_t nempty;sem_t nstored;sem_t lock;int items;char buff[BUFF_SIZE]; }multp_singc_share;void* multp_singc_produce(void *arg) {multp_singc_share *ptr = arg;for(;;){lsem_wait(&(ptr->nempty));lsem_wait(&(ptr->lock));if(ptr->i >= ptr->items){lsem_post(&(ptr->lock));lsem_post(&(ptr->nempty));return NULL;}ptr->buff[ptr->i % BUFF_SIZE] = rand() % 100;printf("produce %d at %d\n", ptr->buff[ptr->i * BUFF_SIZE], ptr->i % BUFF_SIZE);ptr->i++;lsem_post(&ptr->lock);lsem_post(&ptr->nstored);} }void* multp_singc_consume(void *arg) {multp_singc_share *ptr = arg;for(int i = 0;i < ptr->items;i ++){lsem_wait(&(ptr->nstored));lsem_wait(&(ptr->lock));printf("consume %d at %d\n", ptr->buff[i % BUFF_SIZE], i % BUFF_SIZE);lsem_post(&(ptr->lock));lsem_post(&(ptr->nempty));} }void multp_singc_test() {multp_singc_share arg;pthread_t pro_th[THREAD_SIZE], con_th;arg.items = 10;arg.i = 0;memset(arg.buff, 0, BUFF_SIZE * sizeof(int));lsem_init(&(arg.lock), 0, 1);lsem_init(&(arg.nempty), 0, BUFF_SIZE);lsem_init(&(arg.nstored), 0, 0);pthread_setconcurrency(THREAD_SIZE + 1); for(int i = 0;i < THREAD_SIZE;i ++){lpthread_create(&pro_th[i], NULL, multp_singc_produce, &arg);}lpthread_create(&con_th, NULL, multp_singc_consume, &arg);for(int i = 0;i < THREAD_SIZE;i ++){lpthread_join(pro_th[i], NULL);}lpthread_join(con_th, NULL);lsem_destroy(&(arg.lock));lsem_destroy(&(arg.nempty));lsem_destroy(&(arg.nstored)); } ? build git:(master) ? ./main produce 83 at 0 produce 0 at 1 produce 0 at 2 produce 0 at 3 consume 83 at 0 consume 86 at 1 produce 48 at 4 produce 127 at 0 produce 64 at 1 consume 77 at 2 consume 15 at 3 produce 0 at 2 consume 93 at 4 consume 35 at 0 produce -4 at 3 produce 31 at 4 consume 86 at 1 consume 92 at 2 consume 49 at 3 consume 21 at 4

2.3.2 多生產者多消費者

??多個生產者和消費者互相產生和讀取數據。

typedef struct multp_multc_share {int pi;int ci;sem_t nempty;sem_t nstored;sem_t lock;int items;char buff[BUFF_SIZE]; }multp_multc_share;void* multp_multc_produce(void *arg) {multp_multc_share *ptr = arg;for(;;){lsem_wait(&(ptr->nempty));lsem_wait(&(ptr->lock));if(ptr->pi >= ptr->items){lsem_post(&(ptr->nstored));lsem_post(&(ptr->nempty));lsem_post(&(ptr->lock));return NULL;}ptr->buff[ptr->pi % BUFF_SIZE] = rand() % 100;printf("produce %d at %d\n", ptr->buff[ptr->pi * BUFF_SIZE], ptr->pi % BUFF_SIZE);ptr->pi++;lsem_post(&ptr->lock);lsem_post(&ptr->nstored);} }void* multp_multc_consume(void *arg) {multp_multc_share *ptr = arg;for(;;){lsem_wait(&(ptr->nstored));lsem_wait(&(ptr->lock));if(ptr->ci >= ptr->items){lsem_post(&(ptr->nstored));lsem_post(&(ptr->lock));return NULL;}printf("consume %d at %d\n", ptr->buff[ptr->ci % BUFF_SIZE], ptr->ci % BUFF_SIZE);ptr->ci++;lsem_post(&(ptr->lock));lsem_post(&(ptr->nempty));} }void multp_multc_test() {multp_multc_share arg;pthread_t pro_th[THREAD_SIZE], con_th[THREAD_SIZE];arg.items = 10;arg.pi = 0;arg.ci = 0;memset(arg.buff, 0, BUFF_SIZE * sizeof(int));lsem_init(&(arg.lock), 0, 1);lsem_init(&(arg.nempty), 0, BUFF_SIZE);lsem_init(&(arg.nstored), 0, 0);pthread_setconcurrency(THREAD_SIZE + 1); for(int i = 0;i < THREAD_SIZE;i ++){lpthread_create(&pro_th[i], NULL, multp_multc_produce, &arg);}for(int i = 0;i < THREAD_SIZE;i ++){lpthread_create(&con_th[i], NULL, multp_multc_consume, &arg);}for(int i = 0;i < THREAD_SIZE;i ++){lpthread_join(pro_th[i], NULL);}for(int i = 0;i < THREAD_SIZE;i ++){lpthread_join(con_th[i], NULL);}lsem_destroy(&(arg.lock));lsem_destroy(&(arg.nempty));lsem_destroy(&(arg.nstored)); } ? build git:(master) ? ./main produce 83 at 0 produce 0 at 1 produce 0 at 2 produce 0 at 3 consume 83 at 0 consume 86 at 1 consume 77 at 2 produce 1 at 4 produce 0 at 0 produce 0 at 1 produce 0 at 2 consume 15 at 3 consume 93 at 4 consume 35 at 0 consume 86 at 1 produce -2 at 3 consume 92 at 2 produce 98 at 4 consume 49 at 3 consume 21 at 4

2.3.3 多緩沖讀取

??通過多緩沖將數據從一個文件寫入到另一個文件。

typedef struct {struct {char buff[MAX_LEN + 1];int len;}buff[BUFF_SIZE];sem_t lock;sem_t nempty;sem_t nstored;int items;int readfd;int writefd; }wr_share;//將buffer中的數據寫入文件 void *write_buff(void *arg) {wr_share* ptr = arg;int i = 0;while(1){lsem_wait(&ptr->lock);//獲取當前緩沖區的操作lsem_post(&ptr->lock);lsem_wait(&ptr->nstored);lwrite(ptr->writefd, ptr->buff[i].buff, ptr->buff[i].len);lwrite(STDOUT_FILENO, ptr->buff[i].buff, ptr->buff[i].len);i++;if(i >= ptr->items){i = 0;}lsem_post(&ptr->nempty);} }//從文件中讀取數據 void *read_buff(void *arg) {wr_share* ptr = arg;int i = 0;while(1){lsem_wait(&ptr->lock);//獲取當前緩沖區的操作lsem_post(&ptr->lock);lsem_wait(&ptr->nempty);int n = lread(ptr->readfd, ptr->buff[i].buff, MAX_LEN);ptr->buff[i].len = n;i++;if(i >= ptr->items){i = 0;}lsem_post(&ptr->nstored);} }void read_write_test() {wr_share arg;arg.items = BUFF_SIZE;#if 0char *readfile = "build/CMakeCache.txt";char *writefile = "build/mktmp";#elsechar *readfile = "CMakeCache.txt";char *writefile = "mktmp";#endifarg.readfd = lopen(readfile, O_RDONLY);arg.writefd = lopen(writefile, O_WRONLY | O_CREAT);lsem_init(&arg.lock, 0, 1);lsem_init(&arg.nempty, 0, arg.items);lsem_init(&arg.nstored, 0, 0);pthread_t read_th, write_th;lpthread_create(&read_th, 0, read_buff, &arg);lpthread_create(&write_th, 0, write_buff, &arg);lpthread_join(read_th, NULL);lpthread_join(write_th, NULL);lsem_destroy(&arg.lock);lsem_destroy(&arg.nempty);lsem_destroy(&arg.nstored); }

3 System V信號量

3.1 System V信號量

??上面提到的Posix信號量有二值信號量和計數信號量，而System V信號量是信號量集，即一個或者多個信號量構成的集合，這個集合中的信號量都是計數信號量。
??對于信號量集，內核維護的信息結構如下：

/* Data structure describing a set of semaphores. */ struct semid_ds {struct ipc_perm sem_perm; /* Ownership and permissions */time_t sem_otime; /* Last semop time */time_t sem_ctime; /* Last change time */unsigned long sem_nsems; /* No. of semaphores in set */ };//每個信號量包含的值 unsigned short semval; /* semaphore value */ unsigned short semzcnt; /* # waiting for zero */ unsigned short semncnt; /* # waiting for increase */ pid_t sempid; /* ID of process that did last op */

??上面的第一個結構是書上提到的，下面的第二個結構是我主機上的結構，我猜測原理都差不多只是實現進行了修改，因此以書本上的描述為主。

• sem_perm：用戶的操作權限；
• sem_nsems：當前數據結構中信號量的數量；
• sem_otime：上一次調用apisem_op的時間；
• sem_ctime：信號量創建的時間或上次調用IPC_SET的時間。

int semget(key_t key, int nsems, int semflg); int semop(int semid, struct sembuf *sops, size_t nsops); int semctl(int semid, int semnum, int cmd, ...);

• semget：創建一個或者訪問一個已經存在的信號量集；
  • key：鍵值；
  • nsems：希望初始化的信號量數目，初始化之后不可修改，如果只是訪問已經存在的信號量集則設為0；
  • semflg：可以為SEM_R,SEM_A分別表示讀和修改，也可以為IPC_CREAT, IPC_EXCL；
  • 返回值為信號量的標識符的整數；
  • 當創建新的信號量時，用戶權限，讀寫權限，創建時間，信號量的數目都會設置，但是結構中的數組，即各個信號量并不會初始化。這本身是不安全的，即便創建之后立即初始化，因為操作是非原子性的，無法保證絕對的安全；
• semop：操作信號量集，內核能夠保證當前操作的原子性；
  • semid：通過sem_get獲得的信號量標識符；
  • sops：是一個如下結構數據的數組,因為有些系統不會定義該結構，因此有些時候需要用戶自己定義：struct sembuf { unsigned short int sem_num; /* semaphore number */ short int sem_op; /* semaphore operation */ short int sem_flg; /* operation flag */ };
    • sem_num：需要操作的信號量在信號量集中的下標；
    • sem_flg：進行操作的設置：
      • 0;
      • IPC_NOWAIT：不阻塞；
      • SEM_UNDO;
    • sem_op：具體的操作方式
      • sem_op > 0：
        • 未設置SEM_UNDO：將當前值加到sem_val上，即sem_val += sem_op，等同于V操作，只不過釋放線程量可能大于1；
        • 設置SEM_UNDO：從相應的信號量的進程調整值（由內核維護）中減去sem_op；
      • sem_op == 0：調用者希望sem_val==0：
        • 如果sem_val == 0：立即返回；
        • 如果sem_val != 0：對應信號量的semzcnt += 1，阻塞至為0為止，除非設置了IPC_NOWAIT，則不阻塞直接返回錯誤；
      • sem_op < 0：調用者希望等待sem_val >= |sem_op|用于等待資源：
        • 如果sem_val >= |sem_op|，則sem_val -= |sem_op|，若設置了SEM_UNDO，則將|sem_op|加到對應信號量的進程調整值上；
        • 如果sem_val < |sem_op|，則相應信號量的semncnt += 1，線程被阻塞到滿足條件為止。等到解阻塞時semval-=|sem_op，并且semncnt -= 1，如果制定了SEM_UNDO則sem_op的絕對值加到對應信號量的調整值上。如果指定了IPC_NOWAIT則線程不會阻塞。
      • 如果一個被捕獲的信號喚醒了sem_op或者信號量被刪除，則該函數會過早的返回一個錯誤。
• semctl：控制信號量集；
  • semid：信號量集的標識符；
  • semnum：要操作的信號量的標號；
  • cmd：命令；
    • GETVAL：semval作為返回值返回，-1表示失敗；
    • SETVAL：semval設置為arg.val，成功的話相應信號量在進程中的信號量調整值會設置為0；
    • GETPID：返回sempid；
    • GETNCNT：返回semncnt；
    • GETZCNT：返回semzcnt；
    • GETALL：返回所有信號量的semval，存入arg.array；
    • SETALL：按照arg.array設置所有信號量的semval；
    • IPC_RMID：刪除指定信號量集；
    • IPC_SET：根據arg.buf設置信號量集的sem_perm.uid,sem_perm.gid,sem_perm.mode；
    • IPC_STAT：返回當前信號量集的semid_ds結構，存入arg.buf，空間需要用戶分配。
  • arg：可選，根據cmd指定。
  union semun {int val; /* Value for SETVAL */struct semid_ds *buf; /* Buffer for IPC_STAT, IPC_SET */unsigned short *array; /* Array for GETALL, SETALL */struct seminfo *__buf; /* Buffer for IPC_INFO(Linux-specific) */};

??存在的一些限制：

• semmni：系統范圍內最大信號量集數；
• semmsl：每個信號量集最大信號量數；
• semmns：系統范圍內最大信號量數；
• semopm：每個semop調用最大操作數；
• semmnu：系統范圍內最大復舊結構數；
• semume：每個復舊結構最大復舊項數；
• semvmx：任何信號量的最大值；
• semaem：最大退出時調整值。

3.2 示例

int vsem_create(key_t key) {int semid = lsemget(key, 1, 0666 | IPC_CREAT | IPC_EXCL);return semid; }int vsem_open(key_t key) {int semid = lsemget(key, 0, 0);//創建一個信號量集 return semid; }int vsem_p(int semid)// {struct sembuf sb = {0, -1, /*IPC_NOWAIT*/SEM_UNDO};//對信號量集中第一個信號進行操作，對信號量的計數值減1，lsemop(semid, &sb, 1);//用來進行P操作 return 0; }int vsem_v(int semid) {struct sembuf sb = {0, 1, /*0*/SEM_UNDO};lsemop(semid, &sb, 1);return 0; }int vsem_d(int semid) {int ret = semctl(semid, 0, IPC_RMID, 0);//刪除一個信號量集return ret; }int vsem_setval(int semid, int val) {union semun su;su.val = val;semctl(semid, 0, SETVAL, &su);//給信號量計數值printf("value updated...\n");return 0; }int vsem_getval(int semid)//獲取信號量集中信號量的計數值 {int ret = semctl(semid, 0, GETVAL, 0);//返回值是信號量集中printf("current val is %d\n", ret);return ret; }int vsem_getmode(int semid) {union semun su;struct semid_ds sem;su.buf = &sem;semctl(semid, 0, IPC_STAT, su);printf("current permissions is %o\n", su.buf->sem_perm.mode);return 0; }int vsem_setmode(int semid, char *mode) {union semun su;struct semid_ds sem;su.buf = &sem;semctl(semid, 0, IPC_STAT, su);printf("current permissions is %o\n", su.buf->sem_perm.mode);sscanf(mode, "%o", (unsigned int *)&su.buf->sem_perm.mode);semctl(semid, 0, IPC_SET, &su);printf("permissions updated...\n");return 0; }void usage(void) {fprintf(stderr, "usage:\n");fprintf(stderr, "semtool -c\n");fprintf(stderr, "semtool -d\n");fprintf(stderr, "semtool -p\n");fprintf(stderr, "semtool -v\n");fprintf(stderr, "semtool -s <val>\n");fprintf(stderr, "semtool -g\n");fprintf(stderr, "semtool -f\n");fprintf(stderr, "semtool -m <mode>\n"); }void v_test(int argc, char *argv[]) {int opt;opt = getopt(argc, argv, "cdpvs:gfm:");//解析參數if (opt == '?')exit(EXIT_FAILURE);if (opt == -1){usage();exit(EXIT_FAILURE);}key_t key = ftok(".", 's');int semid;switch (opt){case 'c'://創建信號量集vsem_create(key);break;case 'p'://p操作semid = vsem_open(key);vsem_p(semid);vsem_getval(semid);break;case 'v'://v操作semid = vsem_open(key);vsem_v(semid);vsem_getval(semid);break;case 'd'://刪除一個信號量集semid = vsem_open(key);vsem_d(semid);break;case 's'://對信號量集中信號量設置初始計數值semid = vsem_open(key);vsem_setval(semid, atoi(optarg));break;case 'g'://獲取信號量集中信號量的計數值semid = vsem_open(key);vsem_getval(semid);break;case 'f'://查看信號量集中信號量的權限semid = vsem_open(key);vsem_getmode(semid);break;case 'm'://更改權限semid = vsem_open(key);vsem_setmode(semid, argv[2]);break;}return; }

總結

以上是生活随笔為你收集整理的Linux进程通信之信号量的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。