进程间通信

linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另外一个进程中都看不到，所以进程和进程之间不能相互访问，要交互数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷贝到内核缓冲区，进程2再从内核缓冲区中把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。

在进程间完成数据传递需要借助操作系统提供的特殊方法：如：文件、管道、信号、共享内存、消息队列、套接字、命名管道等。随着计算机的蓬勃发展，一些方法由于自身缺陷被淘汰或者弃用，目前常用的进程间通信方式有：

1.管道（使用最简单）

2.信号（开销小）

3.共享映射区（无血缘关系）

4.本地套接字（最稳定）

管道

管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道，

特征：

1.其本质是一个伪文件系统（实为内核缓冲区）

2.由两个文件描述符引用，一个表示读端，一个表示写端

3.规定数据从管道的写端流入管道，从读端流出

管道的原理：管道实为内核使用环形队列机制，借助内核缓冲区（4K）实现。

管道的局限性：

1.数据不能进程自己写，自己读。

2.管道中数据不可反复读，一旦读走，管道中不再存在。

3.采用半双工通信方式，数据只能在单方向上流动。

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

int pipe(int pipefd[2]);

成功：返回0

失败：返回-1，这是errno

函数调用成功返回r/w两个文件描述符，无需open，但需手动close。规定fd[0]->r，fd[1]->w，就像0对应标准输入，1，对应标准输出一样。向管道文件读写数据其实就是在读写内核缓冲区。

管道创建成功后，创建该管道的进程（父进程）同时掌握着管道的读端和写端。

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


int main(int argc, char const *argv[])
{
	pid_t pid;
	int fd[2];
	char *str = "hello pipe\n";
	char buf[1024];
        int ret = pipe(fd);
	if(ret==-1)
	{
		perror("pipe error");
		exit(1);
	}
	pid = fork();
	if(pid==-1)
	{
		perror("fork error");
		exit(1);
	}
	else if(pid>0)
	{
		close(fd[0]);//关闭读端
		write(fd[1],str,strlen(str));
		close(fd[1]);
                sleep(1);
	}
	else
	{
		
		close(fd[1]);//关闭写段
		int ret = read(fd[0],buf,sizeof(buf));
		close(fd[0]);
		write(STDOUT_FILENO,buf,ret);
	}
	return 0;
}

管道的读写行为：

读管道：

1.管道有数据：read返回实际读到的字节数

2.管道无数据：

1）无写端，read返回0（类似读到文件尾）

2）有写端，read阻塞等待

写管道：

1.无读端，异常终止（SIGPIPE导致的）

2.有读端：

1）管道已满，阻塞等待

2）管道未满，返回写入的字节个数。

例子：

使用管道实现父子进程间通信，完成ls | wc-l，假定父进程实现ls，子进程实现wc。

ls命令正常会将结果写到stdout，但现在会写入管道的写端；wc -l正常应该从stdin读取数据，但此时会从管道的读端读。

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


int main(int argc, char const *argv[])
{
	pid_t pid;
	int fd[2];
	int ret = pipe(fd);
	if(ret==-1)
	{
		perror("pipe error");
		exit(1);
	}
	pid = fork();
	if(pid==-1)
	{
		perror("fork error");
		exit(1);
	}
	else if(pid>0)
	{
		close(fd[0]);//关闭读端
		dup2(fd[1],STDOUT_FILENO);//注意这里execlp后依然有效
		execlp("ls","ls",NULL);
		perror("execlp error");
	}
	else
	{
		close(fd[1]);//关闭写段
		dup2(fd[0],STDIN_FILENO);
		execlp("wc","wc","-l",NULL);
		perror("execlp error");
	}
	return 0;
}

兄弟进程间通信

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


int main(int argc, char const *argv[])
{
	pid_t pid;
	int fd[2];
	int ret = pipe(fd);
	int wpid;
	if(ret==-1)
	{
		perror("pipe error");
		exit(1);
	}
	for(int i=1;i<=2;i++)
	{
		pid = fork();
		if(pid==-1)
		{
			perror("fork error");
			exit(1);
		}
		else if(pid==0 && i==1)
		{
			close(fd[0]);//关闭读端
			dup2(fd[1],STDOUT_FILENO);
			execlp("ls","ls",NULL);
			perror("execlp error");
		}
		else if(pid==0 && i==2)
		{
			close(fd[1]);//关闭写端
			dup2(fd[0],STDIN_FILENO);
			execlp("wc","wc","-l",NULL);
			perror("execlp error");
		}
	}
	
	close(fd[0]);//这里得关闭父进程的读写端
	close(fd[1]);
	while((wpid=waitpid(-1,NULL,0))!=-1)
	{
		printf("wait child %d\n",wpid);
	}
	return 0;
}

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


int main(int argc, char const *argv[])
{
	pid_t pid;
	int fd[2];
	int ret = pipe(fd);
	int i;
	if(ret==-1)
	{
		perror("pipe error");
		exit(1);
	}
	for(i=1;i<=2;i++)
	{
		pid = fork();
		if(pid==-1)
		{
			perror("fork error");
			exit(1);
		}
		else if(!pid)
		{
			break;
		}
		
	}
	
	if(i==3)
	{
		close(fd[0]);//父进程关闭读写端
		close(fd[1]);
		wait(NULL);
		wait(NULL);
	}

	else if(i==1)
	{
		close(fd[0]);//关闭读端
		dup2(fd[1],STDOUT_FILENO);
		execlp("ls","ls",NULL);
		perror("execlp error");
	}
 	else if(i==2)
	{
		close(fd[1]);//关闭写端
		dup2(fd[0],STDIN_FILENO);
		execlp("wc","wc","-l",NULL);
		perror("execlp error");
	}

	return 0;
}