1.什么是进程间通信
Unix/Linux系统中每个进程都拥有独立的4G字节大小的虚拟内存空间。其中高地址的1G字节被映射到相同的物理内存区域，用于保存内核代码和数据。低地址的3G字节作为保存用户代码和数据的用户空间，被映射到彼此不同物理内存。因此同一个虚拟内存地址，在不同的进程中，会被映射到不同的物理内存区域，在多个进程之间以交换虚拟内存地址的方式交换数据是不可能的。鉴于进程之间天然的内存壁垒，为了能够在不同进程之间高效地交换数据，需要有一种专门的机制，这就是所谓的进程间通信(Inter-Process Communication, IPC)。
2.简单的进程间通信
1)命令行参数
进程1组织命令行参数->execl->进程2处理命令行参数
进程1：username，password
execl(..., "login", username, password, NULL)
| |
进程2： argv[1] argv[2]
2)环境变量
进程1组织环境变量->execle->进程2处理环境变量
进程1：username，password
sprintf(envp[0], "USERNAME=%s", username);
sprintf(envp[1], "PASSWORD=%s", password);
execle(..., envp);
进程2：envp[0]->USERNAME=zhangsan
envp[1]->PASSWORD=stx
3)wait/waitpid
进程1->fork/vfork+exec->进程2
wait/waitpid(..., &status); main->return ...;
^ exit/_exit/_Exit(...)
|_________|
4)内存映射文件
进程1[虚拟内存]-->文件区域<--[虚拟内存]进程2
^ ^
|______________________|
5)信号
进程1----信号+附加数据--->进程2
3.传统的进程间通信
1)有名管道
进程1<-管道文件->进程2
|
有i节点没有数据块，内存文件
全双工通信
2)无名管道
/ -无名管道-> \
父进程 子进程
\ <-无名管道- /
半双工通信
4.XSI进程间通信(SVR4)
1)消息队列：进程1---消息3|消息2|消息1-->进程2
2)共享内存：进程1[虚拟内存]->物理内存<-[虚拟内存]进程2
3)信号量集：多个进程竞争有限的资源
5.套接字进程间通信(BSD)
进程1<-本地套接字文件->进程2
|
有i节点没有数据块，内存文件
以一种统一的编程模式和接口库，处理网络和本机通信。
6.有名管道
创建有名管道文件
#include <sys/stat.h>
int mkfifo(const char* pathname, model_t mode);
成功返回0，失败返回-1。
pathname - 文件路径
mode - 权限模式
打开、关闭、读取和写入有名管道文件的方法与读写普通文件无异：open/read/write/close。
代码：wfifo.c、rfifo.c
/* wfifo.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#define FIFO_FILE "myfifo"
int main(void) {
printf("创建管道...\n");
if (mkfifo(FIFO_FILE, 0666) == -1) {
perror("mkfifo");
return -1;
}
printf("打开管道...\n");
int fd = open(FIFO_FILE, O_WRONLY);
if (fd == -1) {
perror("open");
return -1;
}
printf("发送数据...\n");
for (;;) {
printf("> ");
char buf[1024];
fgets(buf, sizeof(buf) / sizeof(buf[0]), stdin);
if (!strcmp(buf, "!\n"))
break;
if (write(fd, buf, strlen(buf) * sizeof(buf[0])) == -1) {
perror("write");
return -1;
}
}
printf("关闭管道...\n");
if (close(fd) == -1) {
perror("close");
return -1;
}
printf("删除管道...\n");
if (unlink(FIFO_FILE) == -1) {
perror("unlink");
return -1;
}
printf("完成！\n");
return 0;
}
/* rfifo.c */
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#define FIFO_FILE "myfifo"
int main(void) {
printf("打开管道...\n");
int fd = open(FIFO_FILE, O_RDONLY);
if (fd == -1) {
perror("open");
return -1;
}
printf("接收数据...\n");
for (;;) {
char buf[1024] = {};
ssize_t rb = read(fd, buf, sizeof(buf) - sizeof(buf[0]));
if (rb == -1) {
perror("read");
return -1;
}
// 写端已关闭且管道无数据
if (!rb)
break;
printf("< %s", buf);
}
printf("关闭管道...\n");
if (close(fd) == -1) {
perror("close");
return -1;
}
printf("完成！\n");
return 0;
}编程模型
进程A 进程B
创建管道 mkfifo
打开管道 open 打开管道
读写管道 read/write 读写管道
关闭管道 close 关闭管道
删除管道 unlink
7.无名管道
#include <unistd.h>
int pipe(int pipefd[2]);
成功返回0，失败返回-1。
pipefd - 输出两个文件描述符：
pipefd[0]表示管道的读端
pipefd[1]表示管道的写端
1)父进程调用pipe函数在系统内核中创建无名管道对象，同时得到与该对象相关联的两个文件描述符，一个用于读取，另一个用于写入；
2)父进程调用fork函数，创建子进程，子进程复制父进程的文件描述符表，因此子进程也同样拥有可用于读写管道对象的两个文件描述符。
3)负责写数据进程关闭管道读端，即pipefd[0]，而负责读数据的进程关闭管道的写端，即pipefe[1]；
4)父子进程通过各自持有的文件描述符，分别向管道写入和读取数据，待完成通信后再各自关闭所持有的文件描述符，内核中的无名管道对象即被释放。
代码：pipe.c
/* pipe.c */
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
int main(void) {
printf("父进程：创建管道...\n");
int pipefd[2];
if (pipe(pipefd) == -1) {
perror("pipe");
return -1;
}
printf("父进程：创建子进程...\n");
pid_t pid = fork();
if (pid == -1) {
perror("fork");
return -1;
}
if (pid == 0) {
printf("子进程：关闭写端...\n");
close(pipefd[1]);
printf("子进程：接收数据...\n");
for(;;) {
char buf[2014] = {};
ssize_t rb = read(pipefd[0], buf, sizeof(buf) - sizeof(buf[0]));
if (rb == -1) {
perror("read");
return -1;
}
if (!rb)
break;
fputs(buf, stdout);
}
printf("子进程：关闭读端...\n");
close(pipefd[0]);
printf("子进程：完成！\n");
return 0;
}
printf("父进程：关闭读端...\n");
close(pipefd[0]);
printf("父进程：发送数据...\n");
for (;;) {
char buf[1024];
fgets(buf, sizeof(buf) / sizeof(buf[0]), stdin);
if (!strcmp(buf, "!\n"))
break;
if (write(pipefd[1], buf, strlen(buf) * sizeof(buf[0])) == -1) {
perror("write");
return -1;
}
}
printf("父进程：关闭写端...\n");
close(pipefd[1]);
if (wait(NULL) == -1) {
perror("wait");
return -1;
}
printf("父进程：完成！\n");
return 0;
}8.基于管道通信的特殊情况
1)从写端已被关闭的管道中读取
只要管道缓冲区中还有数据，依然可被正常读取，一直读到缓冲区空，这时read函数会返回0（既不是返回-1也不是阻塞），如同读到文件尾。
2)向读端已被关闭的管道中写入
会直接触发SIGPIPE(13)信号。该信号的默认操作是终止执行写入动作的进程。但如果执行写入动作的进程已经事先将SIGPIPE(13)信号设置为忽略或捕获，这时虽然进程不会因为写入无读端的管道而被终止，但write函数会返回-1，并置errno为EPIPE。
3)在/usr/include/linux/limits.h头文件中定义的PIPE_BUF宏(4096)表示管道写缓冲区的大小。如果写管道时发现缓冲区中的空闲空间不足以容纳此次write调用所要写入的字节数，则write函数会阻塞，直到缓冲区中的空闲空间变得足够大为止。如果同时有多个进程向同一个管道写入数据，而每次调用write函数写入的字节数都不大于BUF_SIZE，则这些write操作不会互相穿插(原子化，atomic)，反之单次写入的字节数超过了BUF_SIZE，则它们的write操作可能会相互穿插。读取一个缓冲区为空的管道，只要其写端没有被关闭，读操作就会阻塞，除非该读文件描述符被设置为非阻塞(O_NONBLOCK)，此时会立即返回失败，并置errno为EAGAIN。
9.管道符号的原理
命令1 | 命令2 | 命令3 ...
| | |
输出>管道>输入
输出>管道>输入
输出>...
A | B
Shell进程：
int pipefd[2];
pipe(pipefd); // 创建无名管道
vfork(); // 产生一个子进程1
子进程1:
close(pipefd[0]); // 关闭无名管道的读端
dup2(pipefd[1], STDOUT_FILENO); // 写端=标准输出
exec(A) // 创建A进程，继承了原进程的文件描述符表
// 在A进程中，写端=标准输出
// printf/puts将数据写入无名管道的写端
vfork(); // 产生一个子进程2
子进程2:
close(pipefd[1]); // 关闭无名管道的写端
dup2(pipefd[0], STDIN_FILENO); // 读端=标准输入
exec(B) // 创建B进程，继承了原进程的文件描述符表
// 在B进程集中，读端=标准输入
// scanf/gets从无名管道的读端读取数据
A和B就成为协作进程，A写入数据进管道，B从管道中读取A写入的数据。
代码：shell.c
/* shell.c */
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>
int main(void) {
// 创建无名管道
// 无名管道读端：pipefd[0]
// 无名管道写端：pipefd[1]
int pipefd[2];
if (pipe(pipefd) == -1) {
perror("pipe");
return -1;
}
// 创建子进程，执行输出进程
pid_t pid = vfork();
if (pid == -1) {
perror("vfork");
return -1;
}
if (pid == 0) {
// 关闭无名管道读端
close(pipefd[0]);
// 复制无名管道写端到标准输出
if (dup2(pipefd[1],
STDOUT_FILENO) == -1) {
perror("dup2");
_exit(-1);
}
// 创建输出进程
// 该进程所有向标准输出的写操作
// 实际都是在写入无名管道的写端
if (execl("./output", "output", NULL) == -1) {
perror("execl");
_exit(-1);
}
}
// 创建子进程，执行输入进程
if ((pid = vfork()) == -1) {
perror("vfork");
return -1;
}
if (pid == 0) {
// 关闭无名管道写端
close(pipefd[1]);
// 复制无名管道读端到标准输入
if (dup2(pipefd[0], STDIN_FILENO) == -1) {
perror("dup2");
_exit(-1);
}
// 创建输入进程
// 该进程所有从标准输入的读操作
// 实际都是在读取无名管道的读端
if (execl("./input", "input", NULL) == -1) {
perror("execl");
_exit(-1);
}
}
close(pipefd[0]);
close(pipefd[1]);
for (;;)
if (wait(NULL) == -1) {
if (errno != ECHILD) {
perror("wait");
return -1;
}
break;
}
return 0;
}
扫一扫
6964
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
