进程IPC---管道和有名管道

无名管道：

①管道是内核管理的一个缓冲区，管道是单向的、先进先出的、无结构的、固定大小的字节流，它把一个进程的标准输出和另一个进程的标准输入连接在一起。写进程在管道的尾端写入数据，读进程在管道的首端读出数据。数据读出后将从管道中移走，其它读进程都不能再读到这些数据。管道提供了简单的流控制机制。

②管道为空时，在有数据写入管道前，读进程将一直阻塞。同样，管道已经满时，进程再试图写管道，在其它进程从管道中移走数据之前，写进程将一直阻塞。

③管道主要用于不同进程间通信。

④管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道。



④无名一般用于父子进程之间的通信，一般是在一个进程在由pipe()创建管道后，一般再由fork一个子进程，然后通过管道实现父子进程间的通信(可以推出，只要两个进程中存在亲缘关系,这里的亲缘关系指的是具有共同的祖先，都可以采用管道方式来进行通信）。

无名管道的读写规则探究：

从管道中读数据：

<1>写端不存在时,此时则认为已经读到了数据的末尾，读函数返回的读出字节数为0；

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
int n;
int fd[2];
int count = 0;
char buf[100] = {0};
if(pipe(fd) < 0)
{
perror("Fail to create pipe");
exit(EXIT_FAILURE);
}
close(fd[1]);
if((n = read(fd[0],buf,sizeof(buf))) < 0)
{
perror("Fail to read pipe");
exit(EXIT_FAILURE);
}
printf("Rread %d bytes : %s.\n",n,buf);

4000
return 0;
}

运行结果如下：

<2>写端存在时，如果请求的字节数目大于PIPE_BUF(ubuntu操作系统为65536)，则返回管道中现有的数据字节数，如果请求的字节数目不大于PIPE_BUF，则返回管道中现有数据字节数（此时，管道中数据量小于请求的数据量）；或者返回请求的字节数(此时，管道中数据量不小于请求的数据量)。

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#define N 10
#define MAX 100

int child_read_pipe(int fd)
{
char buf
;
int n = 0;
while(1)
{
n = read(fd,buf,sizeof(buf));
buf
= '\0';
printf("Read %d bytes : %s.\n",n,buf);
if(strncmp(buf,"quit",4) == 0)
break;
}
return 0;
}

int father_write_pipe(int fd)
{
char buf[MAX] = {0};
while(1)
{
printf(">");
fgets(buf,sizeof(buf),stdin);
buf[strlen(buf)-1] = '\0';
write(fd,buf,strlen(buf));
usleep(500);
if(strncmp(buf,"quit",4) == 0)
break;
}
return 0;
}

int main()
{
int pid;
int fd[2];

if(pipe(fd) < 0)
{
perror("Fail to pipe");
exit(EXIT_FAILURE);
}
if((pid = fork()) < 0)
{
perror("Fail to fork");
exit(EXIT_FAILURE);
}else if(pid == 0){

close(fd[1]);
child_read_pipe(fd[0]);

}else{
close(fd[0]);
father_write_pipe(fd[1]);
}

exit(EXIT_SUCCESS);
}

运行结果如下：

**从以上验证我们可以看到：

<1>当写端存在时，管道中没有数据时，读取管道时将阻塞。

<2>当读端请求读取的数据大于管道中的数据时，此时读取管道中实际大小的数据。

<3>当读端请求读取的数据小于管道中的数据时，此时放回请求读取的大小数据。**

向管道中写入数据:

①向管道中写入数据时，linux将不保证写入的原子性，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。当管道满时，读进程不读走管道缓冲区中的数据，那么写操作将一直阻塞。

②注意：只有管道的读端存在时，向管道中写入数据才有意义。否则，向管道中写入数据的进程将收到内核传来的SIGPIPE信号，应用程序可以处理该信号，也可以忽略(默认动作则是使应用程序终止)。

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

int main()
{
int pid;
int n;
int fd[2];
char buf[1000 * 6] = {0};
if(pipe(fd) < 0)
{
perror("Fail to pipe");
exit(EXIT_FAILURE);
}
if((pid = fork()) < 0)
{
perror("Fail to fork");
exit(EXIT_FAILURE);
}else if(pid == 0){
close(fd[1]);
sleep(5);
close(fd[0]);
printf("Read port close.\n");
sleep(3);
}else{
close(fd[0]);
while(1)
{
n = write(fd[1],buf,sizeof(buf));
printf("Write %d bytes to pipe.\n",n);
}
}

exit(EXIT_SUCCESS);
}

运行结果如下：

有名管道：

有名管道的介绍：

①无名管道，由于没有名字，只能用于亲缘关系的进程间通信.。为了克服这个缺点，提出了有名管道(FIFO)。

②FIFO不同于无名管道之处在于它提供了一个路径名与之关联，以FIFO的文件形式存在于文件系统中，这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信，因此，通过FIFO不相关的进程也能交换数据。值的注意的是，FIFO严格遵循先进先出(first in first out),对管道及FIFO的读总是从开始处返回数据，对它们的写则把数据添加到末尾。它们不支持诸如lseek()等文件定位操作。

③注意：有名管道的名字存在于文件系统中，内容存放在内存中。

有名管道的创建：



该函数的第一个参数是一个普通的路径名，也就是创建后FIFO的名字。第二个参数与打开普通文件的open()函数中的mode参数相同。如果mkfifo的一个参数是一个已经存在路径名时，会返回EXIST错误，所以一般典型的调用代码首先会检查是否返回该错误，如果确实返回该错误，那么只要调用打开FIFO的函数就可以了。

有名管道的打开规则：

①有名管道比无名管道多了一个打开操作：open

②如果当前打开操作时为读而打开FIFO时，若已经有相应进程为写而打开该FIFO，则当前打开操作将成功返回；否则，可能阻塞到有相应进程为写而打开该FIFO(当前打开操作设置了阻塞标志)；或者，成功返回(当前打开操作没有设置阻塞标志)。

③如果当前打开操作时为写而打开FIFO时，如果已经有相应进程为读而打开该FIFO,则当前打开操作将成功返回；否则，可能阻塞直到有相应进程为读而打开该FIFO(当前打开操作设置了阻塞标志)；或者，返回ENIO错误(当期打开操作没有设置阻塞标志)。

A.open for write

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc,char *argv[])
{
int fd;
if(argc < 2)
{
fprintf(stderr,"usage : %s argv[1].\n",argv[0]);
exit(EXIT_FAILURE);
}
if(mkfifo(argv[1],0666) < 0 && errno != EEXIST)
{
fprintf(stderr,"Fail to mkfifo %s : %s.\n",argv[1],strerror(errno));
exit(EXIT_FAILURE);
}
if((fd = open(argv[1],O_WRONLY)) < 0)
{
fprintf(stderr,"Fail to open %s : %s.\n",argv[1],strerror(errno));
exit(EXIT_FAILURE);
}
printf("open for write success.\n");
return 0;
}

B.open for read

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int argc,char *argv[])
{
int fd;
if(argc < 2)
{
fprintf(stderr,"usage : %s argv[1].\n",argv[0]);
exit(EXIT_FAILURE);
}
if(mkfifo(argv[1],0666) < 0 && errno != EEXIST)
{
fprintf(stderr,"Fail to mkfifo %s : %s.\n",argv[1],strerror(errno));
exit(EXIT_FAILURE);
}
if((fd = open(argv[1],O_RDONLY)) < 0)
{
fprintf(stderr,"Fail to open %s : %s.\n",argv[1],strerror(errno));
exit(EXIT_FAILURE);
}
printf("open for read success.\n");
return 0;
}

A.从FIFO中读取数据：

约定：如果一个进程为了从FIFO中读取数据而以阻塞的方式打开FIFO， 则称内核为该进程的读操作设置了阻塞标志

<1>如果有进程为写而打开FIFO，且当前FIFO内没有数据，则对于设置了阻塞标志的读操作来说，将一直阻塞。对于没有设置阻塞标志读操作来说返回-1,当前errno值为EAGAIN,提醒以后再试。

<2>对于设置阻塞标志的读操作说，造成阻塞的原因有两种:当前FIFO内有数据，但有其他进程正在读这些数据；另外就是FIFO内没有数据。解阻塞的原因则是FIFO中有新的数据写入,不论写入数据量的大小，也不论读操作请求多少数据量。

<3>如果没有进程写打开FIFO,则设置了阻塞标志的读操作会阻塞

<4>如果写端关闭，管道中有数据读取管道中的数据，如果管道中没有数据读端将不会继续阻塞，此时返回0。

注意：如果FIFO中有数据，则设置了阻塞标志的读操作不会因为FIFO中的字节数小于请求读的字节数而阻塞，此时，读操作会返回FIFO中现有的数据量。

B.向FIFO中写入数据：

约定：如果一个进程为了向FIFO中
ab50
写入数据而阻塞打开FIFO,那么称该进程内的写操作设置了阻塞标志。

对于设置了阻塞标志的写操作:

<1>当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数，则进入睡眠，直到当缓冲区中能够容纳写入的字节数时，才开始进行一次性写操作。

<2>当要写入的数据量大于PIPE_BUF时，Linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域，写进程就会试图向管道写入数据，写操作在写完所有请求写的数据后返回。

对于没有设置阻塞标志的写操作:

<1>当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后，写操作返回。

<2>当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数，写完后成功返回；如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数，则返回EAGAIN错误，提醒以后再写。

注意：只有读端存在，写端才有意义。如果读端不在，写端向FIFO写数据，内核将向对应的进程发送SIGPIPE信号（默认终止进程）；

命名管道的安全问题：

前面的例子是两个进程之间的通信问题，也就是说，一个进程向FIFO文件写数据，而另一个进程则在FIFO文件中读取数据。试想这样一个问题，只使用一个FIFO文件，如果有多个进程同时向同一个FIFO文件写数据，而只有一个读FIFO进程在同一个FIFO文件中读取数据时，会发生怎么样的情况呢，会发生数据块的相互交错是很正常的？而且个人认为多个不同进程向一个FIFO读进程发送数据是很普通的情况。

为了解决这一问题，就是让写操作的原子化。怎样才能使写操作原子化呢？答案很简单，系统规定：在一个以O_WRONLY（即阻塞方式）打开的FIFO中， 如果写入的数据长度小于等待PIPE_BUF，那么或者写入全部字节，或者一个字节都不写入。如果所有的写请求都是发往一个阻塞的FIFO的，并且每个写记请求的数据长度小于等于PIPE_BUF字节，系统就可以确保数据决不会交错在一起。

命名管道与匿名管道的对比：

使用匿名管道，则通信的进程之间需要一个父子关系，通信的两个进程一定是由一个共同的祖先进程启动。但是匿名管道没有上面说到的数据交叉的问题。

与使用匿名管道相比，我们可以看到fifowrite.exe和fiforead.exe这两个进程是没有什么必然的联系的，如果硬要说他们具有某种联系，就只能说是它们都访问同一个FIFO文件。它解决了之前在匿名管道中出现的通信的两个进程一定是由一个共同的祖先进程启动的问题。但是为了数据的安全，我们很多时候要采用阻塞的FIFO，让写操作变成原子操作。