【Linux】进程间通信（匿名管道和命名管道通信、共享内存通信）

1、进程间通信

1.1 进程的通信

在一些应用场景下，一定要求着进程之间进行通信，而通信有以下这些：
数据传输：进程间将数据传递给彼此。
资源共享：多个进程共享同一份资源。
通知事件：一个进程向另一个进程发送信息，通知它发生了某种事件。（比如父进程向子进程传递信号，让子进程退出。）
进程控制：一个进程控制另一个进程。（比如debug）

比如在linux中通过命令，ps ajx | grep hello，两个命令分别对应着两个进程，通过管道进行进程通信。（也就是说，为了完成某些业务，我们是需要多进程进行协同的）

 

1.2 如何让进程间通信？

Linux的主流通信标准有以下：

1. POSIX （让通信过程可以跨主机）
2. System V （聚焦在本地通信这种方式，这种标准有着三种通信方式：共享内存、消息队列、信号量（这里只谈共享内存，因为SystemV标准不常用）。）

第二套通信方案
管道是最基本的通信方案，管道基于文件系统。
管道有着匿名管道和命名管道。

 

1.3 进程间通信的本质

首先，进程是具有独立性的，所以如果要让进程进行通信肯定是不能进程与进程直接联系的。
那么就需要以下：
 
1、OS需要直接或间接的给通信双方的进程提供"共享空间"。
2、要让通信的进程都看到同一份共享空间。
（而不同的通信种类，本质就是这边共享空间的不同，区别在OS哪个模块提供的。比如通过文件系统提供的资源就是管道。）

综上，我们需要做的就是：
1、需要让进程看到同一份资源。（这个是主要的）
2、通信
 

2、管道通信

2.1 匿名管道

理解管道通信：

在讲文件的时候说到过，一个进程的PCB中有一个指针，指向文件描述符表，被打开的文件被其中文件描述符下标指向。
 
如果有一个父进程打开了一个文件，那么文件描述符表中对应就会指向这个文件对应的结构体对象，通过这个文件结构体中有着文件的操作方法以及一个内核缓冲区。
 
父进程创建子进程后，子进程拷贝父进程，对应文件描述符表中对应也会指向这个文件对应结构体对象。
 
综上，两个进程指向同一文件资源，这个文件就是一个"共享空间"，也是一个管道。

另一个问题，普通文件传输数据是需要经过磁盘的，如果进程间通过文件传输数据经过磁盘，那么就是内存与外设的交互，效率很低。那么OS能不能只创建一个文件结构体对象，只在内存中交互呢？
 
答案是肯定的，这个文件不会真的存在，OS会申请一个文件结构体对象。
同时，这个文件是一个内存级文件没有名字也没有对应inode，所以称之为匿名管道。

 

管道只能单向通信
首先创建管道将读写端返回给进程。

为了让子进程也看到读写端，父进程fork创建子进程。

因为管道需要单向通信，所以对应读端要关闭写端，对应写端要关闭读端。

综上，匿名管道就是一个父进程通过读和写的方式打开一个内存级文件后，通过创建子进程，关闭各自读写端，所构成的通信信道，这个信道基于文件，是一个内存级文件，所以称为匿名管道。

 

2.2 匿名管道通信

pipe接口：

pipe系统接口，可以创建一个单向管道用于进程间通信，pipefd[2]参数是一个返回型参数，返回两个文件描述符，一个读端fd[0]和一个写端fd[1]，指向管道文件的两边。
 
知道了如何创建管道后，下面需要让两个进程都看到这个"共享空间" 因为管道返回的是文件描述符，所以通过文件描述符就可以访问管道。
 
综上，思路就很简单：
1. 创建管道，接收管道文件描述符。
2. 父进程创建子进程，进程会获取和父进程一样的文件描述符。
3. 可以让父进程读，子进程写，然后父进程需要关闭写端，子进程关闭读端。
4. 通过文件操作进行通信。

测试代码:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <string>
#include <unistd.h>
#include <cassert>
#include <sys/types.h>
#include <sys/wait.h>using namespace std;
int main()
{//第一步：创建管道文件，打开读写端int fds[2];int n = pipe(fds);assert(n == 0);//第二步：forkpid_t id = fork();assert(id >= 0);if(id == 0){//子进程写入close(fds[0]);//子进程的通信代码int cnt = 0;while(true){char buffer[1024];snprintf(buffer, sizeof buffer, "child->parent say: %s[%d][%d]","我是子进程,我正在发消息", cnt++, getpid());//一直往管道输入端写，写满也会阻塞write(fds[1], buffer, strlen(buffer));cout << "count: " << cnt << endl;sleep(2); //每隔2s， 写一次 }close(fds[1]); //写完 子进程关闭写端cout << "子进程关闭自己写端" << endl;sleep(5);exit(0);}//父进程读取close(fds[1]);//父进程的通信代码while(true){char buffer[1024];//如果管道中没有了数据，读端在读，默认会直接阻塞当前正在读取的进程！ssize_t s = read(fds[0], buffer, sizeof(buffer) - 1);if(s > 0){buffer[s] = 0;cout << "Get Message# " << buffer << "| my pid:"<< getpid() << endl;//break;}else if(s == 0){//读到文件末尾cout << "read: " << s << endl;break;}//父进程没有sleep}close(fds[0]);int status = 0;n = waitpid(id, &status, 0);cout << "waitpid:" << n << " sig:" << (status & 0x7f) << endl;assert(n == id);return 0;
}

 
匿名管道读写特性：

之前，主要做的是让进程间看到同一份资源，而通信的过程是可以任意想象的，但是大概就以下几个情况。
1、写的快，读的慢。（那么每次读取的时候，就会从缓冲区读一大堆）
2、写的慢，读的快。
3、写后关闭写端，读端继续。（当读完后，子进程退出，父进程需要回收子进程）
4、一直写，读端关闭。（这种情况的出现，让数据没有意义）
 
前三个很好理解，如果第四种情况出现，写端一直写，读端却不读，那么写的数据就没有任何意义，造成了空间浪费。
 
当写端还在，读端关闭这个条件发生时，操作系统为了避免空间浪费，就会给父进程发送SIGPIPE（13）信号，关闭父进程。

 
管道特点：

1. 管道的生命周期随进程。
2. 管道可以用来进行具有"血缘关系"的进程间进行通信，常用于父子间通信。
3. 管道是面向字节流的。
4. 管道只允许单向通信 半双工的。（任何时候都是一方向另一方发送数据）
5. 互斥和同步机制。（共享资源保护机制）（这个可以和后面共享内存进行比较）

 

2.3 命名管道

前面的匿名管道，是有"血缘关系"的进程间进行通信的。
如果想让毫不相关的两个进程通过管道通信呢？命名管道就能解决这个问题。

命名管道相较于匿名管道就是在磁盘有一个特殊的管道文件，这个文件在打开后也拥有着自己的struct file。
 
两个不相关的进程是如何看到同一份资源的呢？
可以让不同进程，通过文件名（路径+文件名）打开。（匿名管道的结构体对象中的地址没有名称，命名管道的结构体对象中的地址拥有名称）
 
值得注意的是，进程传递到内核缓冲区的数据不会刷新到磁盘上。

 

2.4 命名管道的通信

函数调用mkfifo：

函数调用mkfifo用于创建命名管道，也是一个特殊的文件。
pathname: 表示创建文件的路径，如果只是一个文件名就和进程在同一路径。
mode: 表示创建的文件名拥有的初始权限。（前提设置umask(0)，不然结果就是mode & ~umask）
创建成功返回0，失败返回-1。

 
函数调用unlink：

unlink在此用于删除管道文件，只需传管道路径，成功返回0，错误返回-1。

对应通信也很简单。
1、创建管道文件，进程1打开文件，向文件里写入。
2、进程2打开文件向文件里读取，读完后删除管道文件。

//comm.hpp
#pragma once
#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <cerrno>
#include <cstring>
#include <cassert>
#include <fcntl.h>#define NAMED_PIPE "mypipe"bool createFifo(const std::string& path)
{umask(0);int n = mkfifo(path.c_str(), 0666);if(n == 0){return true;}else{std::cout << "errno: " << errno << "err stirng:" << strerror(errno) << std::endl;return false;}
}void removeFifo(const std::string& path)
{int n = unlink(path.c_str());assert(n == 0);(void)n;
}#include "comm.hpp"int main()
{createFifo(NAMED_PIPE);int wfd = open(NAMED_PIPE, O_WRONLY, 0666);int cnt = 10;while(cnt--){char buffer[1024];std::cout << "client begin:" << std::endl;fgets(buffer, sizeof buffer, stdin);std::cout << "client end:" << std::endl;ssize_t w = write(wfd, buffer, strlen(buffer) - 1);std::cout << std::endl;}close(wfd);return 0;
}#include "comm.hpp"int main()
{//createFifo(NAMED_PIPE);int rfd = open(NAMED_PIPE, O_RDONLY, 0666);while(true){std::cout << "server begin:" << std::endl;char buffer[1024];ssize_t r = read(rfd, buffer, sizeof(buffer));if(r > 0){buffer[r] = 0;std::cout << buffer << std::endl;std::cout << "server end:" << std::endl;std::cout << std::endl;}else{std::cout << "read:" << r << std::endl;break;}}close(rfd);removeFifo(NAMED_PIPE);return 0;
}

3、SystemV中的共享内存通信

3.1 共享内存

共享内存的理解很简单。
用户通过接口，让OS在物理空间申请一块内存。
不同的进程将进程地址空间通过页表和这块内存进行映射。
这就做到了共享同一份空间。

下面通过接口，看进程是怎么和共享内存联系起来的。
 
认识接口

 
shmget:

shmget让OS在物理空间上申请一个共享内存
key是一个系统层面的标识符，用于标识共享内存唯一性。(这key是由一个函数生成)
size 表示要创建多大的共享内存。
shmflg 是一个二进制标识符，一般为IPC_CREAT 表示共享内存没有时创建，有时不创建；为IPC_CREAT | IPC_EXCL 表示没有时创建，有时会报错。
成功返回一个用户层面的标识符，用于标识共享内存唯一性，错误返回-1。
也正是因为这个返回值和文件描述符没有关联，使得SystemV标准作为自立的一套标准

ftok:

前面shmget所说的参数key，就是ftok的返回值，用于标识共享内存唯一性。
pathname和proj_id，可以是符合类型的任意值，ftok会根据自己算法将这两个参数转换成返回值key。
 
这也说明，如果多个进程的pathname和proj_id都用一样的话，就能通过返回值key访问同一个共享内存。

 
shmctl：
有了创建共享内存的函数就有可以释放共享内存的函数。

值得注意的是shmclt不仅可以释放共享内存，也有着访问共享内存的属性作用，这里只说怎么释放内存。
shmid ：这个值是shmget的返回值，指的是用户层面上标识共享内存唯一性的。
cmd ：是个二进制标识符，IPC_RMID 代表释放共享内存。

buf 是用于访问共享内存属性的参数，这里可以置空。
成功返回0，失败返回-1.

---

有了shmget和ftok，就可以创建共享内存了，接下来就需要考虑如何将进程和共享内存关联起来。

不过在此之前先再认识下共享内存：

首先前面说过，内存中一定会在一定时刻存在多个共享内存，多个共享内存就一定需要被操作系统管理，管理就一定需要结构化。
 
共享内存 = 物理空间块 + 自身属性。
而管理共享内存的结构体struct shm其中就保存了作为系统层面的key，用于标识唯一性。

 

3.2 共享内存的通信

共享内存的系统命令：

通过ipcs -m 可以查看当前开辟的共享内存

如果要通过命令释放共享内存，可以通过ipcrm -m 对应shmid

通过while :; do ipcs -m; sleep 2; done 也可以一直看到共享内存信息。

---

 
共享内存的通信：

首先进程和共享内存的联系，也是通过函数进行联系的。

shmat(attach 附加) 和 shmdt(detach 分离)

shmat 将内存段连接到进程地址空间
shmid 是shmget返回的用户层面上的唯一标识符
一般都是shmat(id, nullptr, 0)，让它自动连接将当前进程联系到共享内存段。
返回值返回一个指针，指向共享内存的第一个内存段。如果失败返回（void*）-1
 
shmdt 取消进程与共享内存的关联。
只需要传一个shmat返回的地址就行，就能取消联系。
成功返回0，失败返回-1。

共享内存进行通信

//comm.hpp
#include <iostream>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <cstring>
#include <unistd.h>
#include <cassert>#define SHMSIZE 4026
#define PATHNAME "."
#define PROJ_ID 0x66key_t getKey(const char* path, int proj_id)
{key_t k = ftok(path, proj_id);if(k < 0){std::cout << "ftok:" << errno << ":" << strerror(errno) << std::endl;exit(-1);}return k;
}int getShmHelp(key_t k, int shmflg)
{int id = shmget(k, SHMSIZE, shmflg);if(id < 0){std::cout << "shmget: " << errno << ":" << strerror(errno) << std::endl;exit(-1);}
}int createShm(key_t k)
{umask(0);return getShmHelp(k, IPC_CREAT | IPC_EXCL | 0600);
}int getShm(key_t k)
{return getShmHelp(k, IPC_CREAT);
}void* attachShm(int shmId)
{void* mem = shmat(shmId, nullptr, 0);if((long long)mem == -1L) //linux 64位{std::cout << "shmat: " << errno << ":" << strerror(errno) << std::endl;exit(-1);}
}void detachShm(void* start)
{if(shmdt(start) == -1){std::cout << "shmdt: " << errno << ":" << strerror(errno) << std::endl;exit(-1);}
}void delShm(int shmId)
{if(shmctl(shmId, IPC_RMID, nullptr) == -1){std::cout << "shmctl: " << errno << ":" << strerror(errno) << std::endl;exit(-1);}
}///
//client
#include "comm.hpp"int main()
{//先获取key,用于唯一标识共享内存key_t key = getKey(PATHNAME, PROJ_ID);printf("key:0x%x\n", key);//用户创建共享内存int shmId = createShm(key);printf("shmId:%d\n", shmId);//进程与内存关联char* start = (char*)attachShm(shmId);printf("attach success, address start: %p\n", start);//进程通信const char* message = "hello server, 我是另一个进程，正在和你通信";pid_t id = getpid();int cnt = 1;int circnt = 5;while(circnt--){sleep(5);snprintf(start, SHMSIZE, "%s[pid:%d][消息编号:%d]", message, id, cnt++);}//sleep(10);//删除前最好取消关联detachShm(start);//删除共享内存//delShm(shmId);return 0;
}///
//server
#include "comm.hpp"int main()
{//先获取key,用于唯一标识共享内存key_t key = getKey(PATHNAME, PROJ_ID);printf("key:0x%x\n", key);//用户创建共享内存int shmId = getShm(key);printf("shmId:%d\n", shmId);//进程与内存关联char* start = (char*)attachShm(shmId);printf("attach success, address start: %p\n", start);//进程通信while(true){struct shmid_ds sd;shmctl(shmId, IPC_STAT, &sd);printf("client say : %s, cpid[%d], key[0x%x]\n", start, sd.shm_cpid, sd.shm_perm.__key);            sleep(1);}//sleep(9);//删除前最好取消关联detachShm(start);//删除共享内存delShm(shmId);return 0;
}

输出结果:

3.3 共享内存的缺点以及数据保护

根据上一节的输出结果，进行分析

首先client进程每五秒写到共享内存一次，而server每隔一秒向共享内存中读取。
 
这也说明共享内存方式通信是有缺点的：不给我进行同步和互斥操作的，对数据没有进行保护。
也就是不像管道那样，一份数据写完，读端再读。
 
对共享内存进行保护，需要写完，通知读端，再读。
没通知server的时候，让server进行阻塞状态。
通过在外层再设计一层命名管道，写端写入一个字符，如果读端收到那么就从共享内存中读取，没有收到就进入阻塞状态（read读不到数据）

#include <iostream>
#include <sys/shm.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <cstring>
#include <unistd.h>
#include <fcntl.h>
#include <cassert>
#include <string>#define SHMSIZE 4026
#define PATHNAME "."
#define PROJ_ID 0x66
#define FIFOPATH "mypipe"void createFifo(const std::string& path)
{umask(0);int n = mkfifo(path.c_str(), 0666);if(n < 0){std::cout << "mkfifo:" << errno << ":" << strerror(errno) << std::endl;exit(-1);}
}void removeFifo(const char* path)
{if(unlink(path) == -1){std::cout << "unlink:" << errno << ":" << strerror(errno) << std::endl;exit(-1);}
}key_t getKey(const char* path, int proj_id)
{key_t k = ftok(path, proj_id);if(k < 0){std::cout << "ftok:" << errno << ":" << strerror(errno) << std::endl;exit(-1);}return k;
}int getShmHelp(key_t k, int shmflg)
{int id = shmget(k, SHMSIZE, shmflg);if(id < 0){std::cout << "shmget: " << errno << ":" << strerror(errno) << std::endl;exit(-1);}
}int createShm(key_t k)
{umask(0);return getShmHelp(k, IPC_CREAT | IPC_EXCL | 0600);
}int getShm(key_t k)
{return getShmHelp(k, IPC_CREAT);
}void* attachShm(int shmId)
{void* mem = shmat(shmId, nullptr, 0);if((long long)mem == -1L) //linux 64位{std::cout << "shmat: " << errno << ":" << strerror(errno) << std::endl;exit(-1);}
}void detachShm(void* start)
{if(shmdt(start) == -1){std::cout << "shmdt: " << errno << ":" << strerror(errno) << std::endl;exit(-1);}
}void delShm(int shmId)
{if(shmctl(shmId, IPC_RMID, nullptr) == -1){std::cout << "shmctl: " << errno << ":" << strerror(errno) << std::endl;exit(-1);}
}///
//client
#include "comm.hpp"int main()
{//建立命名管道createFifo(FIFOPATH);//先获取key,用于唯一标识共享内存key_t key = getKey(PATHNAME, PROJ_ID);printf("key:0x%x\n", key);//用户创建共享内存int shmId = createShm(key);printf("shmId:%d\n", shmId);//进程与内存关联char* start = (char*)attachShm(shmId);printf("attach success, address start: %p\n", start);//进程通信const char* message = "hello server, 我是另一个进程，正在和你通信";pid_t id = getpid();//向命名管道中写入数据rint wfd = open(FIFOPATH, O_WRONLY, 0666);int cnt = 1;int circnt = 5;while(circnt--){sleep(5);char sig = 'r';ssize_t s = write(wfd, &sig, sizeof(sig));assert(s == sizeof(char));(void)s;snprintf(start, SHMSIZE, "%s[pid:%d][消息编号:%d]", message, id, cnt++);}//sleep(10);//删除前最好取消关联detachShm(start);close(wfd);//删除共享内存//delShm(shmId);return 0;
}//
//server
#include "comm.hpp"int main()
{//createFifo(FIFOPATH);//先获取key,用于唯一标识共享内存key_t key = getKey(PATHNAME, PROJ_ID);printf("key:0x%x\n", key);//用户创建共享内存int shmId = getShm(key);printf("shmId:%d\n", shmId);//进程与内存关联char* start = (char*)attachShm(shmId);printf("attach success, address start: %p\n", start);//进程通信//如果从命名管道中读到了r,就从共享内存中读取数据int rfd = open(FIFOPATH, O_RDONLY, 0666);while(true){char sig;ssize_t s = read(rfd, &sig, sizeof(sig));if(s == 0){printf("read:%d\n", s);break;}if(sig == 'r' && s > 0){struct shmid_ds sd;shmctl(shmId, IPC_STAT, &sd);printf("client say : %s, cpid[%d], key[0x%x]\n", start, sd.shm_cpid, sd.shm_perm.__key);            }sleep(1);}//sleep(9);//删除前最好取消关联detachShm(start);//删除共享内存delShm(shmId);close(rfd);//删除命名管道removeFifo(FIFOPATH);return 0;
}

 

3.4 共享内存的优点

共享内存是所有通信方式中速度最快的。
因为其能大大降低数据的拷贝次数。

同样的数据通信，管道实现和共享内存实现。考虑键盘、显示器，共享内存会有2+2次拷贝。
只需要将数据从输入拷贝到共享内存，再从内存直接放到标准缓冲区，再到屏幕。

而管道通信，在进入管道多了要经过用户层面上的缓冲区（FILE），多了两次拷贝。

所以如果只考虑管道和共享内存通信传输大量的数据的话，共享内存能快不少。

 

3.5 信号量以及与共享内存有关的概念

什么是信号量？
信号量本身是一个计数器，通常用来表示公共资源中，资源数量多少的问题的。
 
公共资源：是可以被多个进程访问的资源。
1、值得注意的是公共资源是需要保护的，不然会出现数据不一致的问题。（而对于数据保护，提出了一些方法，但这些方法也会造成问题，所以问题没有解决，最后只是到了被接受的程度）
2、被保护起来的公共资源称为临界资源。
3、进程访问临界资源的代码，称为临界区，而其它的称为非临界区。
4、共享资源要么是一个整体，要么划分一个一个资源部分。
 
如何保护共享资源呢？
互斥与同步。
互斥也就是当一方访问时，另一方阻塞。
同步的情况是一种原子性，比如银行的两个账户各有1000元，一个账号向另一个账号转账200时，一方要扣200，另一方要加200，而如果转账失败，要保证各个账户金额不变。
 
信号量的作用
打个比方，比如电影院买票，一部电影每场次座位的数量就是一种信号量，在人们买票的时候都要先访问这个信号量。
也就是进程在访问公共资源前，都必须申请sem信号量。