• Linux | 进程间通信

    目录

    前言

    一、进程间通信的基本概念

    二、管道

    1、管道的基本概念

    2、匿名管道

    （1）原理

    （2）测试代码

    （3）读写控制相关问题

    a、读端关闭

    b、写端关闭

    c、读快写慢

    d、读慢些快

    （4）进程池代码拓展

    3、命名管道

    （1）原理 

    （2）测试代码

    三、共享内存

    1、共享内存的原理

    2、测试代码

    3、共享内存的特性

    前言

            进程间通信的方式有很多，如管道、共享内存、消息队列、信号量、socket套接字等等；本文主要讲解其中管道和共享内存两种方式；

    一、进程间通信的基本概念

            我们要理解进程间通信呢首先得知道以下三个问题；

    进程间通信是什么？

    我们为什么要进程间通信？

    怎么进行进程间通信？

            对于所有知识，我们拥有上述三个问题得答案我们就可彻底弄清进程间通信得本质了；

    进程间通信是什么？

            进程间通信就是让两个进程，看到同一块空间（内存），以达到我们通过这块共同空间来进程交互得过程；

            我们都知道，我们可以通过fork创建子进程，fork创建后得子进程与父进程共享同一块代码；那么我们是否可以通过创建一个创建变量的资源缓冲区来使这两个父子进程看到同一块空间（内存）呢？很不幸，由于我们进程间的独立性，所以我们无法通过全局变量来让两个进程看到同一块空间，并且使用这个空间进行通信，准确来说是可以看到，但是不能进行通信，因为当我们父进程或子进程对这块空间内容进行修改时会发生写时拷贝；这也是保证进程间独立性而产生的机制；也正是由于进程具有独立性，所以我们的进程间通信便没有那么容易；

    为什么要进行进程间通信？

            在实际开发中，我们可能会有并发编程的需求，而我们的单进程是不具备并发能力的，而有时我们的并发之间的多进程需要一起协同配合，既然需要协同配合就可能需要进行通信，因此我们需要进程间通信；

    怎么进行进程间通信？

            关于如何进行进程间通信，我们主要有以下几种策略，分别来自于不同的方；

    Linux原生方案：管道（匿名管道、命名管道）

    System V方案：共享内存、消息队列（不常用）、信号量；

    POSIX 方案：socket套接字

            上述为一些主流方案，本文主要讲解 管道方案 与 System V 提供的共享内存方案；

    二、管道

    1、管道的基本概念

            首先管道我们在前面学习指令的时候就已经接触过了，只不过我们对其了解并不深刻；当时我们只知道我们可以通过管道将一个指令（进程）的输出结果传输给另一个指令（进程）；

    1、管道是一个信息传输的媒介！如上图所示，进程A将信息写入管道，而进程B从管道中读取数据；

    2、管道是一个文件；我们之前提过，Linux下，一切皆文件的理念，那么我们的管道也应该是一个文件，只不过这个文件是属于内存级文件，不会将数据刷新到缓冲区中，也没有必要刷新到缓冲区中做持久化的动作；

    3、管道的文件的通信方式为半双工通信；关于这我们需要补充以下几个概念；

    单工通信：只有一个方向的通信，且只有固定的一端作为接收端，一端作为输入端；

    半双工通信：通信的双方都可以作为接收端也可以作为输入端，当某一时刻，只能有一个端发送，一端接收；就好像两个人聊天，你说一句，我接收后，再回复一句，你再接收；

    全双工通信：通信的双方既可以作为接收端也可以作为输入端，某一个时刻，既可以输入也可以接收；就好像两个人吵架，每个人都可以挺别人说话的同时对别人说话；

    2、匿名管道

    （1）原理

            首先，我们来介绍匿名管道实现进程间通信的原理，再使用匿名管道作为进程间通信的方法之前，我们得确保通信双方进程为父子关系；这是使用匿名管道实现进程间通信得基本前提；

            前面我们讲过进程的相关内核数据，与我们创建一个进程会发生什么？以及当我们调用fork会发生什么？有了上述知识铺垫，我们不难想到，当我们使用fork创建子进程时，我们的子进程会创建自己的内核数据，如PCB控制块，虚拟地址空间、页表、文件描述符结构体等内核数据，其中我们还讲过子进程会拷贝父进程内核数据中的某些数据，当我们对这些数据需要进行修改时会发生写时拷贝的现象；那么问题来了，我们的维护当前进程打开的文件的结构体 files_struct 是否也会发生拷贝呢？当然，这是肯定的？因此，我们使用fork时，应该如下图所示；

            我们匿名管道实现进程间通信就是基于这一特性---- “子进程会继承父进程的文件描述符数组”；因此我们不妨首先创建一个管道文件，然后父进程分别以读和写的方式打开这个管道文件，接着我们创建子进程，子进程必然会对文件描述符数组的内容进行拷贝，子进程也拥有对该文件读和写这两个文件描述符，此时若我们想让父进程写，子进程读，我们只需要将父进程的读文件描述符关闭，子进程写文件描述符关闭，然后我们再调用系统调用read和write，分别向对应文件描述符读和写即可！这就是我们使用匿名管道的方式实现进程间通信的过程；

    （2）测试代码

            在正是实现代码之前，我们首先介绍几个与管道相关的接口；

    pipe：创建匿名管道

    参数：该函数只有一个参数，是一个整型数组，当我们调用该函数时，该函数会为我们创建一个匿名管道文件，并打开这个管道文件其中数组的 0 号下标放的是以读的方式打开该文件的文件描述符，1 号下标方式的以写的方式打开该管道文件的文件描述符；（记忆：0想象成嘴巴，代表读，1想象成笔，代表写）；

    返回值：若函数调用成功，返回0，调用失败，返回-1，错误码被设置；

            有了上面函数的学习，我们就可以写一段简单的基于匿名管道的进程间通信代码了；如下所示；

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8.  
    9. int main()
    10. {
    11.     // 1、创建管道
    12.     int pipefd[2] = {0};
    13.     int n = pipe(pipefd);
    14.     if(n == -1)
    15.     {
    16.         perror("pipe");
    17.         exit(1);
    18.     }
    19.     // 2、创建子进程
    20.     pid_t id = fork();
    21.     if(id == 0)
    22.     {
    23.         // 子进程(读)
    24.         // 3、建立单向信道
    25.         // 关闭子进程写端文件描述符
    26.         close(pipefd[1]);
    27.         // 4、进行通信
    28.         char buf[1024];  // 接收缓冲区
    29.         while(true)
    30.         {
    31.             // 读取来自父进程的信息
    32.             ssize_t sz = read(pipefd[0], buf, sizeof(buf));// 这里就不对read进行差错检验了
    33.             
    34.             buf[sz] = '\0';   // 我们想要读的是字符串,因此在语言层面得加 \0
    35.             if(sz > 0)
    36.             {
    37.                 std::cout << "读数据前\n";
    38.                 std::cout << "child[" << getpid() << "], father: " << buf << std::endl;
    39.             }
    40.             else if(sz == 0)
    41.             {
    42.                 std::cout << "father stop write, me quit" << std::endl;
    43.                 break;
    44.             }
    45.             sleep(1);
    46.         }
    47.  
    48.         exit(0);
    49.     }
    50.     // 父进程（写）
    51.     // 3、建立单向信道
    52.     close(pipefd[0]); // 关闭读端
    53.     // 4、进行通信
    54.     const char* msg = "这是发给子进程的消息 ";
    55.     char tmp[1024] = {0};
    56.     int count = 0;
    57.     while(true)
    58.     {
    59.         memset(tmp, 0, sizeof(tmp));
    60.         snprintf(tmp, sizeof(tmp), "%s[%d], %d\n", msg, getpid(), count++);
    61.         ssize_t sz = write(pipefd[1], tmp, strlen(tmp));
    62.         sleep(1);
    63.     }
    64.     // 5、回收子进程
    65.     waitpid(id, nullptr, 0);
    66.     // 6、关闭文件描述符（可关可不关，因为程序快运行结束，OS会自动释放）
    67.     close(pipefd[1]);
    68.     return 0;

            上述代码是实现了一个父进程写，子进程不断的读的功能；

    （3）读写控制相关问题

            基于上述代码，我们还要进行更深层次的研究；我们分别测试以下几种情况下会发生什么？

    a、读端关闭

            我们给上述代码读端设置一个计数器，设置成5秒后，读端退出；观察会发生什么；

     

             我们输入命令行监视脚本指令；如下所示；

    while :; do ps -axj | head -1 && ps -axj | grep ./main | grep -v grep; sleep 1; echo "--------------------";done

     

            我们发现，当我们的读端关闭时，写端进程被终止了！也就是被杀掉了！由于上述我们让子进程关闭读端文件描述符后休眠5秒，因此我们的子进程没有退出；我们不难得出结论；

    结论：读端关闭时，写端进程被操作系统杀死； 

    b、写端关闭

            同样的道理，我们使用计数器的方式，使写端到一定的时间后关闭，我们观察读端会如何；

     

            运行结果如下所示；

            仔细观察，打印了我们在read返回值为0的输出内容；

    结论：当我们写端关闭时，读端会读到文件的末尾，返回0；

    c、读快写慢

            我们将上述代码更改一下；将我们的读端设置为一秒读一次，将我们的写端设置为三秒写一次；再运行代码，看一看会发生什么；

            我们会发现，我们的进程三秒才会打印一次；我们的读进程不是一秒读一次吗？那我们的读进程在干嘛呢？

    结论：当读快写慢时，读进程会阻塞等待写进程进行写入；

    d、读慢些快

            我们将上述代码改一下，读进程三秒读一次，而写进程一秒写一次；又会发生什么呢？

            我们发现第一次立刻打印了，后面三秒打印一次，且每次都打印了三条内容；这时结果也显而易见了；

    结论：读慢写快时，我们的写进程会一直往管道文件里写，直至写满，写满后，写进程会阻塞，直至下一次读进程读取管道文件时，写进程才会被唤醒；

    总结：

            综上所述，我们使用匿名管道进行进程间通信的本质是我们通过子进程会继承父进程文件描述符数组的特性，使我们的父进程和子进程看到同一个文件，它们可以通过该文件进行通信；在我看来进程间通信的本质是让两个进程看到同一块空间的方式！而通信是根据上层定义的；

            匿名管道提供了访问控制，所谓访问控制，就是我们上述讨论a、b、c、d四种不同的方式；并不是所有进程间通信具有访问控制，如我们后面讲的共享内存；

            匿名管道的生命周期是随着进程的，一旦进程结束，我们的匿名管道文件也随之销毁；

    （4）进程池代码拓展

            通过上述知识，我们可以实现一个简单的进程池代码；

            具体代码如下所示；

    1. // task.h文件，主要封装任务和任务管理器
    2. #pragma once
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. // 定义函数对象类型
    11. using func_t = std::function<void()>;
    12.  
    13. void webRequest()
    14. {
    15.     std::cout << "正在执行网络请求任务" << std::endl;
    16. }
    17.  
    18. void readMySQL()
    19. {
    20.     std::cout << "正在执行读取数据库任务" << std::endl;
    21. }
    22.  
    23. void otherTask()
    24. {
    25.     std::cout << "正在执行其他任务" << std::endl;
    26. }
    27.  
    28. // 设计一个单例类，管理所有任务
    29. class ManageTask
    30. {
    31. public:
    32.     static ManageTask* getInstance()
    33.     {
    34.         // 双检查加锁
    35.         if(_pm == nullptr)   // 提高效率
    36.         {
    37.             _m.lock();
    38.             if(_pm == nullptr) // 保证线程安全
    39.             {
    40.                 _pm = new ManageTask();
    41.             }
    42.             _m.unlock();
    43.         }
    44.         return _pm;
    45.     }
    46.     // 加载类内成员
    47.     void load()
    48.     {
    49.         // 增加任务描述与命令号的映射
    50.         _dict.insert({_tasks.size(), "web请求"});
    51.         // 增加命令
    52.         _tasks.push_back(webRequest);
    53.         _dict.insert({_tasks.size(), "读取数据库"});
    54.         _tasks.push_back(readMySQL);
    55.         _dict.insert({_tasks.size(), "其它任务"});
    56.         _tasks.push_back(otherTask);
    57.     }
    58.     // 自定义新增任务
    59.     void add(func_t& cb, std::string& str)
    60.     {
    61.         _dict.insert({_tasks.size(), str});
    62.         _tasks.push_back(cb);
    63.     }
    64.     // 自定义删除任务(任务号)
    65.     void del(int command)
    66.     {
    67.         _dict.erase(command);
    68.         _tasks.erase(_tasks.begin() + command);
    69.     }
    70.     // 展示当前任务
    71.     void show()
    72.     {
    73.         for(auto e : _dict)
    74.         {
    75.             std::cout << e.first << ": " << e.second << std::endl;
    76.         }
    77.     }
    78.     // 获取任务
    79.     func_t get_task(int command)
    80.     {
    81.         return _tasks[command];
    82.     }
    83.     // 获取任务个数
    84.     size_t get_size()
    85.     {
    86.         return _tasks.size();
    87.     }
    88.     // 获取命令描述
    89.     std::string get_command(int command)
    90.     {
    91.         return _dict[command];
    92.     }
    93. private:
    94.     ManageTask(){}
    95.  
    96.     ManageTask(ManageTask& m){}
    97.     ManageTask operator=(ManageTask& m){}
    98. private:
    99.     static ManageTask* _pm;
    100.     static std::mutex _m;
    101.     std::vector<func_t> _tasks;
    102.     std::map<int, std::string> _dict;
    103. };
    104.  
    105. // 初始化单例对象指针和锁
    106. ManageTask* ManageTask::_pm = nullptr;
    107. std::mutex ManageTask::_m;
    108.  
    1. // main.cc文件，主要实现线程池，以及派发任务等逻辑
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include "task.hpp"
    9.  
    10.  
    11. #define NUM 6
    12.  
    13. int main()
    14. {
    15.     srand(time(nullptr)); // 种下随机数种子
    16.     ManageTask::getInstance()->load();  // 初始化任务表
    17.  
    18.     // 1、创建进程池
    19.     std::vectorpid_t, int>> desc; // 子进程pid与写端fd
    20.     for(int i = 0; i < NUM; i++)
    21.     {
    22.         // 1.1 创建管道文件
    23.         int pipefd[2] = {0};
    24.         int n = pipe(pipefd);
    25.         if(n == -1) 
    26.         {
    27.             std::cerr << "create pipe fail" << std::endl;
    28.             exit(1);
    29.         }
    30.         // 1.2 创建子进程
    31.         int id = fork();
    32.         if(id == 0)
    33.         {
    34.             usleep(100);
    35.             // 子进程（读）
    36.             // 1.3 关闭管道写端
    37.             close(pipefd[1]);
    38.             // 1.4 进行读取数据
    39.             int command = 0;
    40.             while(true)
    41.             {
    42.                 ssize_t sz = read(pipefd[0], &command, sizeof(command));
    43.                 if(sz != sizeof(int) || command < 0 || command >= ManageTask::getInstance()->get_size())
    44.                 {
    45.                     std::cerr << "读取无效命令" << std::endl;
    46.                     continue;
    47.                 }
    48.                 // 1.5执行命令对应任务
    49.  
    50.                 ManageTask::getInstance()->get_task(command)();
    51.             }
    52.             exit(0);
    53.         }
    54.         // 父进程（写）
    55.         // 1.3 关闭对应读端,并将写端保存起来
    56.         close(pipefd[0]);
    57.         desc.push_back(std::pair<pid_t, int>(id, pipefd[1]));
    58.     }
    59.  
    60.     // 2、使用进程池
    61.     // 2.1 获取菜单
    62.     while(true)
    63.     {
    64.         int select = 0;
    65.         int command = 0;
    66.         std::cout << "******************************" << std::endl;
    67.         std::cout << "******    1、showTask   ******" << std::endl;
    68.         std::cout << "******    2、execute    ******" << std::endl;
    69.         std::cout << "******************************" << std::endl;
    70.         // 2.2 从用户获取选择
    71.         std::cout << "Enter select> ";
    72.         std::cin >> select;
    73.         // 2.3 从用户获取命令选项
    74.         if(select == 1)
    75.         {
    76.             ManageTask::getInstance()->show();
    77.         }
    78.         else if(select == 2)
    79.         {
    80.             // 2.4 获取命令
    81.             std::cout << "Enter command> ";
    82.             std::cin >> command;
    83.             // 2.5 选择一个子进程执行（随机数实现负载均衡）
    84.             int proc = rand() % ManageTask::getInstance()->get_size();
    85.             // 2.6 向指定进程发送命令
    86.             write(desc[proc].second, &command, sizeof(command));
    87.             std::cout << "已经成功给" << desc[proc].first << "进程,对应命令：" << ManageTask::getInstance()->get_command(command) << std::endl;
    88.         }
    89.         else
    90.         {
    91.             std::cerr << "选择有误,请重新选择" << std::endl;
    92.             continue;
    93.         }
    94.         usleep(500);
    95.     }
    96.  
    97.     // 3、关闭进程池
    98.     // 关闭写端fd
    99.     for(int i = 0; i < desc.size(); i++)
    100.     {
    101.         close(desc[i].second);
    102.     }
    103.     // 回收子进程
    104.     for(int i = 0; i < desc.size(); i++)
    105.     {
    106.         waitpid(desc[i].first, nullptr, 0);
    107.     }
    108.     return 0;
    109. }

    3、命名管道

    （1）原理 

            命名管道的原理与匿名管道不同，命名管道则是通过自己创建一个管道文件，然后双方通过打开这个文件实现看到同一块内存资源的功能；命名管道的最大优势在于命名管道可以使不具有血缘关系的两个进程进行通信；原理非常简单，这里就不做过多解释，可通过后面代码来学习命名管道；

    （2）测试代码

            在正是学习命名管道之前，我们同样先补充一批接口的使用；

            首先我们学习一个命令行指令，mkfifo，该指令加上文件名即可创建一个指定名字的管道文件；具体看如下演示；

    mkfifo：创建一个管道文件（这是一个函数，与我们上述命令行指令重名而已）

    参数一：这个参数为我们要创建管道文件的文件名（默认在当前目录下创建文件）

    参数二：这个参数为我们创建管道文件的权限，这个权限会与我们默认权限掩码进行计算最终权限，计算规则（我们设置权限 & （~默认权限））；

    返回值：若调用成功则返回0，失败则返回-1，且错误码被设置；

    unlink：删除一个文件，与我们命令行下的rm指令功能一致；

    参数：要删除文件的路径

    返回值：若调用成功，则返回0，失败则返回-1，错误码被设置；

            有了上述的知识铺垫，我们可以很容易的写出一个命名管道通信的程序，如下所示；

    1. // comm.hpp文件主要存放公共代码，如管道文件名
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. // 管道文件名
    12. #define PipeName "FIFO.ipc"
    13.  
    1. // pipeServer.cc文件主要作为接收端，该端要创建管道文件，运行结束后要删除管道文件
    2. #include "comm.hpp"
    3.  
    4. int main()
    5. {
    6.     umask(0); // 设置创建文件临时的权限掩码
    7.     // 1、创建管道文件
    8.     int n = mkfifo(PipeName, 0666);
    9.     if(n == -1)
    10.     {
    11.         perror("mkfifo");
    12.         exit(1);
    13.     }
    14.     // 2、打开管道文件
    15.     int fd = open(PipeName, O_RDONLY, 0666);
    16.     if(fd == -1)
    17.     {
    18.         perror("open");
    19.         exit(2);
    20.     }
    21.     // 3、通信
    22.     char buf[1024];
    23.     while(true)
    24.     {
    25.         ssize_t sz = read(fd, buf, sizeof(buf) - 1);
    26.         buf[sz] = '\0'; // 去掉默认换行
    27.         if(strcmp(buf, "quit") == 0)
    28.         {
    29.             std::cout << "client quit, me too" << std::endl;
    30.             break;
    31.         }
    32.         std::cout << "client# " << buf << std::endl;
    33.     }
    34.     // 4、关闭管道文件
    35.     close(fd);
    36.     // 5、删除管道文件
    37.     unlink(PipeName);
    38.  
    39.     return 0;
    40. }
    1. // pipeClient.cc文件作为通信的发送端实现，主要向服务端发送请求
    2. #include "comm.hpp"
    3.  
    4. int main()
    5. {
    6.     // 1、打开管道文件
    7.     int fd = open(PipeName, O_WRONLY, 0666);
    8.     if(fd == -1)
    9.     {
    10.         perror("open");
    11.         exit(2);
    12.     }
    13.     // 2、通信
    14.     std::string buf;
    15.     while(true)
    16.     {
    17.         std::getline(std::cin, buf);
    18.         write(fd, buf.c_str(), buf.size());
    19.     }
    20.     // 3、关闭管道文件
    21.     close(fd);
    22.     return 0;
    23. }

            我们发现，只要我们将管道文件创建好，其他的就像我们操作普通文件一样简单；命名管道的使用比匿名管道会容易很多；

    注意：这里有一个细节，在我们使用管道文件时，若我们服务端使用open打开管道文件时，此时若我们的客户端没有调用open函数打开管道文件，我们的服务端会一只卡在open函数内，直至我们客户端也使用open函数打开管道文件，这时我们的服务端open函数才会返回文件描述符；这个细节在我们后面共享内存的一份代码中有一定重要的作用；

    三、共享内存

    1、共享内存的原理

            之前在讲解进程地址空间时，我们曾经讲过，堆栈中间有一块共享区，我们之前的动态库就是会被映射到这块共享区中；而今天我们的主角，共享内存的原理也与这块空间有关；进程间通信的本质就是看到同一块内存空间，而我们共享内存实现进程间通信的方案就是我们首先在内存中申请一块空间，然后将我们需要进程间通信的进程与这块物理空间进行关联，映射到自己进程地址空间的共享区中；这样便可以实现进程间通信了；如下图所示；

            这样进程间通信就只需要往自己的进程地址空间的某个位置写入读取即可；

    2、测试代码

            在使用共享内存实现进程间通信前，我们需要学习下面几个函数接口；

    shmget：申请一块共享内存空间并返回对应的shmid / 获取一块共享内存空间的shmid；

    参数一：通过key值获取或者申请一块共享内存空间，每块共享内存空间的key值不同；

    参数二：申请 / 获取共享内存空间的大小

    参数三：标志位，通常是由 IPC_CREAT 或 IPC_EXCL 这两个宏加上权限组成；

    返回值：若函数调用成功则返回 shmid，这个也就是共享内存的句柄，与fd类似；若调用失败，则返回-1，错误码被设置；

    注意：

    1、关于参数三，我们若想获取某个key对应的shmid，我们直接填0即可；若某个key对应的共享内存空间不存在，我们需要创建，则我们一般会填 IPC_CREAT | IPC_EXCL | 0666；其中0666为共享内存空间的访问权限；

    IPC_CREAT：若共享内存空间不存在，则创建之；

    IPC_EXCL：通常配合上面IPC_CREAT使用，若共享空间存在，则报错返回-1；因此这两个选项配合使用可以保证获得到的共享内存是一个新创建的共享内存！

    2、关于上述的参数一key，我们可以通过下面这个函数来获取；

    ftok：通过路径和项目id生成唯一key值；

    参数一：项目路径，这里可以随便填写一个；

    参数二：项目id，这里也可以自己设置一个；

    返回值：若函数调用成功，则返回key值，若失败，则返回-1，错误码被设置；

    shmat：是共享内存空间与当前虚拟地址空间进行相关联，建立映射关系；

    参数一：shmid值，之前我们在shmget中获取的 id；

    参数二：我们想要与哪一块虚拟地址空间绑定，建立映射关系；这里通常填NULL，表示让OS系统随机分配一块空间建立映射关系；

    参数三：一般设置为0，可不关心；

    返回值：若调用成功，则返回与共享内存建立映射的虚拟地址，若调用使用，则返回-1，错误码被设置，注意这里的-1被强制装换成了 void* 类型；

    shmdt：将共享内存与我们的共享内存去关联，与我们的shmat相对应；

    参数一：要去关联的共享内存的地址，也就是shmat的返回值；

    返回值：若函数调用成功，则返回0，若失败，则返回-1，错误码被设置；

    shmctrl：共享内存的控制

    参数一：shmid值；

    参数二：这里有三个宏来控制这个函数的行为，我们一般选择IPC_RMID，表示我们要删除这块共享内存空间；

    参数三：填NULL即可；

    返回值：若调用成功则返回0，若失败则返回-1，错误码被设置；

            学习上述的四个函数我们就可以完成进程间通信了，上面四个函数基本囊括了使用共享内存进行进程间通信的整个过程，首先调用ftok获取key值，然后再通过shmget 创建共享内存 / 获取shmid，然后通过shmat 与当前进程的虚拟地址空间进行关联，接着就可以开始进行通信了，通信完毕后，我们使用 shmdt 将虚拟地址与共享内存去关联；最后我们使用shmctl删掉申请的共享内存空间；

            接着我们需要学习一些命令行来获取共享内存相关信息，我们可以通过 ipcs -m 来获取当前机器的共享内存申请使用情况；使用 ipcrm -m shmid 来删除指定的共享内存；下面为我们使用共享内存进行进程间通信的代码；

    1. // comm.hpp 文件用于保存一些共享代码
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. // 形成key所需路径
    13. #define pathName "/home/zsw/linuxCode/shm"
    14. // 形成key所需项目id
    15. #define proj_id 0x13
    16. // 共享内存大小
    17. #define SIZE 4096
    18.  
    19.  
    1. // shmServer.cc 文件实现服务端接收客户端发送信息，其中服务端承担创建共享内存，删除共享内存的任务
    2.  
    3. #include "comm.hpp"
    4.  
    5. int main()
    6. {
    7.     // 1、生成唯一key
    8.     int k = ftok(pathName, proj_id);
    9.     if(k == -1)
    10.     {
    11.         perror("ftok");
    12.         exit(1);
    13.     }
    14.     std::cout << "ftok success\n";
    15.     // 2、创建新的共享空间
    16.     int shmid = shmget(k, SIZE, IPC_CREAT | IPC_EXCL | 0666); // 创建一个新的共享内存，k存在，则创建失败
    17.     if(shmid == -1)
    18.     {
    19.         perror("shmget");
    20.         exit(2);
    21.     }
    22.     std::cout << "shmget success\n";
    23.  
    24.     // 3、与共享空间相关联
    25.     char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    26.     if(*(int*)shmaddr == -1)
    27.     {
    28.         perror("shmat");
    29.         // 退出前释放共享空间
    30.         shmctl(shmid, IPC_RMID, nullptr);
    31.         exit(3);
    32.     }
    33.     std::cout << "shmat success\n";
    34.  
    35.     // 4、通信(读)
    36.     while(true)
    37.     {
    38.         printf("%s\n", shmaddr);
    39.         if(shmaddr[0] == 'z')
    40.             break;
    41.         sleep(1);
    42.     }
    43.     
    44.     // 5、去关联
    45.     int n = shmdt(shmaddr);
    46.     if(n == -1)
    47.     {
    48.         perror("shmdt");
    49.         exit(4);
    50.     }
    51.     std::cout << "shmdt success\n";
    52.  
    53.     // 6、释放共享空间
    54.     shmctl(shmid, IPC_RMID, nullptr);
    55.     std::cout << "shm rm success\n";
    56.  
    57.     return 0;
    58. }
    1. // shmClient.cc 文件用于客户端发送信息给服务端，其中仅需对共享内存关联，通信、去关联等操作即可
    2.  
    3. #include "comm.hpp"
    4.  
    5. int main()
    6. {
    7.     // 1、获取唯一key
    8.     int k = ftok(pathName, proj_id);
    9.     if(k == -1)
    10.     {
    11.         perror("ftok");
    12.         exit(1);
    13.     }
    14.     // 2、获取共享内存
    15.     int shmid = shmget(k, SIZE, 0);
    16.     if(shmid == -1)
    17.     {
    18.         perror("shmget");
    19.         exit(2);
    20.     }
    21.     // 3、关联
    22.     char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    23.     if(*(int*)shmaddr == -1)
    24.     {
    25.         perror("shmat");
    26.         exit(3);
    27.     }
    28.     // 4、通信(写)
    29.     char ch = 'a';
    30.     while(ch <= 'z')
    31.     {
    32.         shmaddr[0] = ch;
    33.         ch++;
    34.         sleep(1);
    35.     }
    36.     // 5、去关联
    37.     int n = shmdt(shmaddr);
    38.     if(n == -1)
    39.     {
    40.         perror("shmdt");
    41.         exit(4);
    42.     }
    43.     return 0;
    44. }
    45.  
    46.

            我们编译运行服务端代码，如下所示；

            确实，我们的服务端一直读取数据，可是读取到的数据为空，此时我们并没有运行客户端，且客户端也不可能进行输出发送；可我们依旧可以读取数据，只不过数据为空罢了，这就与我们的管道通信有了本质的区别，共享内存的进程间通信并没有访问控制！

            接着我们通过ipcs -m 查找我们创建的共享内存，确实存在，其shmid为25，key就是我们通过 ftok 生成的key，owner就是共享内存的拥有者，也就是当前用户，perms就是这块共享内存的访问权限，我们设置成了 666，4096就是我们申请这块共享内存的大小，nattach就是关联到这块共享内存空间的进程数，status就是这块共享内存的状态；

            我们接着启动客户端；如下所示；

            我们发现服务端已经收到客户端发来的信息，并且我们的nattach的数量也由1变成了2，随后当客户端发送完26个英文字母后退出，此时服务端也读取到了字符z，两个进行相继推出，nattach也由2变成了0，共享内存被删除；

            前面的实验，我们也不难发现，我们的共享内存不具备访问控制，那我们要是想使用共享内存实现类似管道的访问控制是否可以做到呢？其实也不难，我们可以通过管道来实现，如下面的代码；

    1. // comm.hpp 文件
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13.  
    14. // 形成key所需路径
    15. #define pathName "/home/zsw/linuxCode/shm/shm_pipe"
    16. // 形成key所需项目id
    17. #define proj_id 0x14
    18. // 共享内存大小
    19. #define SIZE 4096
    20. // 管道文件名
    21. #define pipeName "./fifo.ipc"
    22.  
    23. // 负责创建与销毁管道文件
    24. class Init
    25. {
    26. public:
    27.     Init()
    28.     {
    29.         umask(0);
    30.         int n = mkfifo(pipeName, 0666);
    31.         if(n == -1)
    32.         {
    33.             perror("mkfifo");
    34.             exit(5);
    35.         }
    36.     }
    37.     ~Init()
    38.     {
    39.         unlink(pipeName);
    40.     }
    41. };
    42.  
    43. // 通过read阻塞来形成等待效果
    44. void wait(int fd)
    45. {
    46.     int tmp = 1;
    47.     ssize_t sz = read(fd, &tmp, sizeof(int));
    48.     if(sz != sizeof(tmp))
    49.     {
    50.         std::cerr << "fd: " << fd << " 等待错误\n";
    51.         printf("sz:%d, sizeof(tmp):%d\n", sz, sizeof(tmp));
    52.         perror("wait");
    53.         exit(6);
    54.     }
    55. }
    56.  
    57. // 通过write唤醒等待进程
    58. void signal(int fd)
    59. {
    60.     int tmp = 1;
    61.     ssize_t sz = write(fd, &tmp, sizeof(tmp));
    62.     if(sz != sizeof(int))
    63.     {
    64.         std::cerr << "write err\n";
    65.         exit(7);
    66.     }
    67. }
    1. // shmServer.cc
    2.  
    3. #include "comm.hpp"
    4.  
    5. int main()
    6. {
    7.     Init init; // 创建管道文件
    8.     // 打开管道文件
    9.     int fd = open(pipeName, O_RDONLY, 0666);
    10.  
    11.     // 1、生成唯一key
    12.     int k = ftok(pathName, proj_id);
    13.     if(k == -1)
    14.     {
    15.         perror("ftok");
    16.         exit(1);
    17.     }
    18.     std::cout << "ftok success, k:" << k << std::endl;
    19.     // 2、创建新的共享空间
    20.     int shmid = shmget(k, SIZE, IPC_CREAT | IPC_EXCL | 0666); // 创建一个新的共享内存，k存在，则创建失败
    21.     if(shmid == -1)
    22.     {
    23.         perror("shmget");
    24.         exit(2);
    25.     }
    26.     std::cout << "shmget success\n";
    27.     // 3、与共享空间相关联
    28.     char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    29.     if(*(int*)shmaddr == -1)
    30.     {
    31.         perror("shmat");
    32.         // 退出前释放共享空间
    33.         shmctl(shmid, IPC_RMID, nullptr);
    34.         exit(3);
    35.     }
    36.     std::cout << "shmat success\n";
    37.     sleep(5);
    38.     // 打开管道文件
    39.     int fd = open(pipeName, O_RDONLY, 0666);
    40.     // 4、通信(读)
    41.     while(true)
    42.     {
    43.         wait(fd);
    44.         printf("%s\n", shmaddr);
    45.     }
    46.     
    47.     // 5、去关联
    48.     int n = shmdt(shmaddr);
    49.     if(n == -1)
    50.     {
    51.         perror("shmdt");
    52.         exit(4);
    53.     }
    54.     std::cout << "shmdt success\n";
    55.  
    56.     // 6、释放共享空间
    57.     shmctl(shmid, IPC_RMID, nullptr);
    58.     std::cout << "shm rm success\n";
    59.  
    60.     return 0;
    61. }
    1. // shmClient.cc文件
    2.  
    3. #include "comm.hpp"
    4.  
    5. int main()
    6. {
    7.     // 小坑：不能在这打开管道文件，因为打开管道文件有一个特性，如果对端不打开，这里将会一直阻塞
    8.     // 然后在后续过程中，若客户端进程先执行，下面shmget函数可能出现文件未创建的错误，因为客户端
    9.     // 执行的比服务端快，服务端还未创建共享内存，而客户端就想访问了
    10.     // int fd = open(pipeName, O_WRONLY, 0666);
    11.  
    12.     // 1、获取唯一key
    13.     int k = ftok(pathName, proj_id);
    14.     if(k == -1)
    15.     {
    16.         perror("ftok");
    17.         exit(1);
    18.     }
    19.     std::cout << "ftok success, k:" << k << std::endl;
    20.     // 2、获取共享内存
    21.     int shmid = shmget(k, SIZE, 0);
    22.     if(shmid == -1)
    23.     {
    24.         perror("shmget");
    25.         exit(2);
    26.     }
    27.     std::cout << "shmget success\n";
    28.     // 打开管道文件
    29.     int fd = open(pipeName, O_WRONLY, 0666);
    30.     // 3、关联
    31.     char* shmaddr = (char*)shmat(shmid, nullptr, 0);
    32.     if(*(int*)shmaddr == -1)
    33.     {
    34.         perror("shmat");
    35.         exit(3);
    36.     }
    37.     std::cout << "shmat success\n";
    38.     // 4、通信(写)
    39.     std::string msg;
    40.     while(true)
    41.     {
    42.         std::cout << "Enter message> ";
    43.         getline(std::cin, msg);
    44.         strcpy(shmaddr, msg.c_str());
    45.         signal(fd);
    46.     }
    47.     // 5、去关联
    48.     int n = shmdt(shmaddr);
    49.     if(n == -1)
    50.     {
    51.         perror("shmdt");
    52.         exit(4);
    53.     }
    54.     std::cout << "shmdt success\n";
    55.     return 0;
    56. }

            这段代码就有我们前面所说管道的一个性质，并且，这里有一个小坑；正常情况下，我们一般先运行服务端代码，因为我要保证客户端代码在获取 shmid 时，已经被创建了，因此在测试代码一（不加管道代码）时，我们总是先运行服务端代码；

            如上图所示，若我们将打开管道文件的代码放到最上面，也就是最先执行，此时，当我们的服务端打开管道文件时，由于对端未打开管道文件，因此，我们会阻塞住，此时我们接着运行客户端代码，由于客户端打开管道文件时，由于对端已经在等待了，因此可以直接返回管道文件对应文件描述符，此时若我们的客户端继续运行，当调用shmget获取shmid时，由于key所对应的共享内存并未创建，因此我们的客户端会直接运行失败；

    3、共享内存的特性

    1、共享内存仅需内存级读写即可，与管道不同，使用管道需要调用系统调用read、write等；而共享内存仅需往指定虚拟地址空间写入、读取即可；

    2、共享内存是最快的通信方式，因为拷贝次数最少；写入最少拷贝仅需从键盘文件对应缓冲区拷贝到共享内存中即可，写入仅需从共性内存中拷贝到要写入的缓冲区即可；

  • 相关阅读:
    站在开源云的新周期，EasyStack布局数字原生企业云
    正则验证用户名和跨域postmessage
    简述什么是服务端包含（Server Side Include）？
    redis设计规范
    [附源码]SSM计算机毕业设计作业自动评阅系统JAVA
    论文解读：Rectifying the Shortcut Learning of Background for Few-Shot Learning
    Jupyter使用技巧
    记录“在Unity动画播放协程内等待动画播放完成时回调”遇到的坑
    NLP_文本特征处理_4（代码示例）
    async和await、以及他们和promise的区别？
  • 原文地址：https://blog.csdn.net/Nice_W/article/details/134436861