管道——进程间通信

一、概念
1.管道是什么？
管道是一种特殊的文件，它不属于某一种文件系统，而是一种独立的文件系统，是只存在于内存中的文件，本质是内核的一块缓冲。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。
【注】管道是单向的、先进先出的、无结构的、固定大小字节流，它把一个进程的标准输出和另一个进程的标准输入连接在一起。

二、无名管道
1.概念知识总结

1>无名管道只能用于具有亲缘关系的进程之间的通信，通常一个管道由一个进程创建，然后实现两个进程间的通信时必须通过**fork**创建子进程，实现父子进程之间的通信。
2>半双工通信模式，具有**固定的读端和写端**：传输方向只能是**一个方向**。
3>管道可以看成是一种特殊的文件，对于它的读写可以使用文件IO如read、write函数，因为管道在文件系统中并不存在对应的文件，所以不支持lseek（）等操作。

特点：

1>只能进行单向通信
2>只能够用于有血缘关系（父子，兄弟，爷孙）的进程之间，多常用于父子之间
3>管道内部自带同步机制：子进程写一条，父进程读一条
4>管道在进行通信的时候，对外层提供的服务叫做面向字节流的服务
5>当进程退出之时，管道也随之释放，与文件保持一致
6>管道的生命周期为随进程，进程结束管道就没了

【注】

a.管道的大小
	管道的大小是PIPE_BUF(ubuntu操作系统为65536)

b.从管道中读取数据
1>写端存在时，当管道无数据时，读操作就会阻塞。
2>写端存在时，当读端请求读取的数据大于管道中的数据时，此时读取管道中实际的数据。
  当读端请求读取的数据小于管道中的数据时，此时返回请求读取的数据。
3>当读一个写端已经被关闭的管道时，在所有数据都被读取后，read返回0，以指示达到了文件结束处。


c.向管道中写数据
1>读端存在时，向管道中写入数据时，管道缓冲区一有空闲区域，写进程就会试图向管道写入数据。若有多个进程同时写一个管道（FIFO），则数据可能会与其他写操作的数据交错（需要借助进程间同步/互斥机制）。
2>读端存在时，如果管道缓冲区数据到达PIPE_BUF，读进程不读走管道缓冲区中的数据，那么写进程将会一直阻塞。
3>如果写一个读端已经被关闭的管道，则产生信号SIGPIPE。如果忽略该信号或者捕捉该信号并从其处理程序返回，则write出错返回，errn设置为EPPIPE.

2.无名管道的创建

#include<unistd.h>
int pipe(int pipefd[2]);

参数：fd是文件描述符数组，其中fd[0]表示读端，fd[1]表示写端
返回值：成功返回0，失败返回-1

demon1：同一进程内读取管道

#include<stdio.h>
#include<unistd.h>
#include<string.h>

int main()
{
	int fd[2];
	char buf[512];
	int buf_len;

	//1.创建管道
	if( -1 == pipe(fd))
	{
		perror("pipe:");
		return -1;
	}

	while(1)
	{
		printf("请输入写入管道的内容：");

		//fflush(stdin)刷新标准输入缓冲区,把输入缓冲区里的东西丢弃[非标准
		//fflush(stdout)刷新标准输出缓冲区,把输出缓冲区里的东西打印到标准输出设备上
		fflush(stdout);

		//0-标准输入，STDIN        1-标准输出，STDOUT        3-标准错误 STDERR
		if( 0 > read(0,buf,sizeof(buf))) //从屏幕读取内容
		{
			perror("read");
			return -2;
		}

		buf_len = strlen(buf);

		if( 0 > write(fd[1],buf,buf_len))
		{
			perror("write");
			return -3;
		}

		bzero(buf,sizeof(buf));

		if(0 > read(fd[0],buf,sizeof(buf)))
		{
			perror("read");
			return -4;
		}

		if(0 > write(1,buf,sizeof(buf)))
		{
			perror("write");
			return -5;
		}

		bzero(buf,sizeof(buf));

	}
	return 0;
}

运行结果：

demon2：父子进程读取管道

#include<stdio.h>
#include<unistd.h>
#include<string.h> 

int main(int argc,const char *argv[])
{
	int fd[2]; 
	pid_t pid;
	char buf[1024];

	if(0 > pipe(fd))
	{
		perror("pipe");
		return -1;
	}

	pid = fork();
	if(-1 == pid)
	{
		perror("fork");
		return -2;
	}

	if(pid > 0){
		close(fd[0]);

		while(1){ 
			memset(buf,0,sizeof(buf));
			scanf("%s",buf);
			if(-1 == write(fd[1], buf, sizeof(buf))){
				perror("write");
				return -1;
			}
			if(0 == strcmp(buf,"quit"))
				break;
		}

		close(fd[1]);
	}
	else if(0 == pid){
		close(fd[1]);

		char buf1[1024];
		while(1)
		{
			if(0 < read(fd[0],buf1,sizeof(buf1)))
			{
				printf("读取到内容====%s\n\n",buf1);
				if(0 == strcmp(buf,"quit"))
					break;
			}
			memset(buf1,0,sizeof(buf1));
		}

		close(fd[0]);
	}
	return 0;
}

运行结果：

三、有名管道
1.有名管道的概念

1>有名管道可以使用在俩个互不相干的进程间通信，有名管道可以通过路径名指出，并在文件系统中显示出来。
2>在Linux系统中专门设置了一种特殊的系统文件-管道文件，一FIFO的文件形式存在于文件系统中，
  这样，即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就可以通过FIFO进行彼此间的通信。
  但在磁盘上只是一个节点，而文件的数据则存在于内存缓冲页面中，与普通管道一样。

2.有名管道的创建
1>命令行创建mkfifo myfifo
2>也可以从程序中创建

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

参数1：FIFO的路径名
   2：创建时的权限，如果filename是一个已经存在的路径名，会返回EEXIST错误，一般调用时首先会检查是否返回该错误，如果返回，只需调用打开FIFO的函数。

3>FIFO的open打开规则

flags=O_RDONLY：open将会调用阻塞，除非有另外一个进程以写的方式打开同一个FIFO，否则一直等待。
flags=O_WRONLY：open将会调用阻塞，除非有另外一个进程以读的方式打开同一个FIFO，否则一直等待。
flags=O_RDONLY|O_NONBLOCK：如果此时没有其他进程以写的方式打开FIFO，此时open也会成功返回，此时FIFO被读打开，而不会返回错误。
flags=O_WRONLY|O_NONBLOCK：立即返回，如果此时没有其他进程以读的方式打开，open会失败打开，此时FIFO没有被打开，返回-1。

有名管道demon
将一个文件中的内容通过管道发送给另一个进程
写端

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

int main(int argc, const char *argv[])
{
	int ret,fd,fd1;
	char buf[1024];

//判断FIFO存在与否
	if(-1 == access(argv[1],F_OK))
	{
		if(-1 == mkfifo(argv[1], 0666))
		{
			perror("mkfifo");
			return -1;
		}
	}

	fd = open(argv[1],O_WRONLY);
	if( -1 == fd)
	{
		perror("open");
		return -2;
	}

	fd1 = open(argv[2],O_RDONLY);
	if(-1 == fd1)
	{
		perror("open fd1");
		return -3;
	}

	
	while((ret = read(fd1,buf,sizeof(buf))) > 0)
	{	
		write(fd,buf,ret);
		bzero(buf,sizeof(buf));
	}

	close(fd);
	close(fd1);
	return 0;
}

读端

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


int main(int argc, const char *argv[])
{
	int ret,fd,fd1;
	char buf[1024];

//判断FIFO存在与否
	if(-1 == access(argv[1],F_OK))
	{
		if(-1 == mkfifo(argv[1], 0666))
		{
			perror("mkfifo");
			return -1;
		}
	}

	fd = open(argv[1],O_RDONLY);
	if( -1 == fd)
	{
		perror("open");
		return -2;
	}

	fd1 = open(argv[2],O_WRONLY | O_CREAT | O_TRUNC, 0666);
	if(-1 == fd1)
	{
		perror("open");
		return -3;
	}

	while((ret = read(fd,buf,sizeof(buf))) > 0)
	{	
		write(fd1,buf,ret);
	}

	close(fd);
	close(fd1);
	return 0;
}

运行结果：