Linux 进程间通信之 - 信号量

前言

很久不用，基本概念虽然还记得，估计不会用了，写个demo练练手。

概念

信号量（信号灯）本质上是一个计数器，用于协调多个进程（包括但不限于父子进程）对共享数据对象的读/写。它不以传送数据为目的，主要是用来保护共享资源（信号量、消息队列、socket连接等），保证共享资源在一个时刻只有一个进程独享。

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

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

相关函数

更多信息请通过 man 命令参考 linux 手册

NAME
       semget - get a System V semaphore set identifier

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

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

NAME
       semop, semtimedop - System V semaphore operations

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

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

NAME
       semctl - System V semaphore control operations

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

       int semctl(int semid, int semnum, int cmd, ...);

接口封装

// Semaphore.h
//
// Created by zhaoyf on 2022/5/3.
//

#ifndef LINUX_SEMAPHORE_H
#define LINUX_SEMAPHORE_H

namespace Semaphore {
    /// 创建或者获取已存在的信号量
    /// \param num 要创建的信号量集中信号量数量， [0, 1, 2, ..., n-1]
    /// \param key 创建信号量的 key
    /// \return    信号量id
    int SemInit(int num, int key);

    /// p操作，信号量值减1
    /// \param semid 信号量id
    void SemP(int semid);

    /// v操作，信号量值加1
    /// \param semid 信号量id
    void SemV(int semid);

    /// 销毁信号量集中的所有信号量
    /// \param semid 信号量id
    /// \param num   信号量数量
    void SemRelease(int semid, int num);
}

#endif //LINUX_SEMAPHORE_H

// Semaphore.cpp
//
// Created by zhaoyf on 2022/5/3.
//

#include "Semaphore.h"

#include <stdio.h>

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

namespace Semaphore {
    /* 定义自己的semun联合体*/
    union semun {
        int val;
        struct semid_ds *buf;
        unsigned short *array;
        struct seminfo *__buf;
    };

    /// 创建或者获取已存在的信号量
    /// \param num 要创建的信号量集中信号量数量， [0, 1, 2, ..., n-1]
    /// \param key 创建信号量的 key
    /// \return    信号量id
    int SemInit(int num, int key) {
        int semid = -1;
        semid = semget((key_t) key, num, IPC_CREAT | IPC_EXCL | 0600);
        if (semid == -1) {
            // 指定 key 信号量已存在
            semid = semget((key_t) 1234, 1, 0600);
        } else {
            // 设置初始值
            union semun a;
            a.val = 1;//信号量的初始值
            if (semctl(semid, 0, SETVAL, a) == -1) {
                perror("semctl error");
            }
        }
        return semid;
    }

    /// p操作，信号量值减1
    /// \param semid 信号量id
    void SemP(int semid) {
        struct sembuf buf;
        buf.sem_num = 0;
        buf.sem_op = -1;//p
        buf.sem_flg = SEM_UNDO;
        if (semop(semid, &buf, 1) == -1) {
            perror("semop p error");
        }
    }

    /// v操作，信号量值加1
    /// \param semid 信号量id
    void SemV(int semid) {
        struct sembuf buf;
        buf.sem_num = 0;
        buf.sem_op = 1;//v
        buf.sem_flg = SEM_UNDO;
        if (semop(semid, &buf, 1) == -1) {
            perror("semop v error");
        }
    }

    /// 销毁信号量集中的所有信号量
    /// \param semid 信号量id
    /// \param num   信号量数量
    void SemRelease(int semid, int num) {
        for (int i = 0; i < num; ++i) {
            if (semctl(semid, i, IPC_RMID) == -1) {
                perror("semctl del error");
            }
        }
    }
}

测试用例

进程一代码 a.cpp

// a.cpp
//
// Created by zhaoyf on 2022/5/4.
//
#include "Semaphore.h"

#include <thread>
#include <chrono>

#include <stdio.h>

// 进程1代码
int main() {
    int semId = Semaphore::SemInit(1, 1234);
    const int NUM = 5;
    for (int i = 0; i < NUM; ++i) {
        Semaphore::SemP(semId);
        printf("a");
        fflush(stdout);
        int n = rand() % 3000;
        std::this_thread::sleep_for(std::chrono::milliseconds(n));
        printf("a");
        fflush(stdout);
        Semaphore::SemV(semId);

        n = rand() % 3000;
        std::this_thread::sleep_for(std::chrono::milliseconds(n));
    }
    return 0;
}

进程二代码 b.cpp

// b.cpp
//
// Created by zhaoyf on 2022/5/4.
//

#include "Semaphore.h"

#include <thread>
#include <chrono>

#include <stdio.h>

// 进程2代码
int main() {
    int semId = Semaphore::SemInit(1, 1234);
    const int NUM = 5;
    for (int i = 0; i < NUM; ++i) {
        Semaphore::SemP(semId);
        printf("b");
        fflush(stdout);
        int n = rand() % 3000;
        std::this_thread::sleep_for(std::chrono::milliseconds(n));
        printf("b");
        fflush(stdout);
        Semaphore::SemV(semId);

        n = rand() % 3000;
        std::this_thread::sleep_for(std::chrono::milliseconds(n));
    }
    return 0;
}

gcc -o a a.cpp Semaphore.cpp
gcc -o b b.cpp Semaphore.cpp

./a & .b

output:
bbaabbaabbaabbaabbaabbaabbaabbaabbbbaaaa

注

个人代码仓库请参考： Linux: Linux学习资源汇总