linux进程间的通信-信号量（semget、semstl、semop）

已于 2023-08-23 14:01:05 修改
阅读量933 收藏 16
点赞数 2
分类专栏： linux-进程间的通信(IPC) 文章标签： linux
于 2023-08-22 23:50:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49178419/article/details/132418225
版权

1. semget函数原型

semget(得到一个信号量集标识符或创建一个信号量集对象)

所需头文件

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

函数说明:

得到一个信号量集标识符或创建一个信号量集对象并返回信号量集标识符

函数原型

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

参数解释：

  • key：键值，用于唯一标识一个信号量集。通常可以通过 ftok 函数生成。
  • nsems：信号量集中信号量的数量。
  • semflg：标志位，用于指定信号量的权限和行为选项。（参数ruxia）
  1. IPC_CREAT：如果指定的键值不存在，则创建一个新的信号量集。如果已存在，则返回已存在的信号量集的标识符。
  2. IPC_EXCL：与 IPC_CREAT 一起使用时，如果指定的键值已存在，则返回错误。通常与 IPC_CREAT 结合使用，用于确保创建一个新的信号量集而不是获取已存在的信号量集。
  3. IPC_NOWAIT：在等待获取信号量资源时，不阻塞进程。如果无法立即获得资源，则直接返回错误。
  4. SEM_R：指定信号量集的读取权限，允许其他进程进行读取操作。
  5. SEM_A：指定信号量集的修改权限，允许其他进程进行修改操作。

函数返回值：

  • 成功：返回一个非负整数，表示对应的信号量集标识符（称为信号量集 ID）。
  • 失败：返回 -1，并设置 errno 错误码来指示具体错误原因。

附加说明

上述semflg参数为模式标志参数，使用时需要与IPC对象存取权限（如0600）进行|运算来确定信号量集的存取权限

错误代码

EACCESS没有权限
EEXIST信号量集已经存在，无法创建
EIDRM信号量集已经删除
ENOENT信号量集不存在，同时semflg没有设置IPC_CREAT标志
ENOMEM没有足够的内存创建新的信号量集
ENOSPC超出限制

如果用semget创建了一个新的信号量集对象时，则semid_ds(一般与semctl、STAT)结构成员变量的值设置如下：

       sem_otime设置为0。

       sem_ctime设置为当前时间。

       msg_qbytes设成系统的限制值。

       sem_nsems设置为nsems参数的数值。

       semflg的读写权限写入sem_perm.mode中。

       sem_perm结构的uid和cuid成员被设置成当前进程的有效用户ID，gid和cuid成员被设置成当前进程的有效组ID。
 

 2. semop函数原型

   semop(完成对信号量的P操作或V操作)

所需头文件

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

函数说明

对信号量集标识符为semid中的一个或多个信号量进行P操作或V操作

函数原型

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

参数解释

semid：信号量集标识符

sops：指向进行操作的信号量集结构体数组的首地址，每个结构体描述了一个操作。此结构的具体说明如下：

struct sembuf {

          unsigned short sem_num;  /* semaphore number */
           short          sem_op;   /* semaphore operation */
           short          sem_flg;  /* operation flags */

  };

  1. short sem_num：要操作的信号量在集合中的索引，从0开始计数。
  2. short sem_op：进行的操作。可以是正数、负数或零。通常情况下，正数表示释放资源，负数表示请求资源，零表示等待资源。
  3. short sem_flg：控制操作的标志位。常用的标志有：
    • SEM_UNDO：使操作可以被撤销，即在进程意外终止时自动撤销操作。
    • IPC_NOWAIT：如果操作无法立即执行，不要阻塞进程，立即返回并报告错误。
    • SEM_NOERROR：如果出现错误（如信号量不存在），不要报告错误。

nsops：进行操作信号量的个数，即sops结构变量的个数，需大于或等于1。最常见设置此值等于1，只完成对一个信号量的操作

函数返回值

成功：返回信号量集的标识符

出错：-1，错误原因存于error中

错误代码

E2BIG一次对信号量个数的操作超过了系统限制
EACCESS权限不够
EAGAIN使用了IPC_NOWAIT，但操作不能继续进行
EFAULTsops指向的地址无效
EIDRM信号量集已经删除
EINTR当睡眠时接收到其他信号
EINVAL信号量集不存在,或者semid无效
ENOMEM使用了SEM_UNDO，但无足够的内存创建所需的数据结构
ERANGE信号量值超出范围

sops为指向sembuf数组，定义所要进行的操作序列。下面是信号量操作举例。

struct sembuf sem_get={0,-1,IPC_NOWAIT}; /*将信号量对象中序号为0的信号量减1*/

struct sembuf sem_get={0,1,IPC_NOWAIT};  /*将信号量对象中序号为0的信号量加1*/

struct sembuf sem_get={0,0,0};           /*进程被阻塞，直到对应的信号量值为0*/

flag一般为0，若flag包含IPC_NOWAIT，则该操作为非阻塞操作。若flag包含SEM_UNDO，则当进程退出的时候会还原该进程的信号量操作，这个标志在某些情况下是很有用的，比如某进程做了P操作得到资源，但还没来得及做V操作时就异常退出了，此时，其他进程就只能都阻塞在P操作上，于是造成了死锁。若采取SEM_UNDO标志，就可以避免因为进程异常退出而造成的死锁。
 

 3. semctl函数原型 

semctl (得到一个信号量集标识符或创建一个信号量集对象)

所需头文件

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

函数说明

得到一个信号量集标识符或创建一个信号量集对象并返回信号量集标识符

函数原型

int semctl(int semid, int semnum, int cmd, union semun arg)

参数解释

semid：信号量集标识符

semnum：是要操作的信号量在集合中的索引，通常为0，表示第一个信号量。

cmd：见下文表15-4

arg（是一个联合体）：

   union semun {

   short val;          /*SETVAL用的值*/

   struct semid_ds* buf; /*IPC_STAT、IPC_SET用的semid_ds结构*/

   unsigned short* array; /*SETALL、GETALL用的数组值*/

   struct seminfo *buf;   /*为控制IPC_INFO提供的缓存*/

  } arg;

函数返回值

成功：大于或等于0，具体说明请参照表15-4

出错：-1，错误原因存于error中

附加说明

semid_ds结构见上文信号量集内核结构定义

错误代码

EACCESS权限不够
EFAULTarg指向的地址无效
EIDRM信号量集已经删除
EINVAL信号量集不存在，或者semid无效
EPERM进程有效用户没有cmd的权限
ERANGE信号量值超出范围

cmd参数列表: 

cmd解释
IPC_STAT从信号量集上检索semid_ds结构，并存到semun联合体参数的成员buf的地址中
IPC_SET设置一个信号量集合的semid_ds结构中ipc_perm域的值，并从semun的buf中取出值
IPC_RMID从内核中删除信号量集合
GETALL从信号量集合中获得所有信号量的值，并把其整数值存到semun联合体成员的一个指针数组中
GETNCNT返回当前等待资源的进程个数
GETPID返回最后一个执行系统调用semop()进程的PID
GETVAL返回信号量集合内单个信号量的值
GETZCNT返回当前等待100%资源利用的进程个数
SETALL与GETALL正好相反
SETVAL用联合体中val成员的值设置信号量集合中单个信号量的值

 

 一次之操作一个信号量：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/sem.h>
#include <sys/ipc.h>

union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};

void v (int semid)
{
	struct sembuf sops;
        sops.sem_num = 0;       // 操作信号量集中的第一个信号量
        sops.sem_op = 1;       // 执行V操作，增加信号量的值 by 1
        sops.sem_flg = SEM_UNDO;
  
        semop(semid, &sops, 1);  // 执行V操作，将信号量的值增加 by 1
}

void p (int semid)
{
	struct sembuf sops;
        sops.sem_num = 0;       // 操作信号量集中的第一个信号量
        sops.sem_op = -1;       // 执行P操作，减少信号量的值 by 1
        sops.sem_flg = SEM_UNDO;
  
        semop(semid, &sops, 1);  // 执行P操作，将信号量的值增加 by 1
}
int main() {
    int semid;
    union semun arg;
    key_t key=ftok(".",3);
    // 创建一个信号量.集合，其中包含一个信号量
    semid = semget(key, 1, 0666 | IPC_CREAT);
    if (semid == -1) {
        perror("semget");
        exit(1);
    }

    // 初始化信号量的值为0，表示子进程需要等待
    arg.val = 0;
    if (semctl(semid, 0, SETVAL, arg) == -1) {
        perror("semctl");
        exit(1);
    }

    pid_t pid = fork();
    if (pid > 0) {
        // 父进程
	p(semid);
        printf("Father program pid = %d\n", getpid());
	v(semid);
        // 释放信号量资源
        if (semctl(semid, 0, IPC_RMID) == -1) {
            perror("semctl");
            exit(1);
        }
    } else if (pid == 0) {
        // 子进程
        printf("Child program pid = %d\n", getpid());
        sleep(1); // 模拟一些工作
	v(semid);
    } else {
        perror("fork");
        exit(1);
    }

    return 0;
}

结果：

 一次性操作两个信号量

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>

#define SEM_KEY 1224

void acquire_resources(int semid) {
    struct sembuf operations[2];

    // 第一个信号量操作
    operations[0].sem_num = 0;
    operations[0].sem_op = -1;
    operations[0].sem_flg = SEM_UNDO;

    // 第二个信号量操作
    operations[1].sem_num = 1;
    operations[1].sem_op = -1;
    operations[1].sem_flg = SEM_UNDO;

    if (semop(semid, operations, 2) == -1) {
        perror("semop");
        exit(1);
    }

    printf("Resources acquired.\n");
}

void release_resources(int semid) {
    struct sembuf operations[2];

    // 第一个信号量操作
    operations[0].sem_num = 0;
    operations[0].sem_op = 1;
    operations[0].sem_flg = SEM_UNDO;

    // 第二个信号量操作
    operations[1].sem_num = 1;
    operations[1].sem_op = 1;
    operations[1].sem_flg = SEM_UNDO;

    if (semop(semid, operations, 2) == -1) {
        perror("semop");
        exit(1);
    }

    printf("Resources released.\n");
}

int main() {
    int semid;
    pid_t pid;

    // 创建信号量集合
    semid = semget(SEM_KEY, 2, IPC_CREAT | 0666);
    if (semid == -1) {
        perror("semget");
        exit(1);
    }

    // 初始化信号量集合
    unsigned short values[2] = {1, 1};
    if (semctl(semid, 0, SETALL, values) == -1) {
        perror("semctl");
        exit(1);
    }

    // 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(1);
    }

    if (pid == 0) {
        // 子进程
        sleep(2);
        acquire_resources(semid);
    } else {
        // 父进程
        printf("Parent process.\n");
        acquire_resources(semid);
        sleep(5);
        release_resources(semid);
    }

    // 删除信号量集合
    if (semctl(semid, 0, IPC_RMID, NULL) == -1) {
    perror("semctl");
    exit(1);
}

    return 0;
}

 结果：（有个小问题就是最后一行 ，由于父子进程都执行了删除信号量集合，所以重复执行。）

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/sem.h>

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 */
};

/***对信号量数组semnum编号的信号量做P操作***/
int P(int semid, int semnum)
{
    struct sembuf sops = {semnum, -1, SEM_UNDO};
    return (semop(semid, &sops, 1));
}

/***对信号量数组semnum编号的信号量做V操作***/
int V(int semid, int semnum)
{
    struct sembuf sops = {semnum, +1, SEM_UNDO};
    return (semop(semid, &sops, 1));
}

int main(int argc, char **argv)
{
    int key;
    int semid, ret;
    union semun arg;
    int flag;

    key = ftok(".", 0x66);
    if (key < 0)
    {
        perror("ftok key error");
        return -1;
    }

    /***本程序创建了三个信号量，实际使用时只用了一个0号信号量***/
    semid = semget(key, 3, IPC_CREAT | 0600);
    if (semid == -1)
    {
        perror("create semget error");
        return -1;
    }

    if (argc == 1)
    {
        arg.val = 1;
        /***对0号信号量设置初始值***/
        ret = semctl(semid, 0, SETVAL, arg);
        if (ret < 0)
        {
            perror("ctl sem error");
            semctl(semid, 0, IPC_RMID, arg);
            return -1;
        }
    }

    /***取0号信号量的值***/
    ret = semctl(semid, 0, GETVAL, arg);
    printf("after semctl setval sem[0].val = [%d]\n", ret);
    system("date");

    printf("P operate begin\n");
    flag = P(semid, 0);
    if (flag)
    {
        perror("P operate error");
        return -1;
    }
    printf("P operate end\n");

    ret = semctl(semid, 0, GETVAL, arg);
    printf("after P sem[0].val = [%d]\n", ret);
    system("date");

    if (argc == 1)
    {
        sleep(120);
    }

    printf("V operate begin\n");
    if (V(semid, 0) < 0)
    {
        perror("V operate error");
        return -1;
    }
    printf("V operate end\n");

    ret = semctl(semid, 0, GETVAL, arg);
    printf("after V sem[0].val = %d\n", ret);
    system("date");

    if (argc > 1)
    {
        semctl(semid, 0, IPC_RMID, arg);
    }

    return 0;
}

 结果：

 生产者与消费者：

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <unistd.h>

#define BUFFER_SIZE 5
#define SEM_EMPTY 0      // 空闲缓冲区数量的信号量
#define SEM_FULL 1       // 可用资源数量的信号量

void produce(int semid) {
    struct sembuf operation;

    // 等待空闲缓冲区
    operation.sem_num = SEM_EMPTY;    // 执行操作的信号量在信号量集合中的索引
    operation.sem_op = -1;            // 对信号量进行的操作，-1 表示减少信号量值
    operation.sem_flg = SEM_UNDO;     // 操作完成后是否撤销操作
    semop(semid, &operation, 1);      // 执行信号量操作

    // 生产资源
    printf("Producing resource...\n");

    // 增加可用资源数量
    operation.sem_num = SEM_FULL;
    operation.sem_op = 1;
    operation.sem_flg = SEM_UNDO;
    semop(semid, &operation, 1);
}

void consume(int semid) {
    struct sembuf operation;

    // 等待可用资源
    operation.sem_num = SEM_FULL;
    operation.sem_op = -1;
    operation.sem_flg = SEM_UNDO;
    semop(semid, &operation, 1);

    // 消费资源
    printf("Consuming resource...\n");

    // 增加空闲缓冲区数量
    operation.sem_num = SEM_EMPTY;
    operation.sem_op = 1;
    operation.sem_flg = SEM_UNDO;
    semop(semid, &operation, 1);
}

int main() {
    int semid;
    pid_t pid;

    // 创建信号量集合
    semid = semget(IPC_PRIVATE, 2, IPC_CREAT | 0666);   // 创建一个包含2个信号量的信号量集合
    if (semid == -1) {
        perror("semget");
        exit(1);
    }

    // 初始化信号量集合
    unsigned short values[2] = {BUFFER_SIZE, 0};    // 初始信号量的值，表示初始时有BUFFER_SIZE个空闲缓冲区，0个可用资源
    if (semctl(semid, 0, SETALL, values) == -1) {    // 设置信号量集合中所有信号量的值
        perror("semctl");
        exit(1);
    }

    // 创建子进程
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(1);
    }

    if (pid == 0) {
        // 子进程作为生产者
        for (int i = 0; i < BUFFER_SIZE; i++) {
            produce(semid);
            sleep(1);
        }
    } else {
        // 父进程作为消费者
        for (int i = 0; i < BUFFER_SIZE; i++) {
            consume(semid);
            sleep(1);
        }
    }

    // 删除信号量集合
    if (semctl(semid, 0, IPC_RMID, NULL) == -1) {   // 删除信号量集合，释放资源
        perror("semctl");
        exit(1);
    }

    return 0;
}

结果：

MichstaBe#
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux进程间通信（五）：信号量 semget()、semop()、semctl()
weixin_34061482的博客
09-08 807
这篇文章将讲述别一种进程间通信的机制——信号量。注意请不要把它与之前所说的信号混淆起来，信号与信号量是不同的两种事物。有关信号的更多内容，可以阅读我的另一篇文章：Linux进程间通信 -- 信号。下面就进入信号量的讲解。 一、什么是信号量 为了防止出现因多个程序同时访问一个共享资源而引发的一系列问题，我们需要一种方法，它可以通过生成并使用令牌来授权，在任一时刻只能有一个执行线程访问代码的临界区...
semget函数 semopt 采用信号量处理多进程互斥同步
人不一定要生得漂亮，但一定要活得漂亮！
04-07 1万+
采用信号量处理多进程互斥同步       信号量与消息类似，也是进程间通信的一种方法。我们在这里讲的信号量，实际上是一个包含信号量元素数组的信号量集。信号量元素与E.W.Dijkstra提出的整数信号量相对应。在一个单系统调用中，进程可在完整的信号量集上操作。       信号量集的内部表示和各自信号量元素不是直接可以访问的，但每个信号量元素必须包括下列各项：l         一个标识信号量元素
信号量 semget函数、semop函数、semctl函数
weixin_45891985的博客
03-07 3003
semget函数 创建信号量集 int semget( key_t key, int nsems, int flag); //such as: semId = semget(key,1,IPC_CREAT|0666); if(semId == -1){ perror("semget"); return -1; } 参数 nsems 是信号量集里面的信号量的个数 参数 flag 是信号量的操作类型以及操纵权限 semop函数 函数semop用以操作一个信号量集， 通常用在
linux中与信号量有关的函数
vivilll的博客
10-08 1320
1. semget函数 semget函数的作用：创建一个新信号量或取得一个已有信号量的键。 int semget（key_t key，int num_sems，int sem_flags）； 第一个参数key是整数值，不相关的进程可以通过它访问同一个信号量。程序对所有信号量的访问都是间接的，他先提供一个键，再由系统生成一个相应的信号量标识符。 只有semget函数才直接使用信号量键，所有其
信号量 Linux函数 semget();semctl();semop();
热门推荐
顾修忠的博客
04-25 7万+
Linux进程通信之信号量 信号量(semaphore)是变量，是一种特殊的变量。它紧取正值。对信息号量的操作只有2中： 等待（wait）和发送信号（signal）. 信号量比较难理解。下面我们一个个的看一下各个函数。 与信号量处理的函数有：semget();semctl();semop(); 第一个semget（）函数，与共享内存的shmget（）函数类似。 使用格式： #incl
进程间通信机制之二：信号量
To love and to hold, till death do us apart.
08-15 816
当我们编写的程序使用了线程时，不管它是运行在多用户系统上、多进程系统上，还是运行在多用户多进程系统上，我们通常会发现，程序中存在着一部分临界代码，我们需要确保只有一个进程（或一个执行线程）可以进入这个临界代码并拥有对资源独占式的访问权。 信号量有着复杂的编程接口，但幸运的是，我
使用共享内存及信号量实现进程间通信例子
03-28
本示例代码着重于使用共享内存和信号量来解决进程间的通信和同步问题，这是一种高效且灵活的方法，特别是在多处理器和多线程环境中。下面我们将详细探讨这些概念以及它们在Linux系统中的实现。 **共享内存** 是一种...
Linux-进程间通信
10-07
5. **套接字**：套接字是跨网络通信的关键，允许不同设备间的进程通信。套接字基于IP地址和端口号标识，支持多种网络协议。它在传输层以上提供进程间通信能力。 6. **信号**：信号是进程间通信的一种快速方法，用于...
浅谈Linux进程间通信方式及优缺点
09-15
Linux提供了semget、semop和semctl等函数，用于创建、操作和控制信号量。 信号（Signal）是另一种通信方式，它更像一种异步通知机制，用于告知接收进程某个特定事件的发生。信号传递的信息量有限，但响应速度快，...
进程间通信sample
04-24
在这个“进程间通信sample”项目中，开发者使用了Linux系统下的信号量（Semaphore）来实现进程间的同步与互斥，从而确保对共享资源的正确访问。 信号量是一种同步原语，它是一个计数器，可以用来控制多个进程对共享...
linux进程间通信消息队列信号量共享内存等.pptx
10-16
2. **System V信号量**：利用`<sys/sem.h>`头文件的`semget`, `semctl`, 和 `semop`函数。信号量主要用于进程间的同步，防止多个进程同时访问共享资源，实现互斥。 3. **System V共享内存**：通过`<sys/shm.h>`...
semop异常分析
sunxiaopengsun的专栏
10-20 1895
semop 常见的异常分析 System V 信号量的P\V 操作通过函数semop实现，在使用的过程中经常会遇到一些异常，常见的如：     errno 4，Interrupted system call     errno 34，Numerical result out of range     errno 11，Resource temporarily unavailable 下面分别...
linux 信号量semget,信号量函数 semget() semop() semctl()
weixin_42423852的博客
05-15 1617
semget()可以使用系统调用semget()创建一个新的信号量集，或者存取一个已经存在的信号量集：系统调用：semget();原型：intsemget(key_t key,int nsems,int semflg);返回值：如果成功，则返回信号量集的IPC标识符。如果失败，则返回-1：errno=EACCESS(没有权限)EEXIST(信号量集已经存在，无法创建)EIDRM(信号量集已经删除)...
进程间通信
m0_64259792的博客
07-25 591
如果我们不创建一个新的信号量集，而是访问一个已经存在的信号量集，此处参数应该。ifcmd==GETALL,arg应该为一个short数组的首地址，用来保存所有信号量的值。ifcmd==SETALL,arg应该为一个short数组的首地址，用来保存所有信号量的值。//无论是P操作还是V操作，实质就是对信号量的值进行操作。ifcmd==SETVAL,arg应该为一个short的整数，用来指定该信号量的值。ifcmd==GETVAL,arg则不需要，semctl的返回值就是该信号量的值。...
semop() 函数
嵌入式
10-12 4842
这个函数用来操作sem，对信号量进行加减。 原型： int semop (int semid, struct sembuf *sops, unsigned nsops); 其中第三个参数的意思是什么？ 这要从第二个参数说起，semop这个函数可以对一群（组）信号量进行操作，所以如何表示这样一组或是一群信号量呢？ 由第二个参数来指定他们的首地址，由第三个参数来指定数量。 这里面有
Linux进程通信之信号量 控制进程同步
weixin_50803498的博客
03-26 811
信号量、信号量接口函数、semget函数、semctl函数、semop函数、ipcs 可以查看消息队列、共享内存、信号量的使用情况，使用 ipcrm 可以进行删除操作。
Linux的信号量
肖肖的博客
10-31 1662
信号量（semaphore）与已经介绍过的 IPC 结构不同，它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。 ** 1、特点 ** 1、信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。 2、信号量基于操作系统的 PV 操作，程序对信号量的操作都是原子操作。 3、每次对信号量的 PV 操作不仅限于对信号量值加 1 或减 1，而且可以加减任意正整数。 4、支持信号量组。 例子：就像一个房间，信号量相当于开门的钥匙，房间相当于连接资源（一次仅允许一个进程使用的资源；如
linux 信号量semget,信号量
weixin_32641973的博客
05-15 521
信号量实现的是课堂上“操作系统原理”里提到的经典PV操作即：点击(此处)折叠或打开semaphore s = 1;...P(s);critical code (临界区)V(s);...信号量可以近似理解为博物馆里的互动体验区：体验区有一个初始的机器数；每来一个人，机器数就减少1；每离开一个人，机器数就加1；当机器数降到0时，新来的人就必须等待有人离开才能得到机器；与互动体验区 不同的是，信号量通常...
Linux信号量编程 semget() semctl() semop()
在水一方
03-22 206
④ 如果不需要信号量，则从系统中删除它，此时使用semctl()函数的 IPC_RMID操作。需要注意的是，在程序中不应该出现对已经被删除的信号量的操作。① 创建信号量或获得在系统中已存在的信号量，此时需要调用 semget() 函数。不同进程通过使用同一个信号量键值来获得同一个信号量。② 初始化信号量，此时使用 semctl() 函数的SETVAL操作。当使用二维信号量时，通常将信号量初始化为1。③ 进行信号量的PV操作，此时，调用 semop()函数。这一步是实现进程间的同步和互斥的核心工作部分。
linux下进程信号量通信
最新发布
06-01
在Linux下，进程间通信可以使用信号量（Semaphore）实现。信号量是一种计数器，用于跟踪共享资源的使用情况。进程可以使用信号量来获取和释放共享资源，以确保多个进程之间的同步和互斥。 使用信号量进行进程间通信的一般步骤如下： 1. 创建或打开一个信号量 2. 初始化信号量的值 3. 在进程中使用信号量进行同步和互斥操作 以下是一个使用信号量进行进程间通信的示例： ``` #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> int main() { int semid; struct sembuf sb; // 创建一个信号量 semid = semget(IPC_PRIVATE, 1, IPC_CREAT | 0666); // 初始化信号量的值为1 semctl(semid, 0, SETVAL, 1); // 等待信号量 sb.sem_num = 0; sb.sem_op = -1; sb.sem_flg = 0; semop(semid, &sb, 1); // 释放信号量 sb.sem_num = 0; sb.sem_op = 1; sb.sem_flg = 0; semop(semid, &sb, 1); // 删除信号量 semctl(semid, 0, IPC_RMID); return 0; } ``` 在上面的示例中，我们使用了semget()函数创建了一个信号量，使用semctl()函数初始化了信号量的值为1，然后使用semop()函数等待和释放了信号量。最后，我们使用semctl()函数删除了信号量。 注意：在使用信号量进行进程间通信时，需要注意信号量的值的变化和各个进程之间的同步问题，否则可能会出现死锁等问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MichstaBe#

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值