文章目录
1、进程间通信
1.1 进程的通信
在一些应用场景下，一定要求着进程之间进行通信，而通信有以下这些：
数据传输：进程间将数据传递给彼此。
资源共享：多个进程共享同一份资源。
通知事件：一个进程向另一个进程发送信息，通知它发生了某种事件。（比如父进程向子进程传递信号，让子进程退出。）
进程控制：一个进程控制另一个进程。（比如debug）
比如在linux中通过命令，ps ajx | grep hello，两个命令分别对应着两个进程，通过管道进行进程通信。（也就是说，为了完成某些业务，我们是需要多进程进行协同的）
1.2 如何让进程间通信？
Linux的主流通信标准有以下：
- POSIX （让通信过程可以跨主机）
- 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);
//第二步：fork
pid_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）信号，关闭父进程。
管道特点：
- 管道的生命周期随进程。
- 管道可以用来进行具有"血缘关系"的进程间进行通信，常用于父子间通信。
- 管道是面向字节流的。
- 管道只允许单向通信 半双工的。（任何时候都是一方向另一方发送数据）
- 互斥和同步机制。（共享资源保护机制）（这个可以和后面共享内存进行比较）
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.
关于共享内存的删除与释放：
共享内存的删除并非直接删除，而是拒绝后续的映射，只有当映射数为0时，才是真正删除释放。
有了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 0x66
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()
{
//先获取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();
//向命名管道中写入数据r
int 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、共享资源要么是一个整体，要么划分一个一个资源部分。
信号量的作用
打个比方，比如电影院买票，一部电影每场次座位的数量就是一种信号量，在人们买票的时候都要先访问这个信号量。
也就是进程在访问公共资源前，都必须申请sem信号量。
689
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
