• 进程间的通信终章之【消息队列，信号量，共享内存】

    文章目录

    消息队列

    概述:

    特点:

    消息队列的创建与使用

    函数接口：

    使用：

    ipcs和ipcrm用法：

    信号量

    概述:

    相关概念的认识：

    （一）进程关系

    （二）临界资源和临界区

    （三）原子操作

    （四）PV操作

    信号量接口的介绍:

    信号量的使用：

    封装系统调用:

    案例使用：

    思考：三个进程a.b,c分别输出"A","B","C",要求输出结果必须为"ABCABCABC....."

    共享内存

    概述:

    特点：

    共享内存的使用与创建

    共享内存接口介绍 ：

    案例使用：

    进程间的通信上节讲解：进程之间的通信(管道详解)

    消息队列

    概述:

    消息队列是消息的链表，存放在内存中，由内核维护。消息队列提供了一种从一个进程向另一个进程发送一个数据块的方法，这个数据块由消息类型和数据等信息组成。消息队列遵循先进先出的策略，但因为存在消息类型，有优先级，故消息队列类似于一个优先级队列。

    整个过程就好比进程A要给进程B发送消息，A进程把消息放在对应的消息队列后就可以正常返回，B进行需要读取数据时进入相应的消息队列去读取

    特点:

    1. 消息队列中的消息是由类型的。
    2. 消息队列中的消息是有格式的。
    3. 消息队列可以实现消息的随机查询。消息不一定要先进先出的次序读取，编程时可以按照消息的类型读取。
    4. 消息队列允许一个或多个进程向他写入或者读取消息。
    5. 与无名管道，命名管道一样，从消息队列中读取消息，消息队列中对应的数据会被删除。
    6. 每个消息队列都有消息队列的标识符，消息队列的标识符在整个系统中是唯一的。
    7. 只有内核重启或人工删除消息队列时，该消息队列才会被删除。若人工删除消息队列，消息队列会一直存在于系统中。

    消息队列的创建与使用

    函数接口：

    1)msgget

    1. int msgget(key_t key, int msqflg);
    2. msgget()创建或者获取一个消息队列 
    3. msgget()成功返回消息队列 ID，失败返回-1 
    4.  
    5. key值可以是人为指定的数字，强转为key_t类型即可，也可以通过ftok 函数获得。
    6. 人工指定key值:
    7. （key_t)1234;//1234就为key值，在创建获取消息队列函数的第一个参数可以这样写
    8.  
    9. 通过函数获取:
    10. # include
    11. # include
    12. key_t ftok(const char* pathname,int proj_id);
    13.              成功返回key值，失败返回-1
    14. 参数为：pathname ：路径名；
    15.        proj_id：项目ID，非0整数，只有低8位有效。
    16.  
    17. msqflg：标识函数的行为及消息队列的权限
    18. IPC_CREAT：创建消息队列
    19. IPC_EXCL：检测消息队列是否存在
    20. 位或权限位：可以设置消息队列的访问权限，和其他两个参数可以或表示,如0600，仅拥有者具有文件的读取和写入权限
    21.

    2)msgsnd

    1. int msgsnd(int msqid, const void *msqp, size_t msqsz, int msqflg); 
    2.  
    3. msgsnd()发送一条消息; 
    4.  
    5. //参数意义: 
    6. msqid:消息队列的id,因为系统中可能有多个消息队列,这id指明往哪个消息队列中添加数 据; 
    7.  
    8. msqp:往消息队列中添加的结构体,消息结构为： 
    9.  
    10. struct msgbuf 
    11.  
    12. {
    13.     long mtype; // 消息类型， 必须大于0(或者说>=1),长整型,比如图中的1,2 
    14.  
    15.     char mtext[1]; // 消息数据 ,用户自己定义,可以是任何类型;这里存放消息数据 
    16. };
    17.  
    18. msqsz： 指定 mtext 中有效数据的长度//注意仅仅只接收的数据的大小,不包含消息类 型的大小; 
    19.  
    20. msqflg：一般设置为 0 可以设置 IPC_NOWAIT 
    21.  
    22. msgsnd()成功返回0,失败返回-1;

     3)msgrcv

    1. ssize_t msgrcv(int msqid, void *msgp, size_t msqsz, long msqtyp, int msqflg); 
    2.  
    3. msgrcv()接收一条消息 
    4.  
    5. msgrcv()成功返回 mtext 中接收到的数据长度， 失败返回-1, 
    6.  
    7. msgp:接收消息的结构体,一般约定好,写入什么,接收什么结构体; 
    8.  
    9. msqsz:接收消息的大小,大于等于发送的消息大小,一般和发送的消息大小一样. 
    10.  
    11. msqtyp： 指定接收的消息类型(图中的1和2)，类型可以为 0,为0表示不区分消息类型, 按顺位接收消息; 
    12.  
    13. msqflg： 一般设置为 0 可以设置 IPC_NOWAIT

     4)msgctl

    1. int msgctl(int msqid, int cmd, struct msqid_ds *buf); 
    2.  
    3. msgctl()控制消息队列,也就是对消息队列做一个控制,可以设置消息队列,也可以移除消息队列; 
    4.  
    5. msgctl()成功返回 0，失败返回-1 
    6.  
    7. msqid:消息标识符，即由msgget返回的消息队列表示码
    8.  
    9. cmd
    10. （1）IPC_STAT：把msqid_ds结构体中个元素的当前值存入到由buf指向的结构体中。
    11. （2）IPC_SET：把msqid结构体中的元素设置为buf中的对应值。
    12. （3）IPC_RMID：从系统中删除该消息队列以及仍在该队列中的所有数据，这种删除立即生效。
    13.  
    14. buf:设置或者获取消息队列需要的一个结构体,如果删除就直接给一个NULL;
    15. msgctl(msgid,IPC_RMID,NULL);
    16. 消息队列在内存中创建;

    使用：

    进程a发送一条消息,进程b读取消息;

    利用消息队列进行进程间通讯的方式，我们可以类比为：A需要发送信息给B，但是因为距离原因当面给A，那么就需要A先把信息给XX地址的SS驿站，驿站将其存储，存储箱编号为YYYYY，B要取出这个信息，必须到XX地址的SS驿站取出编号为YYYYY的箱子，打开才可以获取。

    在消息队列中，键（key）值相当于XX地址，消息队列标识符相当于SS驿站，消息类型相当于YYYYY编号的箱子。

    同一个键（key)值可以保证是同一个消息队列，同一个消息队列标识符才能保证不同进程可以相互通信，同一个消息类型才能保证某个进程取出的是对方的信息。

    1. a.c
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8.  
    9.  
    10. struct mess
    11. {
    12.     long type;
    13.     char buff[128];
    14. };
    15. int main()
    16. {
    17.    int msgid= msgget((key_t)1234,IPC_CREAT|0600);//自己指定的key值，也可以通过ftok获取
    18.    assert(msgid!=-1);
    19.    struct mess dt;
    20.    dt.type=1;
    21.    strcpy(dt.buff,"hello1");
    22.  
    23.    //发送消息
    24.    msgsnd(msgid,&dt,128,0);
    25.    exit(0);
    26. }
    1. b.c
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8.  
    9.  
    10. struct mess
    11. {
    12.     long type;
    13.     char buff[128];
    14. };
    15. int main()
    16. {
    17.    int msgid= msgget((key_t)1234,IPC_CREAT|0600);
    18.    assert(msgid!=-1);
    19.    struct mess dt;
    20.    //接收
    21.    msgrcv(msgid,&dt,128,1,0);
    22.    printf("%s",dt.buff);
    23.  
    24.    exit(0);
    25. }

    发送三次消息，读两次

     将b.c接收处改为IPC_NOWAIT,没有消息不等待，即使没有消息队列，里面也不会阻塞

    1. if( msgrcv(msgid,&dt,128,1,IPC_NOWAIT)==-1)
    2.   {
    3.       printf("no mess");
    4.   }
    5.   else
    6.    printf("%s",dt.buff);

    ipcs和ipcrm用法：

    ipcs用法

    1. ipcs==ipcs -a 是默认的输出信息 打印出当前系统中所有的进程间通信方式的信息
    2. ipcs -m 打印出使用共享内存进行进程间通信的信息
    3. ipcs -q 打印出使用消息队列进行进程间通信的信息
    4. ipcs -s 打印出使用信号进行进程间通信的信息

    输出格式的控制

    1. ipcs -t 输出信息的详细变化时间
    2. ipcs -p 输出ipc方式的进程ID ipcs -c 输出ipc方式的创建者/拥有者
    3. ipcs -c 输出ipc各种方式的在该系统下的限制条件信息
    4. ipcs -u 输出当前系统下ipc各种方式的状态信息(共享内存，消息队列，信号)

    ipcrm 命令

    移除一个消息对象。或者共享内存段，或者一个信号集，同时会将与ipc对象相关链的数据也一起移除。当然，只有超级管理员，或者ipc对象的创建者才有这项权利啦

    ipcrm用法

    1. ipcrm -M shmkey 移除用shmkey创建的共享内存段
    2. ipcrm -m shmid 移除用shmid标识的共享内存段
    3. ipcrm -Q msgkey 移除用msqkey创建的消息队列
    4. ipcrm -q msqid 移除用msqid标识的消息队列
    5. ipcrm -S semkey 移除用semkey创建的信号
    6. ipcrm -s semid 移除用semid标识的信号
    7. ipcrm -a 删除所有进程间通信资源

    信号量

    概述:

    信号量就是控制某个进程能够对某个资源进行访问;保证同一时刻只能由一个进程对某个资源进程访问; 信号量主要用于进程或线程的同步和互斥

    信号量是一个特殊的变量，一般取正数值。它的值代表允许访问的资源数目， 获取资源时，需要对信号量的值进行原子减一，该操作被称为 P 操作。

    当信号量值为 0时，代表没有资源可用， P 操作会阻塞。释放资源时，需要对信号量的值进行原子

    加一，该操作被称为 V操作。

    信号量的值如果只取0,1：将其称为二值信号量。

    如果信号量的值大于 1：则称之为计数信号量。

    相关概念的认识：

    （一）进程关系

    1.进程同步：进程之间相互合作，协同工作的关系称为进程的同步。简单来说就是多个相关进程在执行次序上的协调，谁先执行后执行都有顺序。是一种直接制约关系。
    2.进程互斥：多个进程因为争夺临界资源而互斥执行称为进程的互斥。是一种间接制约关系。

    比如多个人打篮球，篮球是临界资源，形成互斥，对他们形成了一个间接制约关系。工厂上流水线工作，一道工序接着下一道，有明确的次序，形成同步，上一道的工序对下一道工序有直接影响，是一种直接制约关系。

    （二）临界资源和临界区

    1.临界资源：在操作系统中，把那些可以被进程共享的资源（文件，打印机等），但是在同一时刻只允许一个进程/线程访问的资源统称为临界资源或共享变量。
    2.临界区：访问临界资源的那段代码。

    （三）原子操作

    原子操作是指不会被进程/线程调度机制打断的操作，这种操作一旦开始，就一直运行到结束，中间不会有任何进程切换。故原子操作要不然不做，要不然一直做到结束。

    （四）PV操作

    P(SV)：如果SV的值大于1，进行减一操作，表示获得资源；如果SV的值为0，则挂起进程的执行，即阻塞，因为目前已经没有资源了。
    V(SV）：如果当前有挂起的进程在等待资源，那么执行V就会将它唤醒；如果没有，SV加一，即释放资源。
    P操作会出现阻塞，V操作永远不会阻塞。


    信号量接口的介绍:

    (1)semget创建/获取信号量集合

    1. int semget(key_t key,int nsems,int semflg);
    2.  
    3. 创建或者获取一个已经存在的信号量;
    4.  
    5. key:两个进程使用相同的key值,就可以使用同一个信号量;
    6.  
    7. nsems:创建几个信号量;
    8.  
    9. semflg:标志位;如果为创建:IPC_CREAT;
    10.              IPC_EXCL:检测信号量集合是否存在
    11.              位或权限位:可以设置信号量集合的访问权限，和其他两个参数可以或表示 
    12.  
    13. //运行的时候:./a& ./b&
    14.  
    15. 如果为全新创建,也就是不知道是否有人创建过,则IPC_CREATE|IPC_EXCEL,就是如果
    16.  
    17. 没有则创建,如果有则创建失败 ;

    (2)semop:操作信号量

    1. int semop(int semid,struct sembuf *sops,unsigned nsops); 
    2.  
    3. 对信号量进行改变,做P操作或者V操作;
    4.  
    5. semid:信号量的id号,也就是刚才semget的返回值;说明对哪个信号量进行操作;
    6.  
    7. sops:结构体指针,指向sembuf的结构体指针,
    8.  
    9. sembuf结构体有三个成员变量:
    10. sem_num表示信号量的编号(即指定信号量集中的信号量下标);
    11. sem_op表示是p还是v操作;1为v操作(加1),-1为p操作(减1);
    12. 若此时已经没有资源了进行-1操作：
    13. 如果指定了IPC_NOWIT，会出错返回。
    14. 未指定，进程会被挂起，知道有资源或捕捉到信号结束挂起。
    15.  
    16. sem_flg为标志位; 
    17. struct sembuf{
    18.      unsigned short sem_num;//信号量ID
    19.      short          sem_op; //信号量操作
    20.      short          sem_flg;//操作标志
    21. }；

     (3)semctl: 设置信号量集合

    1. int semctl(int semid,int semnum,int cmd,...); 
    2.  
    3. 对信号量进行控制:初始化/删除信号量
    4.  
    5. semid:信号量id;
    6.  
    7. semnum:信号量编号;
    8.  
    9. cmd:命令:SETVAL:初始化信号量; IPC_RMID:删除信号量;
    10.  
    11. **注意**:联合体semun,这个联合体需要自己定义;
    12. union semun{
    13.    int              val;   //信号量的值
    14.    struct semid_ds* buf;   // ipc_stat,ipc_set的缓冲区
    15.    unsigned short* array;  //SETALL,GETALL数组
    16.    struct seminfo* _buf;   //ipc_info缓冲区(Linux专用) 
    17. };

    信号量的使用：

    封装系统调用:

    在进行进程同步控制时，经常说到P、V操作，那么如何用上述的系统调用封装一系列的函数，让我们使用起来方便。根据需求我们将其分为4类函数：创建/获取信号量；P操作；V操作；删除信号集合。我们将表示信号量信息的union semun联合体（因为业务简单，所以联合体中只包含信号量的值val即可）和函数声明写在自己创建的.h文件中。

    1. # include
    2. # include
    3. # include
    4. # include
    5. # include
    6.  
    7.  
    8. //保存信号量值的联合体
    9. union semval
    10. {
    11.     int val;
    12. };
    13. //创建/获得信号量集合
    14. int CreateSem(int key,int init_val[],int len);
    15. //减1操作
    16. void SemP(int semid,int index);
    17. //加1操作
    18. void SemV(int semid,int index);
    19. //删除信号量集合
    20. void DeleteSem(int semid);
    21.

    具体操作实现:

    1. # include
    2. # include
    3. # include
    4. # include
    5. # include
    6. # include
    7. # include "sem.h"
    8.  
    9. //创建/获得信号量集合
    10. int CreateSem(int key,int init_val[],int len)
    11. {
    12.     //
    13.     int semid=semget((key_t)key,0,0664);
    14.     if(semid!=-1)
    15.     {
    16.         return semid;
    17.     }
    18.     //
    19.     semid=semget((key_t)key,len,IPC_CREAT|0664);
    20.     if(semid==-1)
    21.     {
    22.         perror("Create Sem Error\n");
    23.         return -1;
    24.     }
    25.     //
    26.     int i=0;
    27.     for(;i
    28.     {
    29.         union semval data;
    30.         data.val=init_val[i];
    31.         if(semctl(semid,i,SETVAL,data)==-1)
    32.         {
    33.             perror("Init Sem Value Fail\n");
    34.             return -1;
    35.         }
    36.     }
    37.     return semid;
    38. }
    39. //减1操作
    40. void SemP(int semid,int index)
    41. {
    42.     struct sembuf buf;
    43.     buf.sem_num=index;
    44.     buf.sem_op=-1;//
    45.     buf.sem_flg=SEM_UNDO;
    46.  
    47.     if(semop(semid,&buf,1)==-1)
    48.     {
    49.         perror("Sem P Error\n");
    50.     }
    51. }
    52. //加1操作
    53. void SemV(int semid,int index)
    54. {
    55.     struct sembuf buf;
    56.     buf.sem_num=index;
    57.     buf.sem_op=1;
    58.     buf.sem_flg=SEM_UNDO;
    59.     if(semop(semid,&buf,1)==-1)
    60.     {
    61.         perror("Sem V Error\n");
    62.     }
    63. }
    64. //删除信号量集合
    65. void DeleteSem(int semid)
    66. {
    67.     if(semctl(semid,0,IPC_RMID)==-1)
    68.     {
    69.         perror("Delete Error\n");
    70.     }
    71.  
    72. }
    73.

    案例使用：

    例题： 进程a和进程b模拟访问打印机，进程a输出第一个字符’a’表示开始使用打印机，输出第二个字符‘a’表示结束打印机；b进程的操作和a进程相同，每个进程循环使用打印机5次。现在打印机为临界资源，所以在某一时刻它只能被一个进程使用，所以输出的结果不应该出现：abab，abba等情况。
    采取信号量进行同步控制：
    打印机输入临界资源，那么设定一个信号量来管理打印机：

    • 它只有一台，所以初始值为1，在a进程使用时，我们对其进行一个P操作，即让a获取打印机，此时信号量为0，如果b来访问就会被挂起。
    • 在a使用完打印机后，我们释放打印机资源，进行V操作，这是信号量为1，b进程这时就可以访问打印机，b也是一样的，访问前进行一次P操作获取，打印完毕进行一次V操作释放。
    1. a.c
    2. # include
    3. # include
    4. # include
    5. # include
    6. # include
    7. # include
    8. # include "sem.h"
    9.  
    10. int main()
    11. {
    12.     int val=1;//信号量初始值
    13.     int semid=CreateSem(1234,&val,1);//a先运行，创建信号集合IDkey为1234，值为1，1个信号量的信号集合
    14.     assert(semid!=-1);
    15.  
    16.     int count=0;//使用打印机次数
    17.  
    18.     while(1)
    19.     {
    20.         SemP(semid,0);//P，占有打印机
    21.         printf("a\n");
    22.         sleep(5);
    23.         printf("a\n");
    24.         SemV(semid,0);//V，释放打印机
    25.         sleep(2);
    26.         count++;
    27.         if(count==5)
    28.         {
    29.             break;
    30.         }
    31.     }
    32.     exit(0);
    33. }
    34.  
    1. b.c
    2. # include
    3. # include
    4. # include
    5. # include
    6. # include
    7. # include
    8. # include "sem.h"
    9.  
    10. int main()
    11. {
    12.     int val=1;//信号量初始值
    13.     int semid=CreateSem(1234,&val,1);//b后运行，直接获取到信号量
    14.     assert(semid!=-1);
    15.  
    16.     int count=0;//使用打印机次数
    17.  
    18.     while(1)
    19.     {
    20.         SemP(semid,0);//P，占有打印机
    21.         printf("b\n");
    22.         sleep(5);
    23.         printf("b\n");
    24.         SemV(semid,0);//V，释放打印机
    25.         sleep(2);
    26.         count++;
    27.         if(count==5)
    28.         {
    29.             break;
    30.         }
    31.     }
    32.     exit(0);
    33. }
    34.  
    1. 编译运行
    2. gcc -o a a.c sem.c 
    3. gcc -o b b.c sem.c

    我们观察结果，发现没有出现abab这种a，b进程混乱使用打印机的现象，都是a/b进程打印完了，释放资源，a/b进程再进行获取打印。

    思考：三个进程a.b,c分别输出"A","B","C",要求输出结果必须为"ABCABCABC....."

    信号量用于同步：有多少个任务就需要多少个信号量。最先 执行的任务对应的信号量为1，其他信号量全为0，每个任务先p自己，v下一个任务的信号量

    共享内存

    概述:

    共享内存为多个进程之间共享和传递数据提供了一种有效的方式。共享内存是先在物理内存申请一块空间，多个进程可以将其映射到自己的虚拟地址空间中。所有进程都可以访问共享内存中的地址，就好像他们都是由malloc分配一样。如果某个进程向共享内存写入了数据，所做的改动将立即可被访问同一段共享内存的任何其他进程看到。

    由于他并未提供同步机制，也就是说，在第一个进程结束对共享内存的写操作之前，并无自动机制可以阻止第二个进程开始对它进行读取。所以我们通常需要用其他的机制来同步对共享内存的访问。例如前面说到的信号量

    特点：

    注意：共享内存区是最快的IPC形式。一旦这样的内存映射到共享它的进程的地址空间，这些进程间数据传递不再涉及到内核，换句话说是进程不再通过执行进入内核的系统调用来传递彼此的数据。

    管道和消息队列需要四次数据拷贝：因为管道和消息队列进行共享的空间都是由内核对象提供管理，所执行的操作也都是系统调用，而这些数据最终还是要在内存中存储的。管道使用数组来保存数据，利用write，read系统调用将数据写入/读取；消息队列使用自定义消息结构体保存数据，利用msgsnd，msgrcv将数据保存/读取到内核中。我们画出管道的拷贝过程：

     过程分别是：

    • 从内存空间缓冲区将数据拷贝到内核空间缓冲区。
    • 从内核缓冲区将数据拷贝到内存
    • 从内存将数据拷贝到内核空间缓冲区
    • 从内核空间缓冲区将数据拷贝到用户空间缓冲区。

    而共享内存使用相关函数，在内存中开辟一块空间，映射到不同进程的虚拟地址空间，并且向用户返回指向该块内存的指针，因此对该内存可通过指针直接访问，只需要两次：

    过程为： 

    • 从用户空间缓冲区拷贝数据到内存。
    • 从内存拷贝数据到用户空间缓冲区。

    共享内存的使用与创建

    共享内存接口介绍 ：

    (1)shmget

     (2)shmat

     (3)shmdt

     (4)shmctl

    1. buf：内核为每个共享内存创建的结构体shmid_ds
    2. struct shmid_ds {
    3.      struct ipc_perm shm_perm;   //用户权限
    4.      size_t          shm_segsz;  //共享内存大小
    5.      time_t          shm_atime;  //最后一次连接时间
    6.      time_t          shm_dtime;  //最后断开连接时间
    7.      time_t          shm_ctime;  //最后改变事件
    8.      pid_t           shm_cpid;   //PID
    9.      pid_t           shm_lpid;   //最后一个PID
    10.      shmatt_t        shm_nattch; //多少个进程正在使用这个共享存储
    11. }；

    案例使用：

    题目： 两个进程，A进程将获取到的用户数据写入内存，B进程打印共享内存中的数据。

    如果我们不对这块共享内存进行同步控制，就会出现读取混乱的问题，会出现A写入的数据还没有被B读，A又重新写入了等问题，所以我们必须要对这块内存进行一个同步控制，就采用信号量来控制，我们分析一下，如何控制A，B才可以实现：
    A写数据时，B不能读数据；B读数据时，A不能写数据，B进程只有在A写入数据后才可读取数据，A只有在B取出数据后才可以继续发数据。

    可以看到A对B有影响，B对A有影响。故需要两个信号量控制，sem1控制A，sem2控制B。信号量初始值的考虑：运行程序，A进程先写入数据，B进程处于阻塞状态，故sem1=1，sem2=0

    图示：

     完整过程：

    1. 先进行shmget函数对内存空间的创建和初始化，再连接共享内存，用ptr保存shmat连接到的内存地址。
    2. 信号量的创建，初始化。
    3. 进行循环读取数据，对sem1信号量P操作，进行数据的写入，写完之后对sem2信号量V操作。B进程这一块相反，
    4. shmdt断开共享内存连接。
    5. shcmtl删除共享内存
    1. //sem.h
    2. //两个信号量
    3. #include
    4. #include
    5. #include
    6. #define SEM1 0
    7. #define SEM2 1
    8. #define SEM_MAX 2
    9. union  semun
    10. {
    11. 	int val;
    12. };
    13. void sem_init();
    14. void sem_p(int index); //对哪个信号量进行操作
    15. void sem_v(int index);
    16. void sem_destroy();
    1. //sem.c
    2. #include"sem.h"
    3. static int semid = -1;
    4.  
    5. void sem_init()
    6. {
    7. 	semid = semget((key_t)1234, SEM_MAX, IPC_CREAT | IPC_EXCL | 0600);//全新创建
    8. 	if (semid == -1)
    9. 	{
    10. 		semid = semget((key_t)1234, SEM_MAX, 0600);//获取
    11. 		if (semid == -1)
    12. 		{
    13. 			printf("create sem failed!\n");
    14. 		}
    15. 		else
    16. 		{
    17. 			//初始化
    18. 			union semun a;
    19. 			int arr[SEM_MAX] = { 1,0 };
    20. 			for (int i = 0; i < SEM_MAX; ++i)//初始化两个信号
    21. 			{
    22. 				a.val = arr[i];
    23. 				if (semctl(semid, i, SETVAL, a) == -1)
    24. 				{
    25. 					printf("semctl setval failed!\n");
    26. 				}
    27. 			}
    28. 			
    29. 		}
    30. 	}
    31. }
    32. void sem_p(int index)
    33. {
    34. 	if (index < 0 || index >= SEM_MAX)
    35. 	{
    36. 		return;
    37. 	}
    38. 	struct sembuf a;
    39. 	a.sem_num = index;
    40. 	a.sem_op = -1;//p操作
    41. 	a.sem_flg = SEM_UNDO;
    42. 	if (semop(semid, &a, 1) == -1)
    43. 	{
    44. 		perror("p error\n");
    45. 	}
    46. }
    47. void sem_v(int index)
    48. {
    49. 	if (index < 0 || index >= SEM_MAX)
    50. 	{
    51. 		return;
    52. 	}
    53. 	struct sembuf a;
    54. 	a.sem_num = index;
    55. 	a.sem_op = 1;//v操作
    56. 	a.sem_flg = SEM_UNDO;
    57. 	if (semop(semid, &a, 1) == -1)
    58. 	{
    59. 		perror("v error\n");
    60. 	}
    61. }
    62. void sem_destroy()
    63. {
    64. 	if (semctl(semid, 0, IPC_RMID) == -1)
    65. 	{
    66. 		perror("destroy sem error\n");
    67. 	}
    68. }
    1. //w.c写数据
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include"sem.h"
    9.  
    10. int main()
    11. {
    12. 	int shmid=shmget((key_t)1234, 256, IPC_CREAT | 0600);//获取
    13. 	assert(shmid != -1);
    14. 	char* s = (char*)shmat(shmid, NULL, 0);//映射
    15. 	if (s == (char*)-1)
    16. 	{
    17. 		exit(1);
    18. 	}
    19. 	sem_init();
    20. 	while (1)
    21. 	{
    22. 		printf("input:\n");
    23. 		char buff[128] = {0};
    24. 		fgets(buff, 128, stdin);
    25. 		sem_p(SEM1);
    26. 		strcpy(s, buff);
    27. 		sem_v(SEM2);
    28. 		if (strncmp("buff", "end", 3) == 0)
    29. 		{
    30. 			break;
    31. 		}
    32. 	}
    33. 	shmdt(s);//断开
    34. 	exit(0);
    35.  
    36. }
    1. //r.c读数据
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include"sem.h"
    9.  
    10. int main()
    11. {
    12. 	int shmid = shmget((key_t)1234, 256, IPC_CREAT | 0600);//获取
    13. 	assert(shmid != -1);
    14. 	char* s = (char*)shmat(shmid, NULL, 0);//映射
    15. 	if (s == (char*)-1)
    16. 	{
    17. 		exit(1);
    18. 	}
    19. 	sem_init();
    20. 	while (1)
    21. 	{
    22. 		sem_p(SEM2);
    23. 		if (strncmp(s, "end", 3) == 0)
    24. 		{
    25. 			break;
    26. 		}
    27. 		printf("read:%s\n", s);
    28. 		sem_v(SEM1);
    29. 	}
    30. 	shmdt(s);//删除共享内存
    31. 	sem_destroy();//销毁信号量
    32. 	shmctl(shmid, IPC_RMID, NULL);
    33. 	exit(0);
    34.  
    35. }

     进程的更新就到这了，感谢观看！

  • 相关阅读:
    51单片机-让一个LED灯闪烁、流水灯（涉及：设置单片机的延迟函数）
    source insight4菜单工具按钮变乱恢复
    kafka安装
    4.多层感知机-3GPT版
    9.5-9.9 小知识点
    结构体与共用体
    ChatGPT与码农的机会
    Codeforces Round #835 (Div. 4)
    redis 哨兵，高可用的执行者
    JavaScript:实现弧度到度算法 （附完整源码）
  • 原文地址：https://blog.csdn.net/weixin_51609435/article/details/126164984