Linux下的系统编程——进程间的通信（九）

 一、进程间通信常用方式

IPC方式：

        Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC,InterProcess Communication)。
 

        在进程间完成数据传递需要借助操作系统提供特殊的方法，如:文件、管道、信号、共享内存、消息队列、套接字、命名管道等。随着计算机的蓬勃发展，一些方法由于自身设计缺陷被淘汰或者弃用。现今常用的进程间通信方式有:

1.管道（使用最简单)

2.信号(开销最小)

3.共享映射区(无血缘关系)

4.本地套接字(最稳定)

二、管道

1.概念：

      

         管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。有如下特质:

（1）.其本质是一个伪文件(实为内核缓冲区)

（2）.由两个文件描述符引用，一个表示读端，一个表示写端，只能一次读取。

（3）.规定数据从管道的写端流入管道，从读端流出，单向流动。

管道的原理:  管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。

管道的局限性:

        1）数据不能进程自己写，自己读。·

        2）管道中数据不可反复读取。一旦读走，管道中不再存在。

        3）采用半双工通信方式，数据只能在单方向上流动。

        4）只能在有公共祖先的进程间使用管道

常用的通信方式： 单工通信、半双工通信、全双工通信

创建管道文件：

（不占用磁盘空间）

*2.pipe函数：

函数功能：创建，并打开管道。

    int pipe(int fd[2]);

    参数：    

        fd[0]: 读端。

        fd[1]: 写端。

    返回值：

         成功： 0

         失败： -1 errno

管道通信：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>void sys_err(const char *str)
{perror(str);exit(1);
}int main(int argc, char *argv[])
{int ret,re;int fd[2];pid_t pid;char *str = "hello pipe\n";char buf[1024];ret = pipe(fd);if(ret == -1)sys_err("pipe error");pid = fork();if(pid > 0){            //父进程close(fd[0]);       //关闭读段write(fd[1],str,strlen(str));//写入数据sleep(1);close(fd[1]);            //关闭写段}else if(pid == 0){        //子进程close(fd[1]);          //关闭写段re = read(fd[0],buf,sizeof(buf)); //读取数据write(STDOUT_FILENO,buf,re);      //写到屏幕上close(fd[0]);        //关闭读段}return 0;}

*3.管道的读写行为：

读管道：
        1. 管道有数据，read返回实际读到的字节数。

        2. 管道无数据：    

                        1）无写端，read返回0 （类似读到文件尾）

                        2）有写端，read阻塞等待。

写管道：
        1. 无读端， 异常终止。 （SIGPIPE导致的）

        2. 有读端：    

                        1） 管道已满， 阻塞等待

                        2） 管道未满， 返回写出的字节个数。

 1）读管道，管道无数据（无写端）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>void sys_err(const char *str)
{perror(str);exit(1);
}int main(int argc, char *argv[])
{int ret,re;int fd[2];pid_t pid;char *str = "hello pipe\n";char buf[1024];ret = pipe(fd);if(ret == -1)sys_err("pipe error");pid = fork();if(pid > 0){            //父进程close(fd[0]);       //关闭读段//	write(fd[1],str,strlen(str));//写入数据close(fd[1]);            //关闭写段}else if(pid == 0){        //子进程close(fd[1]);          //关闭写段re = read(fd[0],buf,sizeof(buf)); //读取数据printf("child read ret =%d\n",ret);write(STDOUT_FILENO,buf,re);      //写到屏幕上close(fd[0]);        //关闭读段}return 0;}

read返回0

4.父子间进程 ：

        使用管道实现父子进程间通信，完成:ls | wc -l。假定父进程实现ls，子进程实现wc

ls | wc -l命令：

 实现流程：

（1）父进程创建管道 pipe()

（2）父进程创建子进程 fork()

（3）设置父进程执行ls命令，子进程执行wc命令 execlp()

（4）设置父子进程通过管道的单项流动(设置指向标准输出的指向管道)  dup2()

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>void sys_err(const char *str)
{perror(str);exit(1);
}int main(int argc,char *argv[])
{/***************dup2();fork();pipe();execlp();****************/int fd[2]; int ret;pid_t pid;//父进程创建管道ret = pipe(fd);if(ret == -1){sys_err("pipe error");}//父进程创建子进程 pid = fork();if(pid == -1){sys_err("fork error");}else if(pid > 0){close(fd[1]);                  //关闭写，设置单项流动dup2(fd[0],STDIN_FILENO);      //设置读管道信息execlp("wc","wc","-l",NULL);        //设置子进程wc命令sys_err("execlp wc error");}else if(pid == 0){close(fd[0]);                  //关闭读，设置单项流动dup2(fd[1],STDOUT_FILENO);     //设置写操作指向管道execlp("ls","ls",NULL);        //设置父进程执行ls命令sys_err("execlp ls error");}return 0;
}

 

 5.兄弟间进程通信：

使用管道实现兄弟进程间通信，完成:ls | wc -l。假定父进程实现ls，子进程实现wc

 实现流程：

（1）父进程创建管道 pipe()

（2）父进程创建俩个（兄弟）子进程 fork()

（3）设置兄进程执行ls命令，第进程执行wc命令 execlp() 

（4）设置兄弟进程通过管道的单项流动(设置指向标准输出的指向管道)  dup2()

（5）回收父进程残余文件  wait()

刚创建出的兄弟进程：

 设置兄弟进程通过管道的单项流动后

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/wait.h>void sys_err(const char *str)
{perror(str);exit(1);
}int main(int argc,char *argv[])
{/***************dup2();fork();pipe();execlp();wait();****************/int fd[2]; int ret;int i;pid_t pid;//父进程创建管道ret = pipe(fd);if(ret == -1){sys_err("pipe error");}for(i = 0;i < 2;i++){       //表达式2 出口，仅限父进程使用pid = fork();if(pid == -1){sys_err("fork error");}if(pid == 0)           //子进程出口break;}if(i == 2){                //父进程 //不需要父进程所以需要关闭他的读写并且回收掉父进程close(fd[0]);          close(fd[1]);wait(NULL);wait(NULL);}else if(i == 0){          //兄进程close(fd[0]);dup2(fd[1],STDOUT_FILENO);execlp("ls","ls",NULL);    //兄进程执行ls命令sys_err("ececlp ls error");}else if(i == 1){		   //弟进程close(fd[1]);dup2(fd[0],STDIN_FILENO);execlp("wc","wc","-l",NULL);//弟进程执行wc命令sys_err("ececlp wc error");}return 0;
}

6.多个读写端操作管道

实现一个pipe有一个写端，多个读端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/wait.h>void sys_err(const char *str)
{perror(str);exit(1);
}int main(int argc,char *argv[])
{/***************dup2();fork();pipe();execlp();****************/int fd[2],i,n; int ret;char buf[1024];pid_t pid;//父进程创建管道ret = pipe(fd);if(ret == -1){sys_err("pipe error");exit(1);}for(i = 0;i < 2;i++){pid = fork();if(pid == -1){sys_err("fork error");exit(1);}if(pid == 0)break;}if(i == 2){            //父进程close(fd[1]);       //父进程关闭写端，留读端读取数据sleep(1);n = read(fd[0],buf,1024);    //从管道中读取数据write(STDOUT_FILENO,buf,n); for(i == 0;i < 2;i++)        //两个儿子wait两次wait(NULL);}else if(i == 0){        //兄进程close(fd[0]);write(fd[1],"1.hello\n",strlen("1.hello\n"));}else if(i == 1){		 //弟进程close(fd[0]);write(fd[1],"2.world\n",strlen("2.world\n"));}return 0;
}

7.管道缓冲区大小：

可以使用 ulimIt -a 命令来查看当前系统中创建管道文件所对应的内核缓冲区大小。通常为:
        pipe size               ......(512 bytes,-p)  8 

也可以使用fpathconf函数，借助参数―选项来查看。使用该宏应引入头文件<unistd.h>
        long fpathconf(int fd, int name);成功:返回管道的大小―失败:-1，设置errno

.8.管道的优劣

优点:简单，相比信号，套接字实现进程间通信，简单很多。

缺点:

                1.只能单向通信，双向通信需建立两个管道。
                2.只能用父子、兄弟进程(有共同祖先)间通信。该问题后来使用fifo有名管道解决）

 三、FIFO:   

fifo管道：可以用于无血缘关系的进程间通信。

    命名管道：  mkfifo 

    无血缘关系进程间通信：

                        读端，open fifo O_RDONLY

                        写端，open fifo O_WRONLY

     

1.命名管道fifo的创建和原理：

使用命令：myfifo myfifo

 使用myfifo创建

#include<stdio.h>
#include<sys/stat.h>
#include<errno.h>
#include<pthread.h>
#include<stdlib.h>void sys_err(const char *str){perror(str);exit(1);
}int main(int argc,char *str)
{int ret = mkfifo("mytestfifo",0664);if(ret == -1)sys_err("mkfifo error");return 0;}