进程间通信就是在不同进程之间传播或交换信息，那么不同进程之间存在着什么双方都可以访问的介质呢？进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。系统空间是“公共场所”，所以内核显然可以提供这样的条件，如下图所示。除此以外，那就是双方都可以访问的外设了，两个进程可以通过磁盘上的普通文件交换信息，或者通过“注册表”或其它数据库中的某些表项和记录交换信息。
linux下的进程通信手段基本上是从Unix平台上的进程通信手段继承而来的。而对Unix发展做出重大贡献的两大主力AT&T的贝尔实验室及BSD（加州大学伯克利分校的伯克利软件发布中心）。它们在进程间通信方面的侧重点有所不同，前者对Unix早期的进程间通信手段进行了系统的改进和扩充，形成了 system
V IPC，通信进程局限在单个计算机内；后者则跳过了该限制，形成了基于套接字 socket的进程间通信机制。
Linux 则把两者继承了下来，如下图示：
Unix IPC包括： 管道、FIFO、信号；
System V IPC包括：System V消息队列、System V信号灯、System V共享内存区；
Posix IPC包括： Posix消息队列、Posix信号灯、Posix共享内存区。
有两点需要简单说明一下：
1.由于Unix版本的多样性，电子电气工程协会（IEEE）开发了一个独立的Unix标准，这个新的ANSI Unix标准被称为计算
机环境的可移植性操作系统界面（PSOIX）。现有大部分Unix和流行版本都是遵循POSIX标准的，而Linux从一开始就遵循POSIX标准；
2.BSD并不是没有涉足单机内的进程间通信（socket本身就可以用于单机内的进程间通信）。事实上，很多Unix版本的单
机IPC留有BSD的痕迹，如4.4BSD支持的匿名内存映射、4.3+BSD对可靠信号语义的实现等等。
上图给出了linux 所支持的各种IPC手段，为了避免概念上的混淆，在尽可能少提及Unix的各个版本的情况下，所有问题的讨论最终都会归结到linux环境下的进程间通信上来。并且，对于linux所支持通信手段的不同实现版本（如对于共享内存来说，有Posix共享内存区以及System V共享内存区两个实现版本）下面将主要介绍Posix API。
linux下进程间通信的几种主要手段：
当从一个进程连接数据流到另一个进程时，使用术语管道(pipe)。通常是把一个进程的输出通过管道连接到另一个进程的输入。
对于shell命令来说，命令的连接是通过管道操作符来完成的，如下所示：
cmd1 | cmd2 shell负责安排两个命令的标准输入和标准输出 cmd1的标准输入来自终端键盘 cmd1的标准输出传递给cmd2,作为它的标准输入 cmd2的标准输出连接到终端屏幕
shell所做的工作实际上是对标准输入和标准输出流进行重新连接，使数据流从键盘输入通过两个命令最终输出到屏幕上。
函数原型:
#include <stdio.h>
FILE *popen(const char*command,const char *open_mode);
int pclose(FILE *stream_to_close);
函数描述:
popen 函数允许一个程序将另一个程序作为新进程来启动，并可以传递数据给它或者通过它来接收数据。
command 字符串是要运行的程序名和相应的参数，这个命令被送到 /bin/sh 以 -c 参数执行, 即由 shell来执行。
open_mode 必须为"r"或者"w"，二者只能选择一个，函数的返回值FILE*文件流指针，通过常用的stdio库函数
(如fread)来读取被调用程序的输出。如果open_mode是"w"，调用程序就可以用fwrite调用向被调用程序发送
数据，而被调用程序可以在自己的标准输入上读取数据。
补:/bin/sh -c
Read commands from the command_string operand instead of from the standard input.
Special parameter 0 will be set from the command_name operand and the positional
parameters ($1, $2, etc.) set from the remaining argument operands.
读取外部程序的输出：
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
FILE *read_fp;
char buffer[BUFSIZ+1];
int chars_read;
memset(buffer,‘\0‘,sizeof(buffer));
read_fp = popen("uname -a","r");
if (read_fp !=NULL)
{
chars_read = fread(buffer,sizeof(char),BUFSIZ,read_fp);
if (chars_read>0)
{
printf("output was:-\n%s\n",buffer);
}
pclose(read_fp);
exit(EXIT_SUCCESS);
}
exit(EXIT_FAILURE);
}
将输出发送到外部程序:
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
FILE *write_fp;
char buffer[BUFSIZ+1];
sprintf(buffer,"Once upon a time ,thera was ...\n");
write_fp = popen("od -c","w");
if (write_fp != NULL)
{
fwrite(buffer,sizeof(char),strlen(buffer),write_fp);
pclose(write_fp);
exit(EXIT_SUCCESS);
}
exit(EXIT_FAILURE);
}
注意:popen()函数的返回值是一个普通的标准I/O流,且它只能用pclose()函数来关闭,而不是fclose()。
popen函数运行一个程序时，它首先启动shell,即系统中的sh命令，然后将command字符串作为一个参数传递给它，由shell来负责分析命令字符串，它允许我们通过popen启动非常复杂的shell命令。使用shell的一个不太好的影响是，针对每个popen的调用，不仅要启动一个被请求的程序，还要启动一个shell，即每个popen调用将多启动两个进程，从节省资源的角度来看，popen函数的调用成本略高，而且对目标命令的调用比正常方式要慢一些。 pclose调用只在popen启动的进程结束后才返回。如果调用pclose时它仍在运行，pclose调用将等待该进程的结束。
底层pipe函数，通过这个函数在两个程序之间传递数据不需要启动一个shell来解释请求命令，它同时还提供了对读写数据的更多控制。
函数原型:
#include <unistd.h>
int pipe(int file_descriptor[2]);
函数描述:
pipe 函数参数是一个由两个整数类型的文件描述符组成的数组的指针。该函数在数组中填上两个新的文件描述符后返回0,如果
失败则返回-1,并设置error来表明失败的原因。
常见的错误：
EMFILE:进程使用的文件描述符过多
ENFILE:系统的文件表已满
EFAULT:文件描述符无效
两个返回的文件描述符以一种特殊的方式连接起来，写到file_descriptor[1]的所有数据都可以从file_descriptor[0]读出来。
数据基于先进先出的原则进行处理，意味着如果你把1,2,3写到file_descriptor[1],从file_descriptior[0]读取到的数据也
是1,2,3。
注意:调用pipe函数时在内核中开辟一块缓冲区（称为管道）用于通信，它有一个读端一个写端，然后通过file_descriptor 参数传出给用户程序两个文件描述符，file_descriptor[0]指向管道的读端，file_descriptor[1]指向管道的写端。在用户程序看起来管道就像一个打开的文件，通过read(file_descriptor[0])或者write(file_descriptor[1])来向这个文件读写数据，其实是在读写内核缓冲区。两个文件描述符被强制规定file_descriptor[0] 只能指向管道的读端，如果进行写操作就会出现错误；同理 file_descriptor[1]只能指向管道的写端，如果进行读操作就会出现错误。pipe使用的是文件描述符而不是文件流，所以必须使用底层的read和write调用来访问数据，而不是用文件流函数fread和fwrite。
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main()
{
int data_processed;
int file_pipes[2];
const char some_data[] = "1233";
char buffer[BUFSIZ+1];
memset(buffer,‘\0‘,sizeof(buffer));
if (pipe(file_pipes)==0)
{
data_processed = write(file_pipes[1],some_data,strlen(some_data));
printf("Wrote %d bytes \n",data_processed);
data_processed = read(file_pipes[0],buffer,BUFSIZ);
printf("Read %d bytes \n",data_processed);
exit(EXIT_SUCCESS);
}
exit(EXIT_FAILURE);
}
程序说明: 这个程序用数组 file_pipes 中的两个文描述符创建一个管道，然后它用文件描述符 file_pipes[1] 向管道中写数据
，再从 file_pipes[0] 读回数据。
管道的真正优势体现在:两个进程之间传递数据。 当程序用fork调用创建新进程时，原先打开的文件描述符仍将保持打开状态。如果在原先的进程中创建一个管道，然后再调用fork创建新进程，即可以通过管道在两个进程之间传递数据，如下图所示:
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
int main()
{
int data_processed;
int file_pipes[2];
const char some_data[] = "1233";
char buffer[BUFSIZ+1];
pid_t fork_result;
memset(buffer,‘\0‘,sizeof(buffer));
if (pipe(file_pipes)==0)
{
fork_result = fork();
if (fork_result ==-1)
{
fprintf(stderr,"Fork failed");
exit(EXIT_FAILURE);
}
if (fork_result ==0)
{
close(file_pipes[1]);
sleep(2);
data_processed = read(file_pipes[0],buffer,BUFSIZ);
printf("Read %d bytes :%s \n",data_processed,buffer);
}
else
{
close(file_pipes[0]);
data_processed = write(file_pipes[1],some_data,strlen(some_data));
printf("Wrote %d bytes \n",data_processed);
}
exit(EXIT_SUCCESS);
}
exit(EXIT_FAILURE);
}
程序说明: 程序首先用pipe函数创建一个管道，接着用fork调用创建一个新进程。如果fork调用成功，父进程首先关闭读操作符，然后写数据到管道中，而子进程首先关闭写操作符，然后从管道中读取数据。父子进程都在只调用了一次write或read之后就退出。其原理如下图所示:
系统维护一个文件的文件描述符表计数，父子进程都各自有指向相同文件的文件描述符，当关闭一个文件描述符时，相应计数减1，当这个计数减到0时，文件就被关闭，因此虽然父进程关闭了其文件描述符 file_pipes[0]，但是这个文件的文件描述符计数还没等于0，所以子进程还可以读取。也可以这么理解，父进程和子进程都有各自的文件描述符，虽然在父进程中关闭了file_pipes[0]，但是对子进程中的 file_pipes[0] 没有影响。
注:1.文件表中的每一项都会维护一个引用计数，标识该表项被多少个文件描述符(fd)引用，在引用计数为0的时候，表项才会被删除。所以调用close(fd)关闭子进程的文件描述符，只会减少引用计数，但是不会使文件表项被清除，所以父进程依旧可以访问。
2.当没有数据可读时，read调用通常会阻塞，即它将暂停进程来等待直到有数据到达为止。如果管道的另一端已被关闭，也就是说没有进程打开这个管道并向它写数据了，此时read调用将会被阻塞。注意，这与读取一个无效的文件描述符不同，read把无效的文件描述符看做一个错误并返回-1.
在pipe使用中，也可以在子进程中运行一个与其父进程完全不同的另一个程序，而不是仅仅运行一个相同的程序。这个可由exec调用来实现。在上面的例子中，因为子进程本身有 file_pipes 数据的一个副本，所以这并不成为问题。但经过exec调用后，原来的进程已经被新的子进程替换了。为解决这个问题，可以将文件描述符（实际上是一个数字)作为一个参数传递给exec启动程序。详细实现见:pipe3.c 和 pipe4.c
无名管道只能用在父子进程之间，这些程序由一个共同的祖先进程启动。但如果想在不同进程之间交换数据，这就不太方便。而这可以使用FIFO文件来完成在不相关的进程之间交换数据，它通常叫做命名管道（named pipe)。
命名管道是一种特殊类型的文件，它在文件系统中以文件名的形式存在，但它的行为却和已经看到过的没有名字的管道类似。
使用下面两个函数可以创建一个FIFO文件:
int mkfifo(const char*filename,mode_t mode)
int mknod(const char* filename,mode_t mode | S_IFIFO,(dev_t)0);
命名管道的一个非常有用特点是：由于它们出现在文件系统中，所以它们可以像平常的文件名一样在命令中使用，使用FIFO只是为了单向传递数据。
使用方法如下:
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
int main()
{
int res = mk fifo("/tmp/my_fifo",0777);
if (res == 0)
{
printf("FIFO created.\n");
}
exit(EXIT_SUCCESS);
}
查看运行结果:
注:输出结果中的第一个字符为p，表示这是一个管道文件。不同的用户掩码最后得到的文件访问权限是不同的(我的用户掩码为0002）。
与通过pipe调用创建管道不同，FIFO是以命名文件的形式存在，而不是打开的文件描述符，所以对它进行读写操作必须先打开它。FIFO也用open和close函数打开和关闭。 对FIFO文件来说，传递给open调用的是FIFO的路径名，而不是一个正常的文件。
打开一个FIFO文件的方法如下:
open(const char*path,O_RDONLY);
在这种情况下，open调用将阻塞，除非有一个进程以写的方式打开同一个FIFO,否则它不会返回。
open(const char* path,O_RDONLY|O_NONBLOCK)
在这种情况下，即使没有其它进程以写方式打开FIFO,open调用也将成功并立刻返回。
open(const char *path,O_WRONLY)
在这种情况下，open调用将会阻塞，直到有一个进程以读方式打开一个FIFO为止。
open(const char*path,O_WRONLY|O_NONBLOCK)
这个函数调用总是立刻返回，但如果没有一个进程以读方式打开FIFO文件，open调用将返回一个错误并且FIFO也不会被打开。
如果确实有一个进程以读方式打开FIFO文件，那么我们就可以通过它返回的文件描述符对这个FIFO文件进行读写操作。
注意:
O_NONBLOCK 分别搭配O_RDONLY 和 O_WRONLY在效果上是不同的，如果没有进程以读方式打开管道，非阻塞写方式的open调用将失败，但非阻塞读方式的open调用总是成功。close调用的行为并不受 O_NONBLOCK标志的影响。
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#define FIFO_NAME "/tmp/my_fifo"
int main(int argc,char* argv[])
{
int res;
int open_mode = 0;
int i;
if (argc <2)
{
fprintf(stderr, "Usage:%s <some combination of O_RDONLY O_WRONLY O_NONBLOCK>\n",*argv );
exit(EXIT_FAILURE);
}
for (i = 1; i < argc; ++i)
{
if (strncmp(*++argv,"O_RDONLY",8) == 0)
{
open_mode |= O_RDONLY;
}
if (strncmp(*argv,"O_WRONLY",8) == 0 )
{
open_mode |= O_WRONLY;
}
if (strncmp(*argv,"O_NONBLOCK",10) == 0)
{
open_mode |= O_NONBLOCK;
}
}
if (access(FIFO_NAME,F_OK) == -1)
{
res = mkfifo(FIFO_NAME,0777);
if (res !=0)
{
fprintf(stderr,"Could not create fifo %s\n",FIFO_NAME);
exit(EXIT_FAILURE);
}
}
printf("Process %d opening FIFO\n",getpid());
res = open(FIFO_NAME,open_mode);
printf("Process %d result %d\n",getpid(),res);
sleep(5);
if (res != -1)
{
(void)close(res);
}
printf("Process %d finished\n",getpid());
exit(EXIT_SUCCESS);
}
使用 O_NONBLOCK模式会影响到对FIFO的read和write调用。
小结:
1. 从FIFO中读取数据
2. 从FIFO中写入数据
FIFO的长度是需要考虑的一个很重要因素。
系统对任一时刻在一个FIFO中可以存在的数据长度是有限制的。它由#define PIPE_BUF定义，在头文件limits.h 中。在Linux和其它类UNIX系统中，它的值通常是4096字节，Red
Hat Fedora9 下是4096，但在某些系统中它可能会小到512字节。
虽然对于只有一个FIFO写进程和一个FIFO读进程而言，这个限制并不重要，但只使用一个FIFO并允许多个不同进程向一个FIFO读进程发送写请求的情况是很常见的。如果几个不同的程序尝试同时向FIFO写数据，能否保证来自不同程序的数据块不相互交错就非常关键了。也就是说，必须保证每个写操作“原子化”。
对于设置了阻塞标志的写操作：
PIPE_BUF时，linux将保证写入的原子性。如果此时管道空闲缓冲区不足以容纳要写入的字节数，则进入睡眠，直到当缓冲区中能够容纳要写入的字节数时，才开始进行一次性写操作。即写入的数据长度小于等于PIPE_BUF时，那么或者写入全部字节，或者一个字节都不写入，它属于一个一次性行为，具体要看FIFO中是否有足够的缓冲区。PIPE_BUF时，linux将不再保证写入的原子性。FIFO缓冲区一有空闲区域，写进程就会试图向管道写入数据，写操作在写完所有请求的数据后返回。对于没有设置阻塞标志的写操作：
PIPE_BUF时，linux将保证写入的原子性。如果当前FIFO空闲缓冲区能够容纳请求写入的字节数，写完后成功返回；如果当前FIFO空闲缓冲区不能够容纳请求写入的字节数，则返回EAGAIN错误，提示以后再写。PIPE_BUF时，linux将不再保证写入的原子性。在写满所有FIFO空闲缓冲区后，写操作返回。原文地址：http://blog.csdn.net/zhangzhebjut/article/details/40142573
