有名管道
为什么叫“有名管道”
有名管道特点
能够用于非亲缘进程之间的通信
进入阻塞
读端口被关闭的处理
有名管道的使用步骤
有名管道API
API说明
有名管道实现进程的单向通信
代码演示
小结：图解分析

有名管道
为什么叫“有名管道”
无名管道因为没有文件名，被称为了无名管道，同样的道理，有名管道之所以叫“有名管道”，是因为它有文件名。

也就是说当我们调用相应的API创建好“有名管道”后，会在相应的路径下面看到一个叫某某名字的“有名管道文件”。

不管是有名管道，还是无名管道，它们的本质其实都是一样的，它们都是内核所开辟的一段缓存空间。

进程间通过管道通信时，本质上就是通过共享操作这段缓存来实现，只不过操作这段缓存的方式，是以读写文件的形式来操作的。
有名管道特点
能够用于非亲缘进程之间的通信
因为有文件名，所以进程可以直接调用open函数打开文件，从而得到文件描述符，不需要像无名管道一样，必须在通过继承的方式才能获取到文件描述符。
所以任何两个进程之间，如果想要通过“有名管道”来通信的话，不管它们是亲缘的还是非亲缘的，只要调用open函数打开同一个“有名管道”文件，然后对同一个“有名管道文件”进行读写操作，即可实现通信。
A进程 —————————> 有名管道 ————————> B进程
总之，不管是亲缘进程还是非亲缘进程，都可以使用有名管道来通信。
进入阻塞
读管道时，如果管道没有数据的话，读操作同样会阻塞（休眠）
读端口被关闭的处理
当一个进程所有读端都被关闭了的管道时，进程会被内核返回SIGPIPE信号如果不想被该信号终止的话，我们需要忽略、捕获、屏蔽该信号。

不过一般情况下，不需要对这个信号进行处理。
有名管道的使用步骤
(1)进程调用mkfifo创建有名管道

(2)open打开有名管道

(3)read/write读写管道进行通信

对于通信的两个进程来说，创建管道时，只需要一个人创建，另一个直接使用即可。

为了保证管道一定被创建，最好是两个进程都包含创建管道的代码，谁先运行就谁先创建，后运行的发现管道已经创建好了，那就直接open打开使用。
有名管道API
API说明
函数原型
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);

功能

创建有名管道文件，创建好后便可使用open打开。

如果是创建普通文件的话，我们可以使用open的O_CREAT选项来创建，比如：

open("./file", O_RDWR|O_CREAT, 0664);
但是对于“有名管道”这种特殊文件，这里只能使用mkfifo函数来创建。
参数

pathname：被创建管道文件的文件路径名。

mode：指定被创建时原始权限，一般为0664（110110100），必须包含读写权限。

使用open函数创建普通文件时，指定原始权限是一样的。

open("./file", O_RDWR|O_CREAT, 0664);

创建新文件时，文件被创建时的真实权限=mode & (~umask)

umask是文件权限掩码，一般默认为002或者022

mkfifo(“./fifo”, 0664);
返回值

成功返回0，失败则返回-1，并且errno被设置。
有名管道实现进程的单向通信
代码演示
有两个进程想要通信，而且还是非亲缘进程，此时我们就可以使用“有名管道”来通信。

我们首先在当前代码创建一个管道文件：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#define FIFO_NAME1 "./fifo1"
void print_err(char * estr)
{
        perror(estr);
        exit(-1);
}

int main()
{
        char buf[100] = {0};
        int ret = 0;
        int fd = 0;
        ret = mkfifo(FIFO_NAME1,0664);
        if(ret == -1) print_err("mkfifo fail");
        fd = open(FIFO_NAME1,O_WRONLY);
        if(fd == -1) print_err("open fail");
        while(1)
        {
                bzero(buf,sizeof(buf));
                scanf("%s",buf);
                write(fd,buf,sizeof(buf));
        }
        return 0;
}

运行结果为：

我们再次运行程序：


我们可以看到管道文件已经存在，那么我们就可以知道mkfifo这个函数在创建管道文件的时候如果管道文件已经存在的时候就会出错返回，并且打印文件已经存在的错误。
那么我们对于上面代码进行修改：

把代码：
if(ret == -1) print_err("mkfifo fail");

修改为：
if(ret == -1 && EEXIST	) print_err("mkfifo fail");

那么我们当文件存在的时候我们不需要程序去报错退出，而是直接忽略。
那么我们需要的是：

如果文件不存在就创建文件并且在后面进行打开，如果文件已经存在就直接跳过直接执行后面代码。那么文件存在就不会报错并且返回退出进程。那么就上面修改之后就只会报文件存在以外的错误，也就是说我们不认为文件存在时已经错误。
那么当我们进程运行起来之后我们需要通过管道来进行通信，进程结束之后我们就没有进程通信的需要了，那么我们就在进程运行结束的时候把管道文件删除，那么通过我们按下ctrl+c进行进程结束，那么我们就可以对于SIGINT信号进行捕获，然后把管道文件进行删除再退出进程。
我们把上面整个代码进行优化：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
#define FIFO_NAME1 "./fifo1"
void print_err(char * estr)
{
        perror(estr);
        exit(-1);
}

void signal_fun(int signal)
{
        remove(FIFO_NAME1);
        exit(-1);
}

int main()
{
        char buf[100] = {0};
        int ret = 0;
        int fd = 0;
         signal(SIGINT,signal_fun);
        ret = mkfifo(FIFO_NAME1,0664);
        if(ret == -1 && errno!=EEXIST) print_err("mkfifo fail");
        fd = open(FIFO_NAME1,O_WRONLY);
        if(fd == -1) print_err("open fail");
        while(1)
        {
                bzero(buf,sizeof(buf));
                scanf("%s",buf);
                write(fd,buf,sizeof(buf));
        }
     
        return 0;
}

运行结果为：


但是signal(SIGINT,signal_fun);不能放在
fd = open(FIFO_NAME1,O_WRONLY);

代码之后，因为当前只有一个写端进行打开，管道文件的读端没有打开的时候，代码就会在

fd = open(FIFO_NAME1,O_WRONLY);  阻塞，不会运行后面的代码。
我们可以看到创建出来的管道文件，但是当前只有一个从键盘向管道文件写入数据的操作，并没有一个从从管道读取文件的操作，所以我们先将进程退出，接下来我们编写读取管道数据的代码：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <strings.h>
#include <signal.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
#define FIFO_NAME1 "./fifo1"
void print_err(char * estr)
{
        perror(estr);
        exit(-1);
}

void signal_fun(int signal)
{
        remove(FIFO_NAME1);
        exit(-1);
}

int main()
{
        char buf[100] = {0};
        int ret = 0;
        int fd = 0;
        signal(SIGINT,signal_fun);
        ret = mkfifo(FIFO_NAME1,0664);
        if(ret == -1 && errno!=EEXIST) print_err("mkfifo fail");
        fd = open(FIFO_NAME1,O_RDONLY);
        if(fd == -1) print_err("open fail");
        while(1)
        {
                read(fd,buf,sizeof(buf));
                printf("rev:%s\n",buf);
        }
        return 0;
}

运行结果为：

我们在另一个中断窗口运行read

我们可以看到实现了两个进程之间数据交换。
小结：图解分析

上面的图和无名管道的单向数据交换逻辑是一样的，只不过创建管道文件的方法不一样。

 fifo_write.c 
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>

#define MYFIFO "/tmp/myfifo" /*有名管道文件标识*/
#define QUIT_STR "quit"
int
main(void){
	
	int fd;
	char buf[100]={0};
	struct stat statbuf;
	if( -1 == access(MYFIFO, F_OK)){ /*检查文件是否存在*/

		if(-1==mkfifo(MYFIFO, 0666)){ /*创建管道文件*/
			perror("mkfifo");
			exit(EXIT_FAILURE);
		}
	
	}else{  /*文件存在*/				
	
		if(-1==lstat(MYFIFO, &statbuf)){  /*获取文件的类型*/
			perror("lstat");
		}
		if(!S_ISFIFO(statbuf.st_mode)){ /*判断是否是管道文件*/
	
			unlink(MYFIFO);  /*不是管道文件，删除*/
			
			if(-1==mkfifo(MYFIFO, 0666)){ /*创建管道文件*/
				perror("mkfifo");
				exit(EXIT_FAILURE);
			}			
		}
	}
	if((fd=open(MYFIFO, O_WRONLY))==-1){
		perror("open_write");
		exit(EXIT_FAILURE);
	}
	while(1){
		
		bzero(buf,100);
		fgets((char *)buf, sizeof(buf)-1, stdin);
		//fgets写成替换成read(STDIN_FILENO, buf, sizeof(buf)-1);
		write(fd, buf, sizeof(buf));
		
		if(!strncasecmp(buf, QUIT_STR, strlen(QUIT_STR))){  /*输入quit退出（不区分大小写）*/
			break;
		}	
		
	}
	
	close(fd); /*关闭文件*/
	return 0;
}

 fifo_read.c 
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>

#define MYFIFO "/tmp/myfifo" /*有名管道文件标识*/
#define QUIT_STR "quit"
int
main(void){
	
	int fd;
	char buf[100]={0};
	struct stat statbuf;
	if( -1 == access(MYFIFO, F_OK)){ /*检查文件是否存在*/

		if(-1==mkfifo(MYFIFO, 0666)){ /*创建管道文件*/
			perror("mkfifo");
			exit(EXIT_FAILURE);
		}
	
	}else{  /*文件存在*/				
	
		if(-1==lstat(MYFIFO, &statbuf)){  /*获取文件的类型*/
			perror("lstat");
		}
		if(!S_ISFIFO(statbuf.st_mode)){ /*判断是否是管道文件*/
	
			unlink(MYFIFO);  /*不是管道文件，删除*/
			
			if(-1==mkfifo(MYFIFO, 0666)){ /*创建管道文件*/
				perror("mkfifo");
				exit(EXIT_FAILURE);
			}			
		}
	}
	if((fd=open(MYFIFO, O_RDONLY))==-1){
		perror("open_read");
		exit(EXIT_FAILURE);
	}
	while(1){
		
		bzero(buf,100);
		read(fd, buf, sizeof(buf));
		printf("%s",buf);
		if(!strncasecmp(buf, QUIT_STR, strlen(QUIT_STR))){ /*输入quit退出（不区分大小写）*/
			break;
		}
	}
	close(fd);
	return 0;
}

写进程
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

void writefifo()
{
	char buf[128];
	memset(buf, 0, sizeof(buf));
	int fd = open("fifo", O_WRONLY);
	if (fd == -1)
	{
		printf("error is %s\n", strerror(errno));
	}
	while (1)
	{
		scanf("%s", buf);
		if (buf[0] == '0')
			break;
		write(fd, buf, sizeof(buf));
		//memset(buf, 0, sizeof(buf));
	}
	close(fd);
}

int main(void)
{
	writefifo();
	return EXIT_SUCCESS;
}


读进程
void listenfifo()
{
	int len = 0;
	char buf[128];
	memset(buf, 0, sizeof(buf));
	int fd = open("fifo", O_RDONLY);
	if (fd == -1)
	{
		printf("error is %s\n", strerror(errno));
	}
	while ((len = read(fd, buf, sizeof(buf))) > 0)
	{
		printf("%s\n", buf);
		//memset(buf, 0, sizeof(buf));
	}
	close(fd);
}

int main(void)
{
	listenfifo();
	return EXIT_SUCCESS;
}

//命名管道特点:
//1.如果打开管道的一方仅以读或写的方式打开管道，必须需要另一方的介入，管道才能打开
//双方都调用open
//可以一方打开，以读写的方式打开open(DEF_FIFO_PATH,O_RDWR)
//发送少量简单无格式的数据
//双方读写都存在，才能打开管道
//计时性存储数据
//2.存在的文件
//3.单向写入，单向写出
//问答形式

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

#define DEF_FIFO_PATH ("./FIFO")
#define DEF_STD_ERROR (-1)

int main(int argc,char *argv[])
{
        int ret;
        int fd;
        char str[1024];
        //if argv[1] > 0,writer
        if(atoi(argv[1])>0)
		{
			ret = mkfifo(DEF_FIFO_PATH,S_IWUSR | S_IRUSR);
			if(ret == DEF_STD_ERROR)
			{
					if(errno == EEXIST)
					{
							printf("Fifo always exist\n");
					}
					else
					{
							printf("%d\n",strerror(errno));
							return -1;
					}
			}
			//open fifo
			fd = open(DEF_FIFO_PATH,O_WRONLY)//O_WRONLY紧以读的方式打开，两个进程
			if(fd == DEF_STD_ERROR)
			{
					printf("%d\n",strerror(errno));
					//delete pipe打开失败删除文件（管道）
					unlink(DEF_FIFO_PATH);
					return -1;
			}
			//write
			while(1)
			{
					printf("Please input string:\n");
					scanf("%s",str);
					write(fd,str,strlen(str)+1);
					if(!strcmp(str,"goodbye"))
					{
							break;
					}
			}
			//close fifo
			close(fd);
	}
    else 
	{
			//if argv[1] <= 0,reader
			//check fifo
			ret = access(DEF_FIFO_PATH,W_OK);
			if(ret == DEF_STD_ERROR)
			{
					printf("%d\n",strerror(errno));
					return -1;
			}
			//open fifo
			fd = open(DEF_FIFO_PATH,O_RDONLY);
			if(fd == DEF_STD_ERROR)
			{
					printf("%d\n",strerror(errno));
					return -1;
			}
			//read fifo
			while(1)
			{
					read(fd,str,sizeof(str));
					printf("Receive data:[%s]\n",str);
					if(strcmp("goodbye",str)==0)
					{
							break;
					}
			}
			//close fifo
			close(fd);
	}
        return 0;
}