前言：我们已经知道了进程和文件的基本理论，知道了进程和文件的重要性。进程具有独立性，所以两个进程不能直接通信，那么进程间应该怎样通信呢？我们今天来解开其中的面纱。
目录
进程间通信
进程间通信目的
数据传输：一个进程需要将它的数据发送给另一个进程
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。
我们往往需要进程间的互相协同去完成一件事情，所以才会需要进程通信。而进程间为了维护自己的独立性双方都不能直接提供一个共享内存，如果有一方进行提供内存，另一个进程就可以进行读写数据反而破坏了进程独立性，这时我们就需要一个话事人提供共享内存——操作系统。
操作系统有不同提供内存的方式，所以就决定了有不同的通信方法！！！
进程间通信发展
管道
System V进程间通信
POSIX进程间通信
进程间通信分类
管道（最古老，但是是最经典的通信方式）
匿名管道pipe
命名管道
System V IPC(只支持本主机内的通信)
System V 消息队列
System V 共享内存
System V 信号量
POSIX IPC(主流通信方式，支持远端网络通信)
消息队列
共享内存
信号量
互斥量
条件变量
读写锁
管道
什么是管道
管道是Unix中最古老的进程间通信的形式。我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”。
我们之前学习过在操作系统创建进程时都会创建对应的结构体task_struct，而结构体中有一个结构体指针指向文件结构体，文件结构体struct files_struct中有一个文件描述符表。当我们以读方式打开，再以写方式打开，因为0，1，2是操作系统默认打开的标准输入输出，所以会在文件描述符队列中创建3和4，也会创建两个文件结构体，但是只有一个缓冲区。
接下来我们创建一个子进程，子进程会继承父进程的task_struct,文件描述符表 ，但是不需要拷贝打开的文件。因为是单纯的浅拷贝，所以文件描述符表中的指针与父进程的相同，所以子进程指向的被打开的文件和父进程是相同的。
进程通信的本质就是让不同的进程看到相同的资源，所以我们的父子进程看到相同的文件资源。3号描述符对应的读端，4号描述符对应的写端。所以我们可以让父进程以4号文件描述符进行写入缓冲区。子进程以3号文件描述符读取缓冲区内容。这就完成了基于文件的进程间通信，这就叫做管道。
为了让管道通信更简单，管道只支持单项通信，所以当父子进程都打开读写端后，父进程关闭写端，子进程关闭读段，就可以进行父进程写子进程读的通信了。
struct file使用的是引用计数，所以文件允许多个指针进行指向文件，当计数值为0时才会销毁文件以及缓冲区。struct file允许多个进程通过指针指向。
为了支持我们进行管道通信，系统提供pipe接口。
匿名管道
#include <unistd.h>
功能:创建一无名管道
原型
int pipe(int fd[2]);
参数
fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0，失败返回错误代码
其中参数是一个输出型参数，当系统调用成功时我们希望得到读写的文件描述符，就会放到pipfd的数组中。pipe会提供一个类似文件缓冲区的空间，但是不需要向磁盘中刷新，磁盘中不存在的文件。这种文件属于内存级文件没有名字，所以我们将他称为匿名文件！！！
匿名管道只能进行具有血缘关系的进程进行通信，常用于父子进程进行通信。其原理就是通过继承的方式进行通信。
pipe管道中的读端fd[0]，写端为fd[1]，现在我们进入代码测试：
#include<stdio.h>
#include<unistd.h>
int main()
{
int pipefd[2];
int n = pipe(pipefd);
if(n < 0) return 1;
printf("pipefd[0]: %d, pipefd[1]: %d\n", pipefd[0], pipefd[1]);
return 0;
}
我们现在程序中默认子进程为写段，父进程为读端。所以我们要将子进程的读端进行关闭父进程的写端关闭，然后我们就可以进行通信了：
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<sys/wait.h>
#include<sys/types.h>
void writer(int wfd)
{
const char *str = "hello father, I am child";
char buffer[128];
int cnt = 0;
pid_t pid = getpid();
while(1)
{
snprintf(buffer, sizeof(buffer), "message: %s, pid: %d, count: %d\n", str, pid, cnt);
write(wfd, buffer, strlen(buffer));
cnt++;
sleep(1);
}
}
void reader(int rfd)
{
char buffer[1024];
while(1)
{
ssize_t n = read(rfd, buffer, sizeof(buffer)-1);
(void)n;
printf("father get a message: %s", buffer);
}
}
int main()
{
// 1.
int pipefd[2];
int n = pipe(pipefd);
if(n < 0) return 1;
printf("pipefd[0]: %d, pipefd[1]: %d\n", pipefd[0]/*read*/, pipefd[1]/*write*/); // 3, 4
// 2.
pid_t id = fork();
if(id == 0)
{
//child: w
close(pipefd[0]);
writer(pipefd[1]);
exit(0);
}
// father: r
close(pipefd[1]);
reader(pipefd[0]);
wait(NULL);
return 0;
}
管道读写规则
当我们在读写管道时一定会有一些特殊情况：
1.管道内部没有数据时并且子进程不关闭自己写端的fd读端父进程就要阻塞等待，直到pipe有数据。
2.管道内部被写满并且读端不关闭自己的fd，写端写满之后就要阻塞等待。
3.对于写端而言：不写了或关闭了pipe，读端会将pipe中的数据读完最后读到返回值为0表示读结束，如同读到了文件结尾。
4.读端不读了或者关闭但是写端在写OS直接终止写入的进程，通过信号13SIGPIPE信号杀掉进程。
现在我们写一段代码，让子进程持续写入，父进程读取10s后直接退出，查看一下退出信号：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
// child
void writer(int wfd)
{
const char *str = "hello father, I am child";
char buffer[128];
int cnt = 0;
pid_t pid = getpid();
while(1)
{
sleep(1);
// snprintf(buffer, sizeof(buffer), "message: %s, pid: %d, count: %d\n", str, pid, cnt);
// write(wfd, buffer, strlen(buffer));
char c = 'A';
write(wfd, &c, 1);
cnt++;
printf("cnt: %d\n", cnt);
// if(cnt == 10) break;
}
close(wfd);
}
// father
void reader(int rfd)
{
char buffer[1024];
int cnt = 10;
while(1)
{
// sleep(5);
ssize_t n = read(rfd, buffer, sizeof(buffer)-1);
if(n > 0)
printf("father get a message: %s, n : %ld\n", buffer, n);
else if(n == 0)
{
printf("read pipe done, read file done!\n");
break;
}
else
break;
cnt--;
if(cnt == 0) break;
}
close(rfd);
printf("read endpoint close!\n");
}
int main()
{
// 1.
int pipefd[2];
int n = pipe(pipefd);
if(n < 0) return 1;
printf("pipefd[0]: %d, pipefd[1]: %d\n", pipefd[0]/*read*/, pipefd[1]/*write*/); // 3, 4
// 2.
pid_t id = fork();
if(id == 0)
{
//child: w
close(pipefd[0]);
writer(pipefd[1]);
exit(0);
}
// father: r
close(pipefd[1]);
reader(pipefd[0]);
int status = 0;
pid_t rid = waitpid(id, &status, 0);
// wait(NULL);
if(rid == id)
{
printf("exit code: %d, exit signal: %d\n", WEXITSTATUS(status), status&0x7F);
}
return 0;
}当没有数据可读时
O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。
当管道满的时候
O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
O_NONBLOCK enable：调用返回-1，errno值为EAGAIN
如果所有管道写端对应的文件描述符被关闭，则read返回0
如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE,进而可能导致write进程
退出
当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。
当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。
管道特点
1.只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。
2.管道提供流式服务
3.一般而言，进程退出，管道释放，所以管道的生命周期随进程
4.一般而言，内核会对管道操作进行同步与互斥
5.管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道
命名管道
管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。命名管道是一种特殊类型的文件 。
当我们在对不同的进程进行进程通信时，我们需要先创建两个进程，这两个进程都有对应的task_struct,而每个进程里面有对应的文件描述符表。我们创建一个命名管道就可实现进程通信。
这种命名管道文件我们需要通过文件的路径+文件名进行查找。
创建一个命名管道
命名管道可以从命令行上创建，命令行方法是使用下面这个命令：
$ mkfifo filename
我们可以使用重定向，向管道中写入内容然后再使用cat读取管道内容：
删除管道使用rm即可。
命名管道也可以从程序里创建，相关函数有：
int mkfifo(const char *filename,mode_t mode);
filename是管道名称，需要可以带指定路径，默认是在当前路径下创建。mode是管道文件的权限。
返回值为0表示创建管道成功，创建失败返回-1并且设置错误错误码。
创建简单命名管道:
int main(int argc, char *argv[])
{
mkfifo("p2", 0644);
return 0;
}如果我们已经在此路径下有自己的命名管道了，再次运行此程序时会直接报错退出，除非我们将管道删除重新运行才可以正常进行。说明每个路径下只能有一个相同的命名管道。
实现命名管道代码
头文件内容：
//头文件
#ifndef __COMM_HPP__
#define __COMM_HPP__
#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
using namespace std;
#define Mode 0666
#define Path "./fifo"
class Fifo
{
public:
Fifo(const string &path) : _path(path)
{
umask(0);
int n = mkfifo(_path.c_str(), Mode);
if (n == 0)
{
cout << "mkfifo success" << endl;
}
else
{
cerr << "mkfifo failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
}
}
~Fifo()
{
int n = unlink(_path.c_str());
if (n == 0)
{
cout << "remove fifo file " << _path << " success" << endl;
}
else
{
cerr << "remove failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
}
}
private:
string _path; // 文件路径+文件名
};
#endif进程写端：
#include "Comm.hpp"
int main()
{
int wfd = open(Path, O_WRONLY);
if (wfd < 0)
{
cerr << "open failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
return 1;
}
string inbuffer;
while (true)
{
cout << "Please Enter Your Message# ";
std::getline(cin, inbuffer);
if(inbuffer == "quit") break;
ssize_t n = write(wfd, inbuffer.c_str(), inbuffer.size());
if (n < 0)
{
cerr << "write failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
break;
}
}
close(wfd);
return 0;
}进程读端：
#include "Comm.hpp"
#include <unistd.h>
int main()
{
Fifo fifo(Path);
int rfd = open(Path, O_RDONLY);
if (rfd < 0)
{
cerr << "open failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
return 1;
}
// 如果我们的写端没打开，先读打开，open的时候就会阻塞，直到把写端打开，读open才会返回
cout << "open success" << endl;
char buffer[1024];
while (true)
{
ssize_t n = read(rfd, buffer, sizeof(buffer) - 1);
if (n > 0)
{
buffer[n] = 0;
cout << "client say : " << buffer << endl;
}
else if (n == 0)
{
cout << "client quit, me too!!" << endl;
break;
}
else
{
cerr << "read failed, errno: " << errno << ", errstring: " << strerror(errno) << endl;
break;
}
}
close(rfd);
return 0;
}
这样我们就可以通过命名管道实现对没有血缘关系的两个进程进行通信。
命名管道的打开规则
如果当前打开操作是为读而打开FIFO时
O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO
O_NONBLOCK enable：立刻返回成功
如果当前打开操作是为写而打开FIFO时
O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO
O_NONBLOCK enable：立刻返回失败，错误码为ENXIO
匿名管道与命名管道的区别
匿名管道由pipe函数创建并打开。
命名管道由mkfifo函数创建，打开用open
FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创建与打开的方式不同，一但这些工作完成之后，它们具有相同的语义。
以上就是今天的内容，感谢大家的观看！！！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
