无名管道 / 有名管道(FIFO)

根据上节所讲就可以了解到：管道其实就是实现进程间通讯IPC中的一种类型方法

基本概念（无名管道）

管道是一种最基本的IPC机制，通常指无名管道，也是UNIX系统IPC最古老的形式。管道只能作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。有如下特质：

1. 其本质是一个伪文件(实为内核缓冲区)，可以使用普通的read,write等函数进行读写
2. 由两个文件描述符引用，一个表示读端，一个表示写端
3. 规定数据从管道的写端流入管道，从读端流出

管道的原理

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

管道的局限性

• 数据一旦被读走，便不在管道中存在，不可反复读取
• 由于管道采用半双工通信方式。因此，数据只能在一个方向上流动

所谓半双工，其实在讲串口的时候就提到过，也就是同一时间要么只能写要么只能读，不能同时写和读。 对于进程通讯就是：父进程写的时候子进程只能读；子进程写的时候父进程只能读。

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

（ 常见的通信方式有，单工通信、半双工通信、全双工通信 ）

pipe函数（无名管道)

当成功调用pipe函数时，会创建两个文件描述符，fd[0] -> 读(r），fd[1]-> 写(w)，之后如果想要向管道写数据就往fd[1]里面写，如果想从管道读数据就从fd[0]里面读！

如果要关闭管道，只需要关闭这两个文件描述符就可以了。

需要添加的库

 #include <unistd.h>

函数原型

int pipe(int pipefd[2]);

函数参数

• pipefd[2]：表示一个包含两个文件描述符的数组，也就是上面提到分别代表读和写的 fd[0] 和 fd[1]
• 返回值：若成功返回0，失败则返回-1

实操演示

创建一个名为'IPC"的文件夹，关于各种IPC的学习代码都放在这个文件夹下：

注意，由于fork函数会拷贝一份一样的程序给子进程，所以管道的创建应该在fork之前，这样父子进程就都有了fd[0]和fd[1]，并且由于管道指向内核，所以父子进程的fd[0]和fd[1]是相同的。

#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>


int main()
{
	int fd[2];
	pid_t fork_return;
	char *writebuf = "mjmmjmmm";
	char readbuf[1024] = {0};

	if(pipe(fd) == -1){
		printf("pipe error\n");
	}

	fork_return = fork();
	if(fork_return > 0){//father
		close(fd[0]);
		//ssize_t write(int fd, const void *buf, size_t count);
		write(fd[1],writebuf,strlen(writebuf));
		wait(NULL);
	}else if(fork_return == -1){//error
		printf("fork error\n");
	}else{//son
		close(fd[1]);
		//ssize_t read(int fd, void *buf, size_t count);
		read(fd[0],&readbuf,1024);
		printf("read from pipe:%s\n",readbuf);
		exit(1);
	}


	return 0;
}

实现效果

基本概念（有名管道）

FIFO，也称为命名管道，它是一种文件类型。

有名管道的特点

• FIFO可以在无关的进程之间交换数据，与无名管道不同
• FIFO有路径名与之相关联，它以一种特殊设备文件形式存在于文件系统中

mkfifo函数（有名管道） 

需要添加的库

#include <sys/stat.h>

函数原型

int mkfifo(const char *pathname, mode_t mode);

函数参数

• pathname：文件路径
• mode：mode 参数与open函数中的 mode 相同。一旦创建了一个 FIFO，就可以用一般的文件I/O函数操作它

关于open函数中的mode:

其中较为常用的是：

• S_IRWXU：对主用户来说可读，可写，可执行
• S_IRUSR：对主用户来说可读
• S_IWUSR：对主用户来说可写
• S_IXUSR：对主用户来说可执行

详见：Linux 系统编程 开篇/ 文件的打开/创建_mjmmm的博客-CSDN博客

• 返回值：成功返回0，出错返回-1

既然可以用一般文件的I/O函数操作它，就意味可以使用open来打开，而open中的第二个参数flag中有一个选项是“O_NONBLOCK”，这是非阻塞标志：

• 若没有指定O_NONBLOCK（默认），只读 open 要阻塞到某个其他进程为写而打开此 FIFO。类似的，只写 open 要阻塞到某个其他进程为读而打开它。

• 若指定了O_NONBLOCK，则只读 open 立即返回。而只写 open 将出错返回 -1 如果没有进程已经为读而打开该 FIFO，其errno置ENXIO。

参考：进程间通信（一）管道的pipe函数 FIFO的mkfifo函数_mkfifo 多进程_点灯小哥的博客-CSDN博客

实操演示

FIFO的通讯方式类似于在进程中使用文件来传输数据，只不过FIFO类型文件同时具有管道的特性。在数据读出时，FIFO管道中同时清除数据，并且“先进先出”

fifo1.c：（只读open FIFO，并不设“O_NONBLOCK”）

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


int main()
{
	if(mkfifo("./fifo",S_IRWXU) == -1 && errno != EEXIST) //如果创建失败 且 没有已存在的FIFO
        {
                printf("mkfifo failed\n");
                perror("why");
        }

	int fd = open("./fifo",O_RDONLY); //only read
	printf("open success\n");

	return 0;
}

实现效果1：

可见，由于没有设置O_NONBLOCK，且没有进程只写打开FIFO，所以只读打开FIFO会一直阻塞

fifo2.c：（只读open FIFO，并设置“O_NONBLOCK”）

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


int main()
{
	if(mkfifo("./fifo",S_IRWXU) == -1 && errno != EEXIST)
        {
                printf("mkfifo failed\n");
                perror("why");
        }

	int fd = open("./fifo",O_RDONLY|O_NONBLOCK); //only read
	printf("open success\n");

	return 0;
}

实现效果2：

 

可见，由于加上了O_NONBLOCK，虽然没有进程只写打开FIFO，但是只读打开不会阻塞而是立刻返回，并执行了printf 

fifo3.c & fifo4.c：（创建两个进程，fifo3一直写，fifo4一直读）

fifio3.c：（一直写）

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


int main()
{
	char *str = "mjmmmmjjm";

	int fd = open("./fifo",O_WRONLY); //only write
	printf("open success\n");

	while(1){
		write(fd,str,strlen(str));
		sleep(1);

	}

	close(fd);

	return 0;
}

fifo4.c：（一直读）

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


int main()
{
	char buf[30] = {0};
    int nread = 0;
	
	if(mkfifo("./fifo",S_IRWXU) == -1 && errno != EEXIST)
        {
                printf("mkfifo failed\n");
                perror("why");
        }

	int fd = open("./fifo",O_RDONLY); //only read
	printf("read open success\n");
	
	while(1){
		read(fd,&buf,30);
		printf("read %d byte from fifo,context: %s\n",nread,buf);
	}

	close(fd);

	return 0;
}

实现效果3：

先编译并运行fifo4.c：

可见没有进程只写打开FIFO，所以一直阻塞

然后再新的窗口编译并运行fifo3.c：

此时有进程只写打开FIFO并每隔一秒向其中写入数据

此时再观察fifo4.c的输出：

 

此时只读FIFO不再阻塞，并每隔一秒读到只写FIFO写入的数据！ 

上述例子可以扩展成 客户进程—服务器进程 通信的实例，负责写的fifo3.c的作用类似于客户端，可以打开多个客户端向一个服务器发送请求信息，负责读的fifo4.c类似于服务器，它适时监控着FIFO的读端，当有数据时，读出并进行处理，但是有一个关键的问题是，每一个客户端必须预先知道服务器提供的FIFO接口，下图显示了这种安排：