• yo！这里是进程间通信

    目录

    前言

    进程间通信简介

    目的

    分类

    匿名通道 

    介绍

    举例（进程池）

    命名管道

    介绍

    举例

    共享内存

    介绍

    共享内存函数

    1.shmget

    2.shmat

    3.shmdt

    4.shmctl 

    举例

    1.框架

    2.通信逻辑

    消息队列

    信号量

    同步与互斥

    理解信号量 

    后记

    前言

            之前介绍到进程说过，进程具有独立性，也就是说两个进程之间没有相交的部分，没有共享的部分，那如何实现标题所说的通信呢？我们一定能先想到，一方将信息放到某个地方，然后另一方去拿，这不就实现了所谓的通信了，实际也是这样，进程间通信就是让两个或多个进程看到同一块资源（空间），对应的实现也是有很多种。其中，在本文我们详细介绍匿名管道、命名管道、共享内存，简单介绍消息队列、信号量，快往下看看吧！

    进程间通信简介

    • 目的

            进程间通信的目的，包括数据传输、共享资源、通知、进程控制。其中，

    数据传输：一个进程需要发送给另一个进程一些数据；

    共享资源：多个进程之间共享同一份资源；

    通知：一个进程需要通知另一个或多个进程发生了某个事件（如进程终止时要通知父进程）；

    进程控制：有些进程可以控制另一个进程的执行（如Debug进程），此时控制进程能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

    • 分类

            进程间通信的方法分类大致可以分为三类，包括管道、System V IPC(进程间通信InterProcess Communication)、POSIX IPC。

    其中，

    管道：

            匿名管道

            命名管道

    System V IPC：

            System V 消息队列

            System V 共享内存

            System V 信号量

    POSIX IPC：

            消息队列

            共享内存

            信号量

            互斥量

            条件变量

            读写锁

            对于System V IPC，侧重于本地通信，也就是一台机器上的多个进程进行通信；对于POSIX IPC，其将网络通信纳入到进程间通信，既能本地通信，又能远程通信。下面我们将详细介绍管道、System V 共享内存，简单介绍System V 消息队列、System V 信号量。

    匿名通道 

    • 介绍

            首先，我们把一个进程连接到两一个进程的一个数据流叫做管道，匿名管道就是之前所用的【 | 】，比如将当前路径信息输入到draft.txt文件中，如下图：

    但这是指令实现的管道，代码如何实现呢？如下：

            其中，pipefd是一个文件描述符数组，里面可以放两个文件描述符，pipefd[0]表示读端，pipefd[1]表示写端；返回值：成功返回0，否则返回-1，且设置errno。

    注意：

            pipefd数组是一个输出型参数，我们传入一个空数组，函数内会将打开的读写fd对应放入数组内带出，函数外就可以通过pipefd[0]、pipefd[1]从写端向读端传输数据，如下图可方便理解：

    • 举例（进程池）

            进程池就是父进程fork出多个子进程，使用进程间通信的方法父进程向子进程发送任务，子进程完成任务返回给父进程。对于父进程fork出来的一个子进程，父进程使用管道文件与子进程进行通信的原理如下：

            对于进程池中父进程通信多个子进程的原理亦是如此，看如下代码实现。

    主函数框架：

             进程池首先需要一个vector记录创建的所有子进程，父进程发送任务可随机选择子进程执行任务，接下来就是创建多个子进程和对应管道，将每个子进程的写端关闭，然后子进程就是等待父进程派发任务；对于父进程，在关闭读端之后，开始派发任务，依旧是面向用户的一个菜单，框架与以前写的游戏菜单一样，用户可以选择菜单上的选项进行操作，用户操作结束以后，紧接着关闭所有的fd以及父进程等待接收子进程，以免子进程成为僵尸进程。

    代码：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include "Task.hpp"
    8.  
    9. #define PROCESS_NUM 5
    10.  
    11. int main()
    12. {
    13.     vectorpid_t, int>> process_vec;
    14.  
    15.     // 创建多个子进程
    16.     for (int i = 0; i < PROCESS_NUM; i++)
    17.     {
    18.         // 创建管道 //注意：管道创建要在循环里面
    19.         int pipefd[2] = {0};
    20.         int res = pipe(pipefd);
    21.         assert(res == 0);
    22.  
    23.         pid_t id = fork();
    24.         if (id == 0)
    25.         {
    26.             // 子进程：读，关闭写
    27.             close(pipefd[1]);
    28.             while (true)
    29.             {
    30.                 //接收任务
    31.             }
    32.             exit(1);
    33.         }
    34.         // 父进程：写，关闭读
    35.         close(pipefd[0]);
    36.         process_vec.push_back(make_pair(id, pipefd[1])); //记录进程
    37.     }
    38.  
    39.     // 派发任务
    40.     int select;
    41.     srand((unsigned int)time(nullptr));
    42.     do
    43.     {
    44.         usleep(100000);
    45.         printf("**************************************************\n");
    46.         printf("***   0.quit   1.show tasks   2.execute task   ***\n");
    47.         printf("**************************************************\n");
    48.         printf("请输入：\n");
    49.         cin >> select;
    50.         if (select == 0)
    51.         {
    52.             printf("退出成功\n");
    53.         }
    54.         else if (select == 1)
    55.         {
    56.             //显示任务
    57.         }
    58.         else if (select == 2)
    59.         {
    60.             //发送任务
    61.         }
    62.         else
    63.         {
    64.             printf("输入有误\n");
    65.         }
    66.     } while (select);
    67.  
    68.     //关闭所有fd
    69.  
    70.     //接受收进程
    71.  
    72.     return 0;
    73. }

     任务（Task.hpp）：

            首先将所有任务实现在这个头文件中，这里仅有task0、1、2、3四个任务，创建一个vector存储这些任务，此外，再创建一个map存储这些任务的序号和对应介绍（这里只显示名称），以便于主函数菜单中的任务显示（ShowTask()函数），而TaskLoad()函数是在完成vector和map的填充。

    代码：

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. using namespace std;
    11.  
    12. typedef function<void()> task; //c++11中提出，作为函数指针的平替
    13. vector task_vec;
    14. map<int,string> task_info;
    15.  
    16. void task0()
    17. {
    18.     printf("进程[%d]正在执行任务0\n");
    19. }
    20. void task1()
    21. {
    22.     printf("进程[%d]正在执行任务1\n");
    23. }
    24. void task2()
    25. {
    26.     printf("进程[%d]正在执行任务2\n");
    27. }
    28. void task3()
    29. {
    30.     printf("进程[%d]正在执行任务3\n");
    31. }
    32.  
    33. void TaskLoad()
    34. {
    35.     task_info.insert(make_pair(task_vec.size(),"task0"));
    36.     task_vec.push_back(task0);
    37.     
    38.     task_info.insert(make_pair(task_vec.size(),"task1"));
    39.     task_vec.push_back(task1);
    40.  
    41.     task_info.insert(make_pair(task_vec.size(),"task2"));
    42.     task_vec.push_back(task2);
    43.  
    44.     task_info.insert(make_pair(task_vec.size(),"task3"));
    45.     task_vec.push_back(task3);
    46. }
    47.  
    48. void ShowTasks()
    49. {
    50.     for(auto i:task_info)
    51.     {
    52.         cout<":"<
    53.     }
    54. }

    主函数细节：

            首先就是要主函数中上传任务（TaskLoad()）；对于父进程的执行任务模块，随机采用子进程将任务序号write到管道中，对于子进程的接收任务模块，则是封装了一个函数，以实现如果父进程不发送任务，就堵塞的情形，在函数中，子进程去read管道中的数据，接收任务序号，再调用对应任务即可；对于最后的收尾工作，包括关闭所有fd、接收子进程，很简单，如代码所示。

    代码：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include "Task.hpp"
    8.  
    9. #define PROCESS_NUM 5
    10.  
    11. bool ReceiveTask(int fd,int& task_no)
    12. {
    13.     ssize_t n=read(fd,&task_no,sizeof(task_no));
    14.     if(n!=sizeof(int)) //保证接收的数据是int大小的字节数
    15.         return false;
    16.     return true;
    17. }
    18.  
    19. int main()
    20. {
    21.     vectorpid_t, int>> process_vec;
    22.     TaskLoad();
    23.     // 创建多个子进程
    24.     for (int i = 0; i < PROCESS_NUM; i++)
    25.     {
    26.         // 创建管道 //注意：管道创建要在循环里面
    27.         int pipefd[2] = {0};
    28.         int res = pipe(pipefd);
    29.         assert(res == 0);
    30.  
    31.         pid_t id = fork();
    32.         if (id == 0)
    33.         {
    34.             // 子进程：读，关闭写
    35.             close(pipefd[1]);
    36.             while (true)
    37.             {
    38.                 //接收任务
    39.                 int task_no=0;
    40.                 bool res=ReceiveTask(pipefd[0], task_no);//封装函数意义：如果父进程不发，就堵塞
    41.                 if(!res)
    42.                     break;
    43.                 if(task_no<0||task_no>=task_vec.size())
    44.                     printf("输入有误\n");
    45.                 else
    46.                     task_vec[task_no]();
    47.             }
    48.             exit(1);
    49.         }
    50.         // 父进程：写，关闭读
    51.         close(pipefd[0]);
    52.         process_vec.push_back(make_pair(id, pipefd[1]));
    53.     }
    54.  
    55.     // 派发任务
    56.     int select;
    57.     srand((unsigned int)time(nullptr));
    58.     do
    59.     {
    60.         usleep(100000);
    61.         printf("**************************************************\n");
    62.         printf("***   0.quit   1.show tasks   2.execute task   ***\n");
    63.         printf("**************************************************\n");
    64.         printf("请输入：\n");
    65.         cin >> select;
    66.         if (select == 0)
    67.         {
    68.             printf("退出成功\n");
    69.         }
    70.         else if (select == 1)
    71.         {
    72.             ShowTasks();
    73.         }
    74.         else if (select == 2)
    75.         {
    76.             int task_no;
    77.             int i = rand() % task_vec.size();
    78.             printf("请输入：");
    79.             cin >> task_no;
    80.             write(process_vec[i].second, &task_no, sizeof(task_no));
    81.         }
    82.         else
    83.         {
    84.             printf("输入有误\n");
    85.         }
    86.     } while (select);
    87.  
    88.     //关闭所有fd
    89.     for(auto i:process_vec)
    90.     {
    91.         close(i.second);
    92.     }
    93.     //接受收进程
    94.     for(auto i:process_vec)
    95.     {
    96.         int ret=waitpid(i.first,nullptr,0);
    97.     }
    98.     return 0;
    99. }

    运行：

            通过以上对匿名管道的理解，我们可以发现，管道是具有访问控制的，以下就是其读写规则，即

    ①当没有数据可以读时，即写的慢，读的快，read调用阻塞，即进程暂停执行，一直等到有数据来到为止；

    ②当管道满了时，即写的快，读的慢，write调用阻塞，直到有进程读走数据；

    ③如果所有管道写端对应的文件描述符被关闭，则read返回0，表示读到了管道文件末尾；

    ④如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE，进而可能导致write进程退出。

            我们也可以总结出匿名管道的特点，如下：

    ① 只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常，一个管道由一个进程创建，然后该进程调用fork，此后父子进程之间就可应用该管道；

    ②管道提供流式服务，这与协议有关，后面再说；

    ③一般而言，进程退出，管道释放，所以管道的生命周期随进程；

    ④一般而言，内核会对管道操作进行同步与互斥，即提供了访问控制；

    ⑤管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道。

    命名管道

    • 介绍

            对于匿名管道，很大的一个缺点就是只能在具有公共祖先（如父子进程）的进程间通信，若想要在不相关的进程间通信，下面要讲到的命名管道（FIFO文件）就是方法之一。命令行实现：mkfifo filename，举例如下图：

    代码实现：

    • 举例

            对于服务端，首先是通过mkfifo函数创建命名管道（fifo文件），接着使用open系统调用打开此文件，下面就可以接收用户端的信息了，这里将接收信息封装成了一个函数getMessage()，而且创建了多个子进程来随机接收任务，最后就是收尾工作，包括父进程接收子进程的、关闭管道文件以及删除管道文件；对于getMessage函数，首先创建一个缓冲区存放用户端发送的信息，接着下面是个循环接收信息的过程，通过read系统调用将信息存放至缓冲区内，这里注意对read的返回值分情况讨论，当读到文件末尾时将不再继续读取，break退出。

    代码（server）：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. using namespace std;
    10.  
    11. #define FIFONAME "mypipe"
    12. #define FIFOMODE 0666
    13.  
    14. void getMessage(int fd)
    15. {
    16.     char buffer[1024];
    17.     while (true)
    18.     {
    19.         memset(buffer, '\0', sizeof(buffer));
    20.         ssize_t n = read(fd, buffer, sizeof(buffer) - 1);//后续对n的分情况处理较为重要
    21.         if(n>0)
    22.         {
    23.             printf("client[%d]>%s\n", getpid(),buffer);
    24.         }
    25.         else if(n==0)//读到了文件结尾
    26.         {
    27.             break;
    28.         }
    29.         else{
    30.             perror("read");
    31.             break;
    32.         }
    33.     }
    34. }
    35.  
    36. int main()
    37. {
    38.     // 创建命名管道
    39.     int res = mkfifo(FIFONAME, FIFOMODE);
    40.     if (res < 0)
    41.     {
    42.         perror("mkfifo");
    43.         exit(1);
    44.     }
    45.     printf("创建管道文件成功\n");
    46.     
    47.     // 打开管道文件
    48.     int fd = open(FIFONAME, O_RDONLY);
    49.     if (fd < 0)
    50.     {
    51.         perror("open");
    52.         exit(2);
    53.     }
    54.     printf("打开管道文件成功\n");
    55.  
    56.     // 正常操作（读）
    57.     int process_nums=5;
    58.     for(int i=0;i
    59.     {
    60.         pid_t id=fork();
    61.         if(id==0)
    62.         {
    63.             getMessage(fd);
    64.             exit(3);
    65.         }
    66.     }
    67.     // 接收子进程
    68.     for(int i = 0; i < process_nums; i++)
    69.     {
    70.         waitpid(-1, nullptr, 0);
    71.     }
    72.  
    73.     //关闭文件
    74.     close(fd);
    75.     printf("关闭管道文件成功\n");
    76.  
    77.     //删除管道文件
    78.     int ret=unlink(FIFONAME);
    79.     assert(res!=-1);
    80.     printf("删除管道文件成功\n");
    81.  
    82.     return 0;
    83. }

            在服务端创建了管道文件之后，用户端也通过系统调用open打开此文件，接下来循环去发送文件，使用系统调用write将信息写进管道文件中，最后收尾工作，将文件fd关闭。

    代码（client）： 

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. using namespace std;
    10.  
    11. #define FIFONAME "mypipe"
    12. #define FIFOMODE 0666
    13.  
    14. int main()
    15. {
    16.     // 打开通道文件
    17.     int fd = open(FIFONAME, O_WRONLY);
    18.     assert(fd > 0);
    19.  
    20.     // 开始操作(写)
    21.     string message;
    22.     while (true)
    23.     {
    24.         cout << "请输入：\n";
    25.         cin >> message;
    26.  
    27.         write(fd, message.c_str(), strlen(message.c_str()));
    28.     }
    29.     //关闭文件
    30.     close(fd);
    31.     return 0;
    32. }

     运行：

            以上就是管道的两种类型的全部介绍，我们可以来总结一下两者的区别：

    ①匿名管道由pipe函数创建并打开，命名管道由mkfifo函数创建，用系统接口open打开；

    ②匿名管道只能在具有公共祖先（如父子进程）的进程间使用，而命名管道可以在不相关的进程间使用，

    除此之外，二者具有相同的功能。

    共享内存

    • 介绍

            共享内存可以说是最快的IPC（进程间通信）方式，因为其属于内存级的数据传输，且不需要过多的拷贝，当这块资源（内存）映射到涉及的两个进程的地址空间，那么数据传输不需要再输入输出内核空间（只在用户空间中），即不需要再使用read、write等系统调用接口传输数据，与此相对应的是pipe、fifo文件均是件，属于内核空间，需要用read、write等系统调用接口传输数据以致通信。示意图如下：

    • 共享内存函数

    1.shmget

    功能：创建共享内存；

    参数：

            key是关键字，是对于os而言的共享内存标识符，这个值调用ftok函数（下面介绍）由os创建，两个进程创建共享内存时使用同一个key值即是共享了这一块内存；

            size是共享内存的大小，建议设置成页大小（4096）的整数倍；

            shmflg是权限标志，填IPC_CREAT，表示若底层已存在key标识的共享内存，则获取之并返回，若不存在则创建之并返回；填IPC_CREAT | IPC_EXCL，表示若底层不存在则创建并返回，若存在则出错返回，注意后面还可以再或上八进制权限表示法，设置共享内存的权限；

    返回值：成功返回一个非负整数，称为shmid，是对于用户而言的共享内存标识符，失败返回-1。

    功能：把一个已存在的路径名和一个整数标识符转换成key；

    参数：pathname是路径名，由用户指定，此路径必须存在且可存取；proj_id也是由用户指定，该值必须是一个至少有8个比特位的非零值；

    返回值：返回一个key值。

    2.shmat

    功能：将共享内存挂接（映射）到进程地址空间；

    参数：

            shmid就是shmget的返回值，是对于用户而言的共享内存标识符；

            shmaddr是指定连接的地址，可设置为nullptr成为默认值；

            shmflg可设置为0成为默认值；

    返回值：成功返回一个指针指向共享内存的第一个字节，失败返回空，用法类似malloc。

    3.shmdt

    功能：将共享内存脱离当前进程；

    参数：指向共享内存的指针shmaddr；

    返回值：成功返回0，失败返回-1。

    4.shmctl 

    功能：控制共享内存，常用于删除共享内存；

    参数：

            shmid是共享内存标识符；

            cmd可填入IPC_RMID，表示删除共享内存；

            buf可填nullptr表示设置默认值；

    返回值：成功返回0，失败返回-1。

    注意：system V IPC资源的生命周期随内核，即需要手动（指令）删除或者代码删除，逼向管道资源，生命周期随进程，进程结束资源也就被删除了。

    • 举例

    1.框架

    1）.common.hpp

    代码：

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. using namespace std;
    15.  
    16. #define PATHNAME "/home/phan9"   //具有访问权限
    17. #define PROJ_ID 0x66   //自定
    18. #define SHM_SIZE 4096  //共享内存的大小，最好是页(PAGE: 4096)的整数倍

     2）.server.cpp

            先通过ftok函数创建key值，再通过此key值使用shmget函数创建共享内存，client也是通过此方法创建（识别到）这同一块共享内存，紧接着，将此共享内存通过shmat函数挂接到当前进程上，之后就可以使用shmaddr指针使用此共享内存，这里可以将共享内存当作成一个shmaddr指向的大字符串，通信结束后，先是使用shmdt函数将此共享内存与此进程相脱离，再用shmctl函数删除此共享内存。

    代码：

    1. #include "common.hpp"
    2.  
    3. int main()
    4. {
    5.     int res;
    6.     //与client通过ftok内部算法创建相同的key
    7.     key_t key=ftok(PATHNAME,PROJ_ID);
    8.     if(key==-1)
    9.     {
    10.         perror("ftok");
    11.         exit(1);
    12.     }
    13.     printf("server创建key成功,key:%d\n",key);  
    14.  
    15.     //创建shm，服务器是通信的发起者---要创建一个全新的共享内存，所以要使用IPC_CREAT|IPC_EXCL
    16.     int shmid=shmget(key,SHM_SIZE,IPC_CREAT|IPC_EXCL|0666);
    17.     if(shmid==-1)
    18.     {
    19.         perror("shmget");
    20.         exit(2);
    21.     }
    22.     printf("server创建共享内存成功,shmid:%d\n",shmid);
    23.  
    24.     //关联共享内存，shmat用法与malloc一样
    25.     char* shmaddr=(char*)shmat(shmid,nullptr,0);   //最后一个参数设为0，是默认只读的形式关联
    26.     if(shmaddr==nullptr)
    27.     {
    28.         perror("shmat");
    29.         exit(3);
    30.     }
    31.     printf("server关联共享内存成功,shmid:%d\n",shmid);
    32.     sleep(5);
    33.  
    34.     //通信
    35.     //*****************************************************
    36.     //...
    37.     //*****************************************************
    38.  
    39.     //共享内存去关联
    40.     res=shmdt(shmaddr);
    41.     if(res==-1)
    42.     {
    43.         perror("shmdt");
    44.         exit(4);
    45.     }
    46.     printf("server共享内存去关联成功,shmid:%d\n",shmid);
    47.     sleep(5);
    48.  
    49.     //删除共享内存
    50.     res=shmctl(shmid,IPC_RMID,nullptr);
    51.     if(res==-1)
    52.     {
    53.         perror("shmctl");
    54.         exit(5);
    55.     }
    56.     printf("server删除共享内存成功,shmid:%d\n",shmid);
    57.     return 0;
    58. }

     3）.client.cpp

            框架部分，client大部分代码是与server一样的，唯一不同的就是client不需要删除共享内存，因为client不是该共享内存的发起者，应当是server来删除。

    代码：

    1. #include "common.hpp"
    2.  
    3. int main()
    4. {
    5.     int res;
    6.     //创建key
    7.     key_t key=ftok(PATHNAME,PROJ_ID);
    8.     if(key==-1)
    9.     {
    10.         perror("ftok");
    11.         exit(1);
    12.     }
    13.     printf("client创建key成功,key:%d\n",key);
    14.  
    15.     //创建共享内存
    16.     int shmid=shmget(key,SHM_SIZE,IPC_CREAT);
    17.     if(shmid==-1)
    18.     {
    19.         perror("shmget");
    20.         exit(2);
    21.     }
    22.     printf("client创建共享内存成功,shmid:%d\n",shmid); 
    23.  
    24.     //关联共享内存，shmat用法与malloc一样
    25.     char* shmaddr=(char*)shmat(shmid,nullptr,0);
    26.     if(shmaddr==nullptr)
    27.     {
    28.         perror("shmat");
    29.         exit(3);
    30.     }
    31.     printf("client关联共享内存成功,shmid:%d\n",shmid);
    32.     sleep(5);
    33.  
    34.     //通信
    35.     //*****************************************************
    36.     //...
    37.     //*****************************************************
    38.  
    39.     //共享内存去关联
    40.     res=shmdt(shmaddr);
    41.     if(res==-1)
    42.     {
    43.         perror("shmdt");
    44.         exit(3);
    45.     }
    46.     printf("client共享内存去关联成功,shmid:%d\n",shmid);
    47.     sleep(5);
    48.  
    49.     //client不需要删除shm
    50.     return 0;
    51. }

     4）.运行

    ipcs -m：查看共享内存

    while :; do ipcs -m; sleep 1; done：一秒显示一次共享内存

            代码中会用sleep函数模拟通信逻辑部分，先运行server，再运行client可看到如下图情况，运行server，nattach变成1，三秒之后，运行client，nattach变成了2，紧接着server中对共享内存去关联，随即nattach变成了1，在client也去关联之后，nattach变成了0，可见，框架的运行逻辑是没错的，下面看一下通信逻辑的实现。

    运行：

    2.通信逻辑

    1）.server.cpp

            server将共享内存当成一个字符串，即将shmaddr当成字符串的首地址，举例让server反复去检查共享内存有无信息可以读取，有的话立马读出来，当遇到quit字符串时就退出读取。

    代码：

    1.     //通信(读)
    2.     //server将共享内存当成一个字符串，即将shmaddr当成字符串的首地址
    3.     while(true)
    4.     {
    5.         printf("%s\n",shmaddr);
    6.         if(strcmp(shmaddr,"quit")==0)
    7.             break;
    8.         sleep(1);
    9.     }

    2）.client.cpp

             client将共享内存当成一个char类型的缓存区，这里我们举例让client反复去写信息，当写到quit字符串时就停止写入。

    代码： 

    1.     //通信(写)
    2.     //client将共享内存当成一个char类型的缓存区
    3.     while(true)
    4.     {
    5.         cin>>shmaddr;
    6.         if(strcmp(shmaddr,"quit")==0)
    7.             break;
    8.     }

    运行：

            上图中可见，无论client运不运行，server都在一直从共享内存读消息，当client写进消息时，server能立马读出来，要知道共享内存是内存级的读写，是IPC中最快的，因为不需要过多的拷贝工作，但是共享内存缺乏访问控制，这样会带来并发问题，即client还没将信息写完整，server就已经读到了，这会产生不可控的影响。

            那如何做到一定的访问控制呢？

            我们知道，管道文件是自带访问控制的，那我们不妨借助管道文件来实现共享内存的访问控制，如下common.hpp代码中，我们首先实现了一个类，来创建和删除管道文件，只要在server中我们定义一个全局变量的该类的对象，那么在运行server时都会自动创建管道文件，运行结束就会自动删除管道文件，紧接着就是为打开和删除管道文件封装的函数，而Wait函数就是实现server读取共享内存中的信息前进行等待的功能，Wake函数就是实现client将消息输入到共享内存后提醒server可以读取消息的功能，其中tmp是通过管道的临时信息，具体使用如代码2、3。

    1）.common.hpp

    1. #define FIFONAME "./myfifo"
    2.  
    3. class Init
    4. {
    5. public:
    6.     Init()
    7.     {
    8.         umask(0);
    9.         int ret=mkfifo(FIFONAME,0666);
    10.         assert(ret==0);
    11.     }
    12.  
    13.     ~Init()
    14.     {
    15.         unlink(FIFONAME);
    16.     }
    17. };
    18.  
    19. int OpenFifo(const char* FifoName,int flags)
    20. {
    21.     int fd=open(FIFONAME,flags);
    22.     assert(fd>=0);
    23.     return fd;
    24. }
    25. void CloseFifo(int fd)
    26. {
    27.     close(fd);
    28. }
    29.  
    30. void Wait(int fd)
    31. {
    32.     printf("等待中\n");
    33.     int tmp=0;
    34.     read(fd,&tmp,sizeof(int));
    35. }
    36.  
    37. void Wake(int fd)
    38. {
    39.     int tmp=1;
    40.     write(fd,&tmp,sizeof(tmp));
    41. }

     2）.server.cpp

            在server读取共享内存的消息之前，先进行等待，当client向共享内存输入了信息（即将tmp输入到管道后），就算是等待到了信息，随后即可读取共享内存的信息，值得注意的是，在读取前后，要打开和关闭管道文件。

    代码： 

    1.     //通信(读)
    2.     //server将共享内存当成一个字符串，即将shmaddr当成字符串的首地址
    3.     int fd=OpenFifo(FIFONAME,O_RDONLY);
    4.     while(true)
    5.     {
    6.         Wait(fd);
    7.         printf("%s\n",shmaddr);
    8.         if(strcmp(shmaddr,"quit")==0)
    9.             break;
    10.     }
    11.     CloseFifo(fd);

    3）.client.cpp

            在client向共享内存写入了信息之后，提醒server可以读取了（即将管道的内容读到了tmp中），也要注意，写入信息前后别忘了打开和关闭管道文件。 

    代码： 

    1.     //通信(写)
    2.     //client将共享内存当成一个char类型的缓存区
    3.     int fd=OpenFifo(FIFONAME,O_WRONLY);
    4.     while(true)
    5.     {
    6.         cin>>shmaddr;
    7.         if(strcmp(shmaddr,"quit")==0)
    8.             break;
    9.         Wake(fd);
    10.     }
    11.     CloseFifo(fd);

    运行：

    消息队列

            消息队列是一个可以存储消息的缓冲区，它有一个唯一的标识符来区分不同的消息队列。进程可以通过调用消息队列相关的API来创建、发送、接收和删除消息队列。

            System V消息队列提供了一些优点，如异步通信、灵活的消息长度、高效的消息传递和顺序保证，使得它成为一种常见的IPC机制。但是，它也存在一些缺点，如消息队列的大小受限于系统内存、没有提供消息确认机制和没有提供消息过期机制。

            在Linux系统中，类似共享内存一样，消息队列也可以使用类似函数，比如msgget()、msgsnd()、msgrcv()和msgctl()等函数来操作System V消息队列。

    查看消息队列：ipcs -q

    删除消息队列：ipcrm -q msqid

    信号量

            system V信号量是一种用于进程间同步和通信的机制。它是UNIX系统中用于进程间同步和互斥的一种机制，常被用于进程间共享资源的同步和互斥（下面介绍）。

            system V信号量由3部分组成：一个计数器，一个等待队列和一些函数。计数器用于记录可用资源数量，等待队列用于保存等待该资源的进程列表，函数用于对信号量进行操作，例如增加、减少、初始化等操作。

            当一个进程需要访问共享资源时，它必须先申请信号量。如果信号量的计数器值大于0，那么进程可以使用该资源，并将信号量计数器减1。如果计数器值为0，则表明该资源已经被占用，申请进程将被阻塞，直到该资源被释放。释放资源的进程将会增加信号量计数器的值，同时唤醒等待队列中的一个或多个进程来获取资源。

            system V信号量提供了一种可靠的机制来防止多个进程同时访问共享资源。它是一种重要的进程间通信和同步机制，在多进程编程中应用广泛。

    查看信号量：ipcs -s

    删除信号量：ipcrm -s semid

    • 同步与互斥

            进程的同步是指在多个进程同时运行的情况下，为了避免出现不合预期的结果而采取的措施。由于各进程要求共享资源，而且有些资源需要互斥使用，因此各进程间竞争使用这些资源，进程的这种关系为进程的互斥。

            其中，多个进程（执行流）访问公共的同一份资源，这一份资源称为临界资源；涉及临界资源的代码称为临界区。

    注意：

            一般地，多个执行流一起运行时互相干扰，主要是因为在不加保护的情况下在临界区访问了临界资源，但在非临界区多个执行流是互不影响的。

    • 理解信号量 

            如同想在电影院看电影，就要先买票一样，进程访问临界资源就要先申请信号量；如同卖掉一张电影票，电影院的座位就少一个一样，一个进程申请信号量成功，信号量计数器就--，就能成功预定想要的资源，当执行完自己的临界区代码（访问完临界资源），信号量就会释放，计数器就会++。

            其中买票是对座位的预定，而申请信号量就是对临界资源的预定。

    后记

            进程间通信的方法很多，涉及到的知识点不是很难，但实操起来是是有一点困难，难的是一些细节的处理，虽然这些并不是目前主流的通信方式，但是都是一些较为经典的、会在面试当中被问到的知识点，希望可以通过此文章了解一部分，有问题的可以在评论中提出哦，拜拜！

  • 相关阅读:
    SSM框架学习——SqlSession以及Spring与MyBatis整合
    【Release】Photoshop ICO file format plug-in 3.0
    鸿蒙开发系列教程（二十三）--List 列表操作（2）
    服装连锁店铺管理软件大盘点！秦丝、日进斗金、商陆花谁更强？
    docker-compose安装gitlab
    Day42-HttpServletRequest、Cookie
    Python逆向爬虫之pyquery，非常详细
    TeeChart Pro for .NET 2022.10.24 Crack
    梳理promise功能逻辑，手写promise及相关方法
    Python数据分析与机器学习40-自然语言处理词向量模型-Word2Vec
  • 原文地址：https://blog.csdn.net/phangx/article/details/133819811