1. 进程间通信介绍

两个进程间，可以进行“数据”的直接传递吗？不能！进程具有独立性！

进程间通信的本质：先让不同的进程，看到同一份资源（一般都是要由 OS 提供）。

1.1 进程间通信目的

• 数据传输：一个进程需要将它的数据发送给另一个进程。
• 资源共享：多个进程之间共享同样的资源。
• 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
• 进程控制：有些进程希望完全控制另一个进程的执行（如 Debug 进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

1.2 进程间通信发展

• 管道
• System V 进程间通信
• POSIX 进程间通信

1.3 进程间通信分类

• 管道
  • 匿名管道 pipe
  • 命名管道
• System V IPC
  • System V 消息队列
  • System V 共享内存
  • System V 信号量
• POSIX IPC
  • 消息队列
  • 共享内存
  • 信号量
  • 互斥量
  • 条件变量
  • 读写锁

2. 管道

2.1 什么是管道

• 管道是 Unix 中最古老的进程间通信的形式。
• 我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”。

2.2 匿名管道

#include <unistd.h>功能：创建一个无名管道
原型：
int pipe(int fd[2]);
参数：
fd：文件描述符数组，其中fd[0]表示读端，fd[1]表示写端
返回值：成功返回0，失败返回错误代码

实例代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>// 例子：从键盘读取数据，写入管道，读取管道，写到屏幕
int main()
{int fds[2];char buf[100];int len;if (pipe(fds) == -1)perror("make pipe"), exit(1);// read from stdinwhile (fgets(buf, 100, stdin)){len = strlen(buf);// write into pipeif (write(fds[1], buf, len) != len){perror("write to pipe");break;}memset(buf, 0x00, sizeof(buf));// read from pipeif ((len = read(fds[0], buf, 100)) == -1){perror("read from pipe");break;}// write to stdoutif (write(1, buf, len) != len){perror("write to stdout");break;}}return 0;
}

2.3 用 fork 来共享管道原理

2.4 站在文件描述符角度 - 深入理解管道

2.5 站在内核角度 - 管道本质

所以，看待管道，就如同看待文件一样！管道的使用和文件一致，迎合了 “Linux 一切皆文件” 思想。

fork 共享管道测试代码

#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);char c = 'A';write(wfd, &c, 1);cnt++;printf("cnt: %d\n", cnt);}close(wfd);
}// father
void reader(int rfd)
{char buffer[1024];int cnt = 10;while (1){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;}elsebreak;cnt--;if (cnt == 0)break;}close(rfd);printf("read endpoint close!\n");
}int main()
{printf("PIPE_BUF: %d\n", _PC_PIPE_BUF);// 1.int pipefd[2];int n = pipe(pipefd);if (n < 0)return 1;//                                       read       writeprintf("pipefd[0]: %d, pipefd[1]: %d\n", pipefd[0], pipefd[1]); // 3, 4// 2.pid_t id = fork();if (id == 0){// child: wclose(pipefd[0]);writer(pipefd[1]);exit(0);}// father: rclose(pipefd[1]);reader(pipefd[0]);int status = 0;pid_t rid = waitpid(id, &status, 0);if (rid == id){printf("exit code: %d, exit signal: %d\n", WEXITSTATUS(status), status & 0x7F);}return 0;
}

2.6 管道读写规则

1. 当没有数据可读时
   • O_NONBLOCK disable：read 调用阻塞，即进程暂停执行，一直等到有数据来到为止。
   • O_NONBLOCK enable：read 调用返回 -1，errno 值为 EAGAIN。
2. 当管道满的时候
   • O_NONBLOCK disable：write 调用阻塞，直到有进程读走数据。
   • O_NONBLOCK enable：调用返回 -1，errno 值为 EAGAIN。
3. 如果所有管道写端对应的文件描述符被关闭，则 read 返回 0。
4. 如果所有管道读端对应的文件描述符被关闭，则 write 操作会产生信号 SIGPIPE，进而可能导致 write 进程退出。
5. 当要写入的数据量不大于 PIPE_BUF 时，Linux 将保证写入的原子性。
6. 当要写入的数据量大于 PIPE_BUF 时，Linux 将不再保证写入的原子性。

2.7 管道特点

• 只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常，一个管道由一个进程创建，然后该进程调用 fork，此后父、子进程之间就可应用该管道。
• 管道提供流式服务。
• 一般而言，进程退出，管道释放，所以管道的生命周期随进程。
• 一般而言，内核会对管道操作进行同步与互斥。
• 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道。

3. 命名管道

• 命名管道可以从命令行上创建，命令行方法是使用下面这个命令：

  $ mkfifo filename
  

• 命名管道也可以从程序里创建，相关函数有：

  int mkfifo(const char* filename, mode_t mode);
  

创建命名管道：

int main(int argc, char* argv[])
{mkfifo("p2", 0644);return 0;
}

3.1 匿名管道与命名管道的区别

• 匿名管道由 pipe 函数创建并打开。
• 命名管道由 mkfifo 函数创建，打开用 open。
• FIFO（命名管道）与 pipe（匿名管道）之间唯一的区别在于它们创建与打开的方式不同，一旦这些工作完成之后，它们具有相同的意义。

3.2 命名管道的打开规则

• 如果当前打开操作是为读而打开 FIFO 时：
  • O_NONBLOCK disable：阻塞直到有相应进程为写而打开该 FIFO。
  • O_NONBLOCK enable：立刻返回成功。
• 如果当前打开操作是为写而打开 FIFO 时：
  • O_NONBLOCK disable：阻塞直到有相应进程为读而打开该 FIFO。
  • O_NONBLOCK enable：立刻返回失败，错误码为 ENXIO。

例：用命名管道实现 server & client 通信

$ ls -l
total 16
-rw-rw-r-- 1 ubuntu ubuntu 1009 May  4 17:16 Comm.hpp
-rw-rw-r-- 1 ubuntu ubuntu  193 May  4 15:14 Makefile
-rw-rw-r-- 1 ubuntu ubuntu  656 May  4 17:44 PipeClient.cc
-rw-rw-r-- 1 ubuntu ubuntu  929 May  4 17:44 PipeServer.cc

Makefile：

$ cat Makefile 
.PHONY:all
all:pipe_client pipe_serverpipe_server:PipeServer.ccg++ -o $@ $^ -std=c++11
pipe_client:PipeClient.ccg++ -o $@ $^ -std=c++11.PHONY:clean
clean:rm -f pipe_client pipe_server

Comm.hpp：

#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

PipeServer.cc：

#include "Comm.hpp"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 sat : " << 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;
}

PipeClient.cc：

#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;
}

结果：

---

END