C++ linux 信号量

简介

信号量本质上是一个计数器，用于协调多个进程（包括但不限于父子进程）对共享数据对象的读/写。

它不以传送数据为目的，主要是用来保护共享资源（共享内存、消息队列、socket连接池、数据库连接池等），保证共享资源在一个时刻只有一个进程独享。

信号量是一个特殊的变量，只允许进程对它进行等待信号和发送信号操作。最简单的信号量是取值0和1的二元信号量，这是信号量最常见的形式。

通用信号量（可以取多个正整数值）和信号量集方面的知识比较复杂，应用场景也比较少。

参考链接

https://freecplus.net/91049192da9e435a92209b287a220af8.html

https://www.zhihu.com/question/40562993/answer/87204567

Q&A

信号量和锁有什么区别

那互斥锁和数量为1的信号量有什么区别？

信号量（Semaphore）信号量就是一个停车场。当前值是停车场里还剩下多少个空车位。最大值是停车场里最多能容纳多少个车位。当汽车进入停车场时，首先要在门口排队(sem_wait)，得到进入许可后才能进入。排队顺序原则上先到先得。每进一辆车，停车场就少了1个停车位，即信号量当前值-1。当前值为0时，停车场停满了，所有车不得进入统统在门口排队等。当一辆车离开后，释放其所占据的停车位(sem_post)，信号量当前值+1信号量值得到释放后，如果门口有正在排队的车，那么就放进来，每放进来一个就重复前面的步骤。2. 互斥锁（Mutex）Mutex就是厕所的隔间门开着的时候谁都可以进但是一次只能进一个人进去后就从里面锁上门厕所里有人的时候其他人就要排队等，直到里面的人出来.

本质上信号量和锁是同一种东西

答主的评论

本质上没有区别。实际上在posix中是没有mutex只有semaphore的，stl通过自己的封装提供了std::mutex，std::recursive_mutex等互斥锁类以及std::lock_guard, std::unique_lock等辅助类来实现mutex功能。

code

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/sem.h>

class CSEM {
private :
    union semun{ // 用于信号操作的共同体
        int val;
        struct semid_ds *buf;
        unsigned short *array;
    };
    int sem_id; // 信号量描述符号
public:
    bool init(key_t key); // 如果信号量已经存在，获取信号量； 如果信号量不存在，则创建信号量并初始化。
    bool wait(); // 等待信号量
    bool post(); // 产生信号量
    bool destory(); // 销毁信号量
};

int main(int argc, char **argv) {
    CSEM sem;

    // 初始信号量
    if (sem.init(0x5000) == false) {
        printf("sem.init failed.\n");
        return -1;
    }
    printf("sem.init ok\n");

    // 等待信号量，等待成功后，将持有信号量，我感觉信号量也像锁一样
    if (sem.wait() == false) {
        printf("sem.wait failed.\n");
        return -1;
    }
    printf("sem.wait ok\n");

    sleep(30); // 在sleep的过程中，其他需要这个信号量的程序将会等待锁

    // 挂出信号量，释放锁
    if (sem.post() == false) {
        printf("sem.post failed.\n");
        return -1;
    }
    printf("sem.post  ok\n");

    // 销毁信号量
    // if(sem.destory() == false)
    // {
    //     printf("sem.destory failed.\n");
    //     return -1;
    // }
    // printf("sem.destory ok\n");
}

bool CSEM::init(key_t key){
    // 获取信号量
    if((sem_id=semget(key, 1, 0640)) == -1){
        // 如果信号量不存在，创建它
        if(errno == 2){
            if((sem_id = semget(key, 1, 0640 | IPC_CREAT)) == -1) {
                perror("init 1 semget()");
                return false;
            }
            // 信号量创建成功后，还需要把它初始化成可用的状态
            union semun sem_union;
            sem_union.val = 1;
            if(semctl(sem_id, 0, SETVAL, sem_union) < 0) {
                perror("init semctl()");
                return false;
            }
        }else {
            perror("init 2 semget()");
            return false;
        }
    }
    return true;
}

bool CSEM::destory() {
    if(semctl(sem_id, 0, IPC_RMID) == -1) {
        perror("destroy semctl()");
        return false;
    }
    return true;
}

bool CSEM::wait() {
    struct sembuf sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_op = -1;
    sem_b.sem_flg = SEM_UNDO;
    if(semop(sem_id, &sem_b, 1) == -1) {
        perror("wait semop()");
        return false;
    }
    return true;
}

bool CSEM::post() {
    struct sembuf sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_op = 1;
    sem_b.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sem_b, 1) == -1) {
        perror("post semop()");
        return false;
    }
    return true;
}

相关信号量的函数

Linux中提供了一组函数用于操作信号量，程序中需要包含以下头文件：

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

1. semget函数
   
   semget函数用来获取或创建信号量，它的原型如下：

int semget(key_t key, int nsems, int semflg);

1）参数key是信号量的键值，typedef unsigned int key_t，是信号量在系统中的编号，不同信号量的编号不能相同，这一点由程序员保证。key用十六进制表示比较好。

2）参数nsems是创建信号量集中信号量的个数，该参数只在创建信号量集时有效，这里固定填1。

3）参数sem_flags是一组标志，如果希望信号量不存在时创建一个新的信号量，可以和值IPC_CREAT做按位或操作。如果没有设置IPC_CREAT标志并且信号量不存在，就会返错误（errno的值为2，No such file or directory）。

4）如果semget函数成功，返回信号量集的标识；失败返回-1，错误原因存于error中。

示例：

1）获取键值为0x5000的信号量，如果该信号量不存在，就创建它，代码如下：

int semid=semget(0x5000,1,0640|IPC_CREAT);

2) 获取键值为0x5000的信号量，如果该信号量不存在，返回-1，errno的值被设置为2，代码如下：

int semid= semget(0x5000,1,0640)；

2. semctl 函数

该函数用来控制信号量(常用语设置信号量的初始值和销毁信号量),他的原型如下

int semctl(int semid, int sem_num, int command, ...);

1）参数semid是由semget函数返回的信号量标识。

2）参数sem_num是信号量集数组上的下标，表示某一个信号量，填0。

3）参数cmd是对信号量操作的命令种类，常用的有以下两个：

IPC_RMID：销毁信号量，不需要第四个参数；

SETVAL：初始化信号量的值（信号量成功创建后，需要设置初始值），这个值由第四个参数决定。第四参数是一个自定义的共同体，如下：

// 用于信号灯操作的共同体。
  union semun
  {
    int val;
    struct semid_ds *buf;
    unsigned short *arry;
  };

4）如果semctl函数调用失败返回-1；如果成功，返回值比较复杂，暂时不关心它。

示例：

1）销毁信号量。

semctl(semid,0,IPC_RMID);

2）初始化信号量的值为1，信号量可用。

  union semun sem_union;
  sem_union.val = 1;
  semctl(semid,0,SETVAL,sem_union);

3、semop函数

该函数有两个功能：1）等待信号量的值变为1，如果等待成功，立即把信号量的值置为0，这个过程也称之为等待锁；2）把信号量的值置为1，这个过程也称之为释放锁。

int semop(int semid, struct sembuf *sops, unsigned nsops);

1）参数semid是由semget函数返回的信号量标识。

2）参数nsops是操作信号量的个数，即sops结构变量的个数，设置它的为1（只对一个信号量的操作）。

3）参数sops是一个结构体，如下：

struct sembuf
{
  short sem_num;   // 信号量集的个数，单个信号量设置为0。
  short sem_op;    // 信号量在本次操作中需要改变的数据：-1-等待操作；1-发送操作。
  short sem_flg;   // 把此标志设置为SEM_UNDO，操作系统将跟踪这个信号量。
                   // 如果当前进程退出时没有释放信号量，操作系统将释放信号量，避免资源被死锁。
};

示例：

1）等待信号量的值变为1，如果等待成功，立即把信号量的值置为0；

  struct sembuf sem_b;
  sem_b.sem_num = 0;
  sem_b.sem_op = -1;
  sem_b.sem_flg = SEM_UNDO;
  semop(sem_id, &sem_b, 1);

2）把信号量的值置为1。

  struct sembuf sem_b;
  sem_b.sem_num = 0;
  sem_b.sem_op = 1;
  sem_b.sem_flg = SEM_UNDO;
  semop(sem_id, &sem_b, 1);

其他操作命令

用ipcs -s可以查看系统的信号量，内容有键值（key），信号量编号（semid），创建者（owner），权限（perms），信号量数（nsems）。

用ipcrm sem 信号量编号，可以手工删除信号量

code

使用信号量来访问共享内存

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>

class CSEM {
private :
    union semun{ // 用于信号操作的共同体
        int val;
        struct semid_ds *buf;
        unsigned short *array;
    };
    int sem_id; // 信号量描述符号
public:
    bool init(key_t key); // 如果信号量已经存在，获取信号量； 如果信号量不存在，则创建信号量并初始化。
    bool wait(); // 等待信号量
    bool post(); // 产生信号量
    bool destory(); // 销毁信号量
};

int main(int argc, char **argv) {
    CSEM sem;
    int shmid; // 共享内存标识符
    // 创建共享内存，键值为0x5000， 共1024字节
    if( (shmid = shmget((key_t)0x5000, 1024, 0640|IPC_CREAT) ) == -1){
        printf("shmat(0x5000) failed\n");
        return -1;
    }
    char *ptext = 0; // 用于指向共享内存的指针

    // 将共享内存链接到当前进程的地址空间， 由ptext 指针指向它
    ptext = (char *)shmat(shmid, 0, 0);
    // 初始信号量
    if (sem.init(0x5000) == false) {
        printf("sem.init failed.\n");
        return -1;
    }
    printf("sem.init ok\n");

    // 等待信号量，等待成功后，将持有信号量，我感觉信号量也像锁一样
    if (sem.wait() == false) {
        printf("sem.wait failed.\n");
        return -1;
    }
    printf("sem.wait ok\n");

    // 操作本程序的ptext指针，就是操作共享内存
    printf("写入前: %s\n", ptext);
    // sprintf(ptext, "本程序的进程号是: %d", getpid());
    strcpy(ptext, argv[1]);
    // sprintf(ptext, "本程序的进程号是: %d", getpid());
    printf("写入后: %s\n", ptext);

    sleep(30); // 在sleep的过程中，其他需要这个信号量的程序将会等待锁

    // 挂出信号量，释放锁
    if (sem.post() == false) {
        printf("sem.post failed.\n");
        return -1;
    }
    printf("sem.post  ok\n");

    // 把共享内存从当前进程中分离
    shmdt(ptext);

    // 销毁信号量
    // if(sem.destory() == false)
    // {
    //     printf("sem.destory failed.\n");
    //     return -1;
    // }
    // printf("sem.destory ok\n");
}

bool CSEM::init(key_t key){
    // 获取信号量
    if((sem_id=semget(key, 1, 0640)) == -1){
        // 如果信号量不存在，创建它
        if(errno == 2){
            if((sem_id = semget(key, 1, 0640 | IPC_CREAT)) == -1) {
                perror("init 1 semget()");
                return false;
            }
            // 信号量创建成功后，还需要把它初始化成可用的状态
            union semun sem_union;
            sem_union.val = 1;
            if(semctl(sem_id, 0, SETVAL, sem_union) < 0) {
                perror("init semctl()");
                return false;
            }
        }else {
            perror("init 2 semget()");
            return false;
        }
    }
    return true;
}

bool CSEM::destory() {
    if(semctl(sem_id, 0, IPC_RMID) == -1) {
        perror("destroy semctl()");
        return false;
    }
    return true;
}

bool CSEM::wait() {
    struct sembuf sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_op = -1;
    sem_b.sem_flg = SEM_UNDO;
    if(semop(sem_id, &sem_b, 1) == -1) {
        perror("wait semop()");
        return false;
    }
    return true;
}

bool CSEM::post() {
    struct sembuf sem_b;
    sem_b.sem_num = 0;
    sem_b.sem_op = 1;
    sem_b.sem_flg = SEM_UNDO;
    if (semop(sem_id, &sem_b, 1) == -1) {
        perror("post semop()");
        return false;
    }
    return true;
}