进程间通信——管道

一、进程间通信
1、本质：让两个不相干的进程看到同一块资源，这个资源肯定是操作系统提供的
2、目的
    ·数据传输：一个进程需要将它的数据发给另一个进程
    ·资源共享：多个进程之间共享同样的资源

    ·通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（例如：子进程终止时要通知父进程）
    ·进程控制：有些进程希望完全控制另一个进程的执行，此时控制进程希望能够拦截另一个进程所有陷入和异常，并能够及时知道它的状态改变
3、分类
（1）管道
    ·匿名管道

    ·命名管道

（2）System V IPC
    ·System V 消息队列

    ·System V 共享内存

    ·System V 信号量

（3）POSIX IPC
    ·消息队列

    ·共享内存

    ·信号量

    ·互斥量

    ·条件变量

    ·读写锁

二、管道
1、概念
    ·管道是Unix中最古老的进程间通信的形式

    ·从一个进程链接到另一个进程间的一个数据流



2、匿名管道：创建一个无名管道
int pipe(int fd[2]);
其中：fd为文件描述符数组，fd[0]表示读端，fd[1]表示写端
          成功返回0，失败返回错误代码



1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #include<unistd.h>
5
6 int main()
7 {
8 int fds[2];
9 char buf[100];
10 int len;
11
12 if(pipe(fds) == -1){
13 perror("make pipe"),exit(1);
14 }
15 //read from stdin
16 while(fgets(buf,100,stdin)){
17 len = strlen(buf);
18 //write into pipe
19 if(write(fds[1],buf,len) != len){
20 perror("write to pipe");
21 break;
22 }
23 memset(buf,0x00,sizeof(buf));
24 //read from pipe
25 if((len = read(fds[0],buf,100)) == -1){
26 perror("read from pipe");
27 break;
28 }
29 //write to stdout
30 if(write(1,buf,len) != len){
31 perror("write to stdout");
32 break;
33 }
34 }
35 }



3、用fork来共享管道原理
（1）父进程创建管道（父进程调用pipe开辟管道，得到两个文件描述符分别指向管道的读端和写端）



（2）父进程fork出子进程（父进程调用fork创建子进程，那么子进程也有两个文件描述符指向同一个管道）



（3）父进程关闭fd[0]，子进程关闭fd[1]（父进程关闭管道读端，子进程关闭管道写端。父进程往管道里写，子进程从管道里读。管道是用环形队列实行的，数据从写端流入，从读端流出，这样就实现了进程间通信）



1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<string.h>
4 #include<unistd.h>
5
6 int main()
7 {
8 int fds[2];
9 if(pipe(fds) == -1){
10 perror("pipe");
11 return 1;
12 }
13 pid_t pid = fork();
14 if(pid < 0){
15 perror("fork");
16 return 2;
17 }
18 else if(pid > 0){//parent write
19 close(fds[0]);
20 char *argv = "child , I am your father";
21 int i = 4;
22 while(i--){
23 write(fds[1],argv,strlen(argv));
24 sleep(1);
25 }
26 }
27 else{//child read
28 close(fds[1]);
29 char buf[1024];
30
31 while(1){
32 size_t s = read(fds[0],buf,sizeof(buf));
33 if(s > 0){
34 buf[s] = 0;
35 printf("child : %s\n",buf);
36 }
37 else if(s == 0){
38 printf("child : parent did not speak!\n");
39 break;
40 }
41 else{
42 perror("read");
43 return 3;
44 }
45 }
46 }
47 return 0;
48 }


4、管道读写规则



5、匿名管道的特点
（1）只有用于具有共同祖先的进程（具有亲缘关系的进程）之间通信；通常一个管道由一个进程创建，然后该进程调用fork，此后，父子进程之间就可以应用该管道
（2）管道可以提供流式服务
（3）一般情况，进程退出，管道释放，所以管道的生命周期随进程
（4）一般而言，内核会对管道操作进行同步和互斥
（5）管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道
6、命名管道
·管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信
·如果我们想在不想关的进程之间交换数据，可以使用FIFO文件来工作，它被称为命名管道
·命名管道是一种特殊类型的文件
创建命名管道
*可以从命令行上创建，命令行方法是使用命令：
mkfifo filename



*可以从程序里创建，相关函数： 1 #include<sys/types.h>
2 #include<sys/stat.h>
3
4 int mkfifo(const char *filename,mode_t mode);返回值：成功返回0，失败返回-1
参数：filename为创建出的管道名称
          mode为这个管道具有的权限 1 #include<sys/types.h>
2 #include<sys/stat.h>
3 #include<stdio.h>
4
5
6 int main()
7 {
8 if(mkfifo("fifo",0644) == -1){
9 perror("mkfifo");
10 return 1;
11 }
12 return 0;
13 }



7、匿名管道和命名管道的区别
（1）匿名管道由pipe函数创建
（2）命名管道由mkfifo函数创建，打开用open
（3）FIFO（命名管道）与pipe（匿名管道）之间唯一的区别是打开的方式不同，一旦这些工作完成之后，它们具有相同的语义
例：用命名管道实现
Makefile文件 1 .PHONY:all
2 all:client server
3 client:client.c
4 gcc client.c -o client
5 server:server.c
6 gcc server.c -o server
7 .PHONY:clear
8 clear:
9 rm -f client server
client.c 1 #include<stdio.h>
2 #include<sys/types.h>
3 #include<sys/stat.h>
4 #include<fcntl.h>
5 #include<unistd.h>
6 #include<stdlib.h>
7 #include<string.h>
8
9 #define ERR_EXIT(m)\
10 do{\
11 perror(m);\
12 exit(EXIT_FAILURE);\
13 }while(0)
14 int main()
15 {
16 int wfd = open ("mypipe",O_WRONLY);
17 if ( wfd < 0 ){
18 ERR_EXIT("open");
19 }
20 char buf[1024];
21 while(1){
22 buf[0] = 0;
23 printf("please enter : ");
24 fflush(stdout);
25 ssize_t s = read (0,buf,sizeof(buf)-1);
26 if ( s > 0 ){
27 buf[s] = 0;
28 write(wfd,buf,strlen(buf));
29 }
30 else if(s <= 0){
31 ERR_EXIT("read");
32 }
33 }
34 close(wfd);
35 return 0;
36 }
server.c 1 #include<stdio.h>
2 #include<sys/types.h>
3 #include<sys/stat.h>
4 #include<fcntl.h>
5 #include<unistd.h>
6 #include<stdlib.h>
7
8 #define ERR_EXIT(m)\
9 do{\
10 perror(m);\
11 exit(EXIT_FAILURE);\
12 }while(0)
13 int main()
14 {
15 umask(0);
16 if ( mkfifo("mypipe",0644) < 0){
17 ERR_EXIT("mkfifo");
18 }
19 int rfd = open ("mypipe",O_RDONLY);
20 if ( rfd < 0 ){
21 ERR_EXIT("open");
22 }
23 char buf[1024];
24 while(1){
25 buf[0] = 0;
26 printf("please wait...\n");
27 ssize_t s = read (rfd,buf,sizeof(buf)-1);
28 if ( s > 0 ){
29 buf[s-1] = 0;
30 printf("client say : %s\n",buf);
31 }
32 else if(s == 0){
33 printf("client quit,exit now!\n");
34 exit(EXIT_SUCCESS);
35 }
36 else{
37 ERR_EXIT("read");
38 }
39 }
40 close(rfd);
41 return 0;
42 }测试结果：
（1）先运行server，创建出mypipe
（2）再运行client，输入数据进行交流