文章目录
- 1. 进程间通信介绍
- 1.1 进程间通信目的
- 1.2 进程间通信发展
- 1.3 进程间通信分类
- 2. 管道
- 2.1 什么是管道
- 2.2 匿名管道
- 2.3 用 fork 来共享管道原理
- 2.4 站在文件描述符角度 - 深入理解管道
- 2.5 站在内核角度 - 管道本质
- 2.6 管道读写规则
- 2.7 管道特点
- 3. 命名管道
- 3.1 匿名管道与命名管道的区别
- 3.2 命名管道的打开规则
- 例：用命名管道实现 server & client 通信
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 stdin
while (fgets(buf, 100, stdin))
{
len = strlen(buf);
// write into pipe
if (write(fds[1], buf, len) != len)
{
perror("write to pipe");
break;
}
memset(buf, 0x00, sizeof(buf));
// read from pipe
if ((len = read(fds[0], buf, 100)) == -1)
{
perror("read from pipe");
break;
}
// write to stdout
if (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;
}
else
break;
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 write
printf("pipefd[0]: %d, pipefd[1]: %d\n", pipefd[0], pipefd[1]); // 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);
if (rid == id)
{
printf("exit code: %d, exit signal: %d\n", WEXITSTATUS(status), status & 0x7F);
}
return 0;
}
2.6 管道读写规则
- 当没有数据可读时
- 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 将不再保证写入的原子性。
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_server
pipe_server:PipeServer.cc
g++ -o $@ $^ -std=c++11
pipe_client:PipeClient.cc
g++ -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;
}
结果：
