linux内核剖析（八）进程间通讯之-管道

管道

---

管道是一种两个进程间进行单向通讯的机制。

由于管道传递数据的单向性，管道又称为半双工管道。

管道的这一特色决定了器使用的局限性。管道是Linux支持的最初Unix IPC形式之一，具备如下特色：

• 数据只能由一个进程流向另外一个进程（其中一个读管道，一个写管道）；若是要进行双工通讯，须要建 立两个管道。

• 管道只能用于父子进程或者兄弟进程间通讯。，也就是说管道只能用于具备亲缘关系的进程间通讯。

  除了以上局限性，管道还有其余一些不足，如管道没有名字（匿名管道），管道的缓冲区大小是受限制的。管道所传输的是无格式的字节流。这就须要管道输入方和输出方事先约定好数据格式。虽然有那么多不足，但对于一些简单的进程间通讯，管道仍是彻底能够胜任的。

信号和消息的区别

---

咱们知道，进程间的信号通讯机制在传递信息时是以信号为载体的，但管道通讯机制的信息载体是消息。那么信号和消息之间的区别在哪里呢？

• 1
• 2

首先，在数据内容方面，信号只是一些预约义的代码，用于表示系统发生的某一情况；消息则为一组连续语句或符号，不过量也不会太大。在做用方面，信号担任进程间少许信息的传送，通常为内核程序用来通知用户进程一些异常状况的发生；消息则用于进程间交换彼此的数据。

在发送时机方面，信号能够在任什么时候候发送；信息则不能够在任什么时候刻发送。在发送者方面，信号不能肯定发送者是谁；信息则知道发送者是谁。在发送对象方面，信号是发给某个进程；消息则是发给消息队列。在处理方式上，信号能够不予理会；消息则是必须处理的。在数据传输效率方面，信号不适合进大量的信息传输，由于它的效率不高；消息虽然不适合大量的数据传送，但它的效率比信号强，所以适于中等数量的数据传送。

管道-流管道-命名管道的区别

---

咱们知道，命名管道和管道均可以在进程间传送消息，但它们也是有区别的。

管道这种通信方式有两种限制，

• 一是半双工的通讯，数据只能单向流动

• 二是只能在具备亲缘关系的进程间使用。

进程的亲缘关系一般是指父子进程关系。

流管道s_pipe去除了第一种限制,能够双向传输。

管道可用于具备亲缘关系进程间的通讯，命名管道name_pipe克服了管道没有名字的限制，所以，除具备管道所具备的功能外，它还容许无亲缘关系进程间的通讯；

管道技术只能用于链接具备共同祖先的进程，例如父子进程间的通讯，它没法实现不一样用户的进程间的信息共享。再者，管道不能常设，当访问管道的进程终止时，管道也就撤销。这些限制给它的使用带来很多限制，可是命名管道却克服了这些限制。

命名管道也称为FIFO，是一种永久性的机构。FIFO文件也具备文件名、文件长度、访问许可权等属性，它也能像其它Linux文件那样被打开、关闭和删除，因此任何进程都能找到它。换句话说，即便是不一样祖先的进程，也能够利用命名管道进行通讯。

若是想要全双工通讯，那最好使用Sockets API（linux并不支持s_pipe流管道）。下面咱们分别介绍经过管道命令解析管道的技术模型，而后详细说明用来进行管道编程的编程接口和系统级命令。

管道技术模型

---

管道技术是Linux操做系统中从来已久的一种进程间通讯机制。

全部的管道技术，不管是半双工的匿名管道，仍是命名管道，它们都是利用FIFO排队模型来指挥进程间的通讯。

对于管道，咱们能够形象地把它们看成是链接两个实体的一个单向链接器。

使用管道进行通讯时，两端的进程向管道读写数据是经过建立管道时，系统设置的文件描述符进行的。从本质上说，管道也是一种文件，但它又和通常的文件有所不一样，能够克服使用文件进行通讯的两个问题，这个文件只存在内存中。

经过管道通讯的两个进程，一个进程向管道写数据，另一个从中读数据。写入的数据每次都添加到管道缓冲区的末尾，读数据的时候都是从缓冲区的头部读出数据的。

管道命令详解

---

参见

linux shell 管道命令(pipe)使用及与shell重定向区别

例如，请看下面的命令

管道符号，是unix功能强大的一个地方,符号是一条竖线:”|”，

用法: command 1 | command 2

他的功能是把第一个命令command 1执行的结果做为command 2的输入传给command 2

注意：

1. 管道命令只处理前一个命令正确输出，不处理错误输出

2. 管道命令右边命令，必须可以接收标准输入流命令才行。

例如:
ls -l | more

该命令列出当前目录中的任何文档，并把输出送给more命令做为输入，more命令分页显示文件列表。

管道命令与重定向区别

---

区别是：

• 左边的命令应该有标准输出 | 右边的命令应该接受标准输入

• 左边的命令应该有标准输出 > 右边只能是文件

• 左边的命令应该须要标准输入 < 右边只能是文件

• 管道触发两个子进程执行”|”两边的程序；而重定向是在一个进程内执行

重定向与管道在使用时候不少时候能够通用

其实，在shell里面，常常是条条大路通罗马的。

通常若是是命令间传递参数，仍是管道的好，若是处理输出结果须要重定向到文件，仍是用重定向输出比较好。

前面的例子实际上就是在两个命令之间创建了一根管道（有时咱们也将之称为命令的流水线操做）。

第一个命令ls执行后产生的输出做为了第二个命令more的输入。

这是一个半双工通讯，由于通讯是单向的。两个命令之间的链接的具体工做，是由内核来完成的。

固然内核也为咱们提供了一套接口（系统调用），除了命令以外，应用程序也可使用管道进行链接。

管道编程技术

---

参考 http://www.cppblog.com/jackdongy/archive/2013/01/07/197055.html

http://blog.chinaunix.net/uid-26495963-id-3066282.html

管道的接口

---

无名管道pipe

---

建立管道pipe

1. 函数原型`int pipe(int filedes[2]);

   • pipe()会创建管道,并将文件描述词由参数 filedes 数组返回。

   • filedes[0]为管道里的读取端，因此pipe用read调用的。

   • filedes[1]则为管道的写入端。使用write进行写入操做。

2. 返回值

   • 若成功则返回零,不然返回-1,错误缘由存于 errno 中。

3. 错误代码

   • EMFILE 进程已用完文件描述词最大量

   • ENFILE 系统已无文件描述词可用。

   • EFAULT 参数 filedes 数组地址不合法。

当调用成功时，函数pipe返回值为0，不然返回值为-1。成功返回时，数组fds被填入两个有效的文件描述符。数组的第一个元素中的文件描述符供应用程序读取之用，数组的第二个元素中的文件描述符能够用来供应用程序写入。

关闭管道close

• 关闭管道只是将两个文件描述符关闭便可，可使用普通的close函数逐个关闭。

若是管道的写入端关闭，可是还有进程尝试从管道读取的话，将被返回0，用来指出管道已不可用，而且应当关闭它。若是管道的读出端关闭，可是还有进程尝试向管道写入的话，试图写入的进程将收到一个SIGPIPE信号，至于信号的具体处理则要视其信号处理程序而定了。

dup函数和dup2函数

---

dup和dup2也是两个很是有用的调用，它们的做用都是用来复制一个文件的描述符。

它们常常用来重定向进程的stdin、stdout和stderr。

这两个函数的原型以下所示：

#include <unistd.h> int dup( int oldfd ); int dup2( int oldfd, int targetfd )

 

dup函数

利用函数dup，咱们能够复制一个描述符。传给该函数一个既有的描述符，它就会返回一个新的描述符，这个新的描述符是传给它的描述符的拷贝。这意味着，这两个描述符共享同一个数据结构。

例如，若是咱们对一个文件描述符执行lseek操做，获得的第一个文件的位置和第二个是同样的。下面是用来讲明dup函数使用方法的代码片断：

int fd1, fd2;
fd2 = dup( fd1 );

 

须要注意的是，咱们能够在调用fork以前创建一个描述符，这与调用dup创建描述符的效果是同样的，子进程也一样会收到一个复制出来的描述符。

dup2函数

dup2函数跟dup函数类似，但dup2函数容许调用者规定一个有效描述符和目标描述符的id。

dup2函数成功返回时，目标描述符（dup2函数的第二个参数）将变成源描述符（dup2函数的第一个参数）的复制品，换句话说，两个文件描述符如今都指向同一个文件，而且是函数第一个参数指向的文件。

下面咱们用一段代码加以说明：

int oldfd; oldfd = open("app_log", (O_RDWR | O_CREATE), 0644 ); dup2( oldfd, 1 ); close( oldfd ); 

 

咱们打开了一个新文件，称为“app_log”，并收到一个文件描述符，该描述符叫作fd1。咱们调用dup2函数，参数为oldfd和1，这会致使用咱们新打开的文件描述符替换掉由1表明的文件描述符（即stdout，由于标准输出文件的id为1）。任何写到stdout的东西，如今都将改成写入名为“app_log”的文件中。须要注意的是，dup2函数在复制了oldfd以后，会当即将其关闭，但不会关掉新近打开的文件描述符，由于文件描述符1如今也指向它。

命名管道mkfifo

---

mkfifo函数的做用是在文件系统中建立一个文件，该文件用于提供FIFO功能，即命名管道。前边讲的那些管道都没有名字，所以它们被称为匿名管道，或简称管道。对文件系统来讲，匿名管道是不可见的，它的做用仅限于在父进程和子进程两个进程间进行通讯。而命名管道是一个可见的文件，所以，它能够用于任何两个进程之间的通讯，无论这两个进程是否是父子进程，也无论这两个进程之间有没有关系。Mkfifo函数的原型以下所示：

#include <sys/types.h> #include <sys/stat.h> int mkfifo( const char *pathname, mode_t mode );

 

mkfifo函数须要两个参数，第一个参数（pathname）是将要在文件系统中建立的一个专用文件。第二个参数（mode）用来规定FIFO的读写权限。Mkfifo函数若是调用成功的话，返回值为0；若是调用失败返回值为-1。下面咱们以一个实例来讲明如何使用mkfifo函数建一个fifo，具体代码以下所示：

int ret; ret = mkfifo( "/tmp/cmd_pipe", S_IFIFO | 0666 ); if (ret == 0) { // 成功创建命名管道 } else { // 建立命名管道失败 }

 

在这个例子中，利用/tmp目录中的cmd_pipe文件创建了一个命名管道（即fifo）。以后，就能够打开这个文件进行读写操做，并以此进行通讯了。命名管道一旦打开，就能够利用典型的输入输出函数从中读取内容。举例来讲，下面的代码段向咱们展现了如何经过fgets函数来从管道中读取内容：

pfp = fopen( "/tmp/cmd_pipe", "r" ); ret = fgets( buffer, MAX_LINE, pfp );

 

咱们还能向管道中写入内容，下面的代码段向咱们展现了利用fprintf函数向管道写入的具体方法：

pfp = fopen( "/tmp/cmd_pipe", "w+ ); ret = fprintf( pfp, "Here’s a test string!\n" );

 

对命名管道来讲，除非写入方主动打开管道的读取端，不然读取方是没法打开命名管道的。Open调用执行后，读取方将被锁住，直到写入方出现为止。尽管命名管道有这样的局限性，但它仍不失为一种有效的进程间通讯工具。

无名管道

---

无名管道为创建管道的进程及其子孙提供一条以比特流方式传送消息的通讯管道。

该管道再逻辑上被看做管道文件，在物理上则由文件系统的高速缓冲区构成，而不多启动外设。

发送进程利用文件系统的系统调用write(fd[1],buf,size),把buf 中的长度为size字符的消息送入管道入口fd[1]，

接收进程则使用系统调用read(fd[0],buf,size)从管道出口fd[0]出口读出size字符的消息置入buf中。

这里，管道按FIFO（先进先出）方式传送消息，且只能单向传送消息（如图）。

无名管道pipe读写

---

管道用于不一样进程间通讯。一般先建立一个管道，再经过fork函数建立一个子进程，该子进程会继承父进程建立的管道。注意事项：必须在系统调用fork（）前调用pipe（），不然子进程将不会继承文件描述符。不然，会建立两个管道，由于父子进程共享同一段代码段，都会各自调用pipe（），即创建两个管道，出现异常错误。

无名管道读写过程如图所示

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #define MAX_DATA_LEN 256 #define DELAY_TIME 1 int main(void) { pid_t pid; char buf[MAX_DATA_LEN]; const char *data="Pipe Test program"; int real_read, real_write; int pipe_fd[2]; memset((void*)buf, 0, sizeof(buf)); if(pipe(pipe_fd) < 0) { perror("Pipe create error...\n"); exit(1); } else { printf("Pipe create success...\n"); } if ((pid = fork()) < 0) { perror("Fork error!\n"); exit(1); } else if (pid == 0) { printf("I am the child process, PID = %d, PPID = %d", getpid(), getppid()); close(pipe_fd[1]); sleep(DELAY_TIME * 3); if ((real_read=read(pipe_fd[0],buf, MAX_DATA_LEN)) > 0) { printf("Child receive %d bytes from pipe: '%s'.\n", real_read, buf); } close(pipe_fd[0]); exit(0); } else { printf("I am the parent process, PID = %d, PPID = %d", getpid(), getppid()); close(pipe_fd[0]); sleep(DELAY_TIME); if ((real_write = write(pipe_fd[1], data, strlen(data))) > 0) { printf("Parent write %d bytes into pipe: '%s'.\n", real_write, data); } close(pipe_fd[1]); waitpid(pid,NULL,0); exit(0); } return EXIT_SUCCESS; } 

 

多进程管道读写

---

创建一个管道。同时，父进程生成子进程P1，P2，这两个进程分别向管道中写入各自的字符串，父进程读出它们（如图）。

#include < stdio.h> main( ) { int I,r,p1,p2,fd[2]; char buf[50],s[50]; pipe(fd); /*父进程创建管道*/ while((p1=fork()) = = -1); if(p1 = = 0 ) { lockf(fd[1],1,0); /*加锁锁定写入端*/ sprinrf(buf, ”child process P1 is sending messages! \n”); printf(“child process P1! \n”); write(fd[1],buf, 50); /*把buf中的50个字符写入管道*/ sleep(5); lockf(fd[1],0,0); /*释放管道写入端*/ exit(0); /*关闭P1*/ } else /*从父进程返回，执行父进程*/ { while((p2=fork()) = = -1); /*建立子进程P2,失败时循环*/ if(p2 = = 0) /*从子进程P2返回，执行P2*/ { lockf(fd[1],1,0); / *锁定写入端*/ sprintf(buf, ”child process P2 is sending messages \n”); printf(“child process P2 ! \n”); write(fd[1],buf,50); /*把buf中字符写入管道*/ sleep(5); /* 睡眠等待*/ lockf (fd[1],0,0); /*释放管道写入端*/ exit(0); /*关闭P2*/ } wait(0); if (r = read(fd[0],s 50) = = -1) printf(“can’t read pipe \n”); else printf(“%s\n”,s); wait(0); if(r = read(fd[0],s,50)= = -1) printf(“can’t read pipe \n”); else printf((“%s\n”,s); exit(0); } } 

 

使用dup函数实现指令流水

---

咱们的子进程把它的输出重定向的管道的输入，而后，父进程将它的输入重定向到管道的输出。这在实际的应用程序开发中是很是有用的一种技术。

#include <stdio.h> #include <stdlib.h> #include <unistd.h> int main() { int pfds[2]; if ( pipe(pfds) == 0 ) { if ( fork() == 0 ) { close(1); dup2( pfds[1], 1 ); close( pfds[0] ); execlp( "ls", "ls", "-1", NULL ); } else { close(0); dup2( pfds[0], 0 ); close( pfds[1] ); execlp( "wc", "wc", "-l", NULL ); } } return 0; } 

 

命名管道

---

write端

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/stat.h> #include <errno.h> #include <unistd.h> #include <fcntl.h> #define FIFO "myfifo" #define BUFF_SIZE 1024 int main(int argc,char* argv[]) { char buff[BUFF_SIZE]; int real_write; int fd; if(argc <= 1) { printf("Usage: %s string\n", argv[0]); exit(1); } else { printf("%s at PID = %d\n", argv[0], getpid()); } sscanf(argv[1], "%s", buff); // 测试FIFO是否存在，若不存在，mkfifo一个FIFO if(access(FIFO, F_OK) == -1) { if((mkfifo(FIFO, 0666) < 0) && (errno != EEXIST)) { printf("Can NOT create fifo file!\n"); exit(1); } } // 调用open以只写方式打开FIFO，返回文件描述符fd if((fd = open(FIFO, O_WRONLY)) == -1) { printf("Open fifo error!\n"); exit(1); } // 调用write将buff写到文件描述符fd指向的FIFO中 if ((real_write = write(fd, buff, BUFF_SIZE)) > 0) { printf("Write into pipe: '%s'.\n", buff); exit(1); } close(fd); exit(0); } 

 

read端

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/stat.h> #include <errno.h> #include <unistd.h> #include <fcntl.h> #define FIFO "myfifo" #define BUFF_SIZE 1024 int main(int argc, char *argv[]) { char buff[BUFF_SIZE]; int real_read; int fd; printf("%s at PID = %d ", argv[0], getpid()); // access肯定文件或文件夹的访问权限。即，检查某个文件的存取方式 // 若是指定的存取方式有效，则函数返回0，不然函数返回-1 // 若不存在FIFO，则建立一个 if(access(FIFO, F_OK) == -1) { if((mkfifo(FIFO, 0666) < 0) && (errno != EEXIST)) { printf("Can NOT create fifo file!\n"); exit(1); } } // 以只读方式打开FIFO，返回文件描述符fd if((fd = open(FIFO, O_RDONLY)) == -1) { printf("Open fifo error!\n"); exit(1); } // 调用read将fd指向的FIFO的内容，读到buff中，并打印 while(1) { memset(buff, 0, BUFF_SIZE); if ((real_read = read(fd, buff, BUFF_SIZE)) > 0) { printf("Read from pipe: '%s'.\n",buff); } } close(fd); exit(0); }