该文章参考于http://blog.csdn.net/yx_l128125/article/details/7680221，中间增加自己理解内容，在此先感谢这位大哥。
一、进程通信简介
1、进程通信目的
为什么进程间需要通信？
(1) 数据传输
一个进程需要将它的数据发送给另一个进程
(2) 资源共享
多个进程之间共享同样的资源
(3) 通知事件
一个进程需要向另一个或一组进程发送消息，通知他们发生了某事件
(4) 进程控制
有些进程希望完全控制另一个进程的执行（如：debug进程）
此时控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变。
2、Linux进程间通信（IPC）由以下几部分发展而来：
- UNIX进程间通信
- 基于System V进程间通信
- POSIX进程间通信
POSIX 介绍：POSIX（portable
operating system interface）表示可移植操作系统接口。电气和电子工程师协会（institute
of Electrical and Electronics Engineers ,IEEE）最初开发POSIX标准是为了提高UNIX环境下应用程序的可移植性。然而，POSIX并不局限与UNIX，许多其他的操作系统，例如：DEC
OpenVMS和MicrosoftWindows，都支持POSIX标准。
3、进程通讯方式 System V分类：（必须记住）
现在Linux使用的进程间通信方式包括：
(1) 管道（pipe）和有名管道（FIFO）（信息传输UNIX进程间通信
(2) 信号（signal）(控制作用)UNIX进程间通信
(3) 消息队列 system v进程间通信
(4) 共享内存 system v进程间通信
(5) 信号量 system v进程间通信
(6) 套接字（socket）
关（管）心（信）小（消息队列）攻（共享内存）心（信号量）疼（套）
二、管道通信
什么是管道？
管道是单向的、先进先出的，它把一个进程的输入和另一个进程的输出连接在一起。一个进程（写进程）在管道的尾部写入数据，另一个进程（读进程）从管道的头部读出数据。
数据被一个进程读出后，将被从管道中删除，其他读进程将不能再读到这些数据。
管道提供了简单的流程控制机制，进程试图读空管道时，进程将阻塞。同样，管道已经满时，进程再试图向管道写入数据，进程将阻塞。
管道包括无名管道和有名管道两种，前者用于父进程和子进程间通信，后者可用于运行于同一系统中的任意两个进程间的他通信。
2.1无名管道
1、创建：
无名管道由pipe()函数创建：
函数原型： int pipe (int fd[2]);
参数说明：fd[2]表示管道建立后创建的两个文件描述符，可以直接操作这两个文件描述符实现无名管道的读写。其中
fd[0]用于读管道（管道头部），fd[1]用于写管道（管道尾部）
返回值：若成功则返回0；否则返回-1;错误原因从存于error。
2、管道关闭：
关闭管道只需将这两个文件描述符关闭即可，可以使用普通的close函数逐个关闭。
例程：
#include <unistd.h>
#include <error.h>
#include <stdio.h>
#include <stdlib.h>
int main()
{
int pipe_fd[2];
if (pipe(pipe_fd)<0) //(pipe(pipe_fd)已经是在创建管道
{
printf(“pipe create error\n”);
return -1;
}
else
printf(“pipe creat success \n”);
close(pipe_fd[0]);//
close(pipe_fd[1]);//
}
3、管道读写
源码
/**********************************************************
*实验要求： 使用pipe创建无名管道并实现父子进程之间的通讯。
*功能描述： 在父进程中通过无名管道的写端写入数据，通过子进程从管道读端读出相应的数据。
*日 期： 2010-9-17
*作 者： 国嵌
**********************************************************/
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/*
* 程序入口
* */
int main()
{
int pipe_fd[2];
pid_t pid;
char buf_r[100];
char* p_wbuf;
int r_num;
memset(buf_r,0,sizeof(buf_r));
/*创建管道*/
if(pipe(pipe_fd)<0)
{
printf("pipe create error\n");
return -1;
}
/*创建子进程*/
if((pid=fork())==0) //子进程执行序列
{
printf("\n");
close(pipe_fd[1]);//子进程先关闭了管道的写端
sleep(2); /*让父进程先运行，这样父进程先写子进程才有内容读*/
if((r_num=read(pipe_fd[0],buf_r,100))>0)
{
printf("%d numbers read from the pipe is %s\n",r_num,buf_r);
}
close(pipe_fd[0]);
exit(0);
}
else if(pid>0) //父进程执行序列
{
close(pipe_fd[0]); //父进程先关闭了管道的读端
if(write(pipe_fd[1],"Hello",5)!=-1)
printf("parent write1 Hello!\n");
if(write(pipe_fd[1]," Pipe",5)!=-1)
printf("parent write2 Pipe!\n");
close(pipe_fd[1]);
waitpid(pid,NULL,0); /*等待子进程结束*/
exit(0);
}
return 0;
}
运行结果：
parent write1 Hello!
parent write2 Pipe!
10 numbers read from the pipe is Hello Pipe
执行过程：子进程先休眠2s让父进程执行，父进程通过向pipe_fd[1]文件描述符两次写入数据（hello pipe），然后阻塞等待子进程退出。子进程醒来后读取管道里数据（通过读取pipe_fd[0]文件中内容），打印出来并退出，父进程捕获子进程退出后也退出。
小结：
1、无名管道只是适用于具备血缘关系进程（父子进程或兄弟进程）
2、无名管道是半双工通讯方式，数据只能向一个方向流动。（单向性和操作时只能允许读或写）
3、无名管道是一种特殊文件，存在内存中。不能通过路径访问，但可以通过read、write对其操作。
4、为了保证父子进程都可以操作无名管道的一对文件描述符，必须在fork创建子进程前建立无名管道（这样子进程会对父进程与管道相关的信息或者是堆、栈进程拷贝走，让子进程也知道管道在哪）。
因为：在fork之后创建按管道，即是在父进程中创建管道，子进程不会知道；但如果在fork之前创建管道，子进程会继承父进程所创建的管道。
5、管道数据读取和写入：
1、写入：一个进程将数据写入无名管道的末尾pipe_fd[1]。
1）关闭该进程的读端 close（pipe_fd[0]）。作用：保证数据流向的单向性
2) 该进程将数据写入无名管道的末尾 write（pipe_fd[1],"写入内容" ,"写入长度"）
2、读取：另一个进程从无名管道头pipe_fd[0]读取出来。
1）关闭该进程的写端close（pipe_fd[1]）。作用：保证数据流向的单向性
2）该进程从无名管道头读取数据read（pipe_fd[0],"读取缓冲区" ,"读取长度"）
2.2 有名管道
有名管道和无名管道基本相同，有不同点：无名管道只能由父子进程使用；但是通过有名管道，不相关的进程也能交换数据。
1、 创建有名管道
#include<sys/types.h>
#include <sys/stat.h>
函数原型： int mkfifo(const char *pathname ,mode_t mode)
mkfifo ()会依参数pathname建立特殊的FIFO文件，该文件必须不存在，而参数mode为该文件的权限。
参数说明：
(1) pathname :创建有名管道对应的文件名（管道名）
(2) mode : 文件的权限属性
返回值：如成功返回0，否则返回-1，错误原因存于errno。
一旦创建了一个FIFO，就可用open打开它，一般的文件访问函数（close、read、
write等）都可用于FIFO。
2、操作
当使用open（）打开FIFO时，非阻塞标志（O_NONBLOCK）将对以后的读写产生如下影响：
1. 没有使用O_NONBLOCK:访问要求无法满足时将阻塞。如试图读取空的FIFO，将导致进程阻塞。
2. 使用O_NONBLOCK：访问要求无法满足时不阻塞，立即出错返回，errno是ENXIO
例程分析：
fifo_write.c
fifo_read.c
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define FIFO "/tmp/myfifo" //创建的有名管道的对应实名文件路径
/*
* 程序入口
* */
int main(int argc,char** argv)
{
int fd;
char w_buf[100];
int nwrite;
/*打开管道（fifo_read.c中创建的FIFO管道）*/
fd=open(FIFO,O_WRONLY |O_NONBLOCK,0);
if(fd==-1)
{
perror("open");
exit(1);
}
/*入参检测*/
if(argc==1)
{
printf("Please send something\n");
exit(-1);
}
strcpy(w_buf,argv[1]);
/* 向管道写入数据 */
if((nwrite=write(fd,w_buf,100))==-1)
{
if(errno==EAGAIN)//
printf("The FIFO has not been read yet.Please try later\n");
}
else
{
printf("write %s to the FIFO\n",w_buf);
}
close(fd); //关闭管道
return 0;
}
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define FIFO "/tmp/myfifo"
/*
* 程序入口
* */
int main(int argc,char** argv)
{
char buf_r[100];
int fd;
int nread;
printf("Preparing for reading bytes...\n");
memset(buf_r,0,sizeof(buf_r));
/*创建有名管道
1、创建有名管道对应的实名文件路径FIFO 即"/tmp/myfifo"
2、该管道名之前是不存在，如果之前存在FIFO路径文件，则errno返回 EEXIST值
3、 mode权限： 1、O_CREAT 创建文件
2、O_EXCL 文件存在检测，若存在，返回-1并修改errno值
3、O_RDWR 读写模式
*/
if((mkfifo(FIFO,O_CREAT|O_EXCL|O_RDWR)<0)&&(errno!=EEXIST))
{
printf("cannot create fifoserver\n");
}
/*修改/tmp/myfifo权限：支持其他用户的可读，即fifo_read.c中支持open、read的/tmp/myfifo，
之前未加入执行fifo_read.c， 输出open: Permission denied
*/
system("chmod 704 /tmp/myfifo");
/* 打开管道即打开 /tmp/myfifo */
fd=open(FIFO,O_RDONLY|O_NONBLOCK,0);
if(fd==-1)
{
perror("open");
exit(1);
}
while(1)
{
memset(buf_r,0,sizeof(buf_r));//将buf_r内存区清零
if((nread=read(fd,buf_r,100))==-1)
{
if(errno==EAGAIN)
printf("no data yet\n");
}
printf("read %s from FIFO\n",buf_r);
sleep(1);
}
/*后面三句话是不会被运行到的，但不会影响程序运行的效果。当程序在上面的死循环中执行时，
收到信号后会马上结束运行而没有执行后面的三句话。这些会在后面的信号处理中讲到，
现在不理解没有关系，这个问题留给大家学习了信号处理之后来解决。*/
close(fd); //关闭管道
pause(); /*暂停，等待信号*/
unlink(FIFO); //删除文件
}
2、写入数据，读取数据。
2.3信号通信
一．信号（signal）机制是Unix系统中最为古老的进程间通信机制，很多条件可以产生一个信号：
1.
当用户按某些按键时，产生信号。
2.
硬件异常产生信号：除数为0、无效的存储访问等。这些情况通常由硬件检测到，将其通知内核，然后内核产生适当的信号通知进程产生一个SIGSEGC信号。
3.
进程用kill函数将信号发送给另一个进程；
4.
用户可用kill命令将信号发送给其它进程。
二．信号类型：
三．信号处理：
当某信号出现时，将按照下列三种方式中的一种进行处理：
(1) 忽略此信号
大多数信号都是按照这种方式进行处理的，但是有两种信号却决不能被忽略。它们是：SIGKILL和 SIGSTOP。这两种信号不能被忽略的原因是：它们向超级用户提供了一种终止或停止进程的方法。
(2) 执行用户希望的动作
通知内核在某种信号发生时，调用一个用户函数。在用户函数中，执行用户希望的处理。
(3) 执行系统默认动作
对大多数信号的系统默认动作是终止该进程。
四．信号发送：
(1)发送信号的主要函数有 kill 和raise
区别：
用Kill -l 可以看到编号（前面的数字）
Kill
既可以向自身发送信号，也可以向其他进程发送信号。与kill函数不同的是，raise函数是向进程自身发送信号。
#include <sys/types.h>
#include <signal.h>
int kill (pid_t pid ,int signo) //第一个参数：发给哪一个进程，这个进程的pid是多少；第二个参数：发送什么信号，信号编号是多少
int raise (int signo) //因为只给自己发，所以只需要信号编号
kill
的pid参数有四种不同的取值情况：
1. pid>0
将信号发送给进程ID为pid的进程；
2.pid==0
将信号发送给同组的进程；
3.pid<0
将信号发送给其进程组ID等于pid绝对值的进程；
4.pid==-1
将信号发送给所有进程
(2)Alarm
使用alarm函数可以设置一个时间值（闹钟时间），当所设置的时间到了，产生SIGALRM信号。如果不捕捉此信号，则默认动作是终止该进程。（这个信号是发给自己的）
#include <unistd.h>
Unsigned int alarm (unsigned int seconds)
(1)Seconds:经过了指定的seconds秒后会产生信号SIGALRM.
(2)每个进程只能有一个闹钟时间。如果在调用alarm时，以前已为该进程设置过闹钟时间，而且它没有超时，以前登记的闹钟时间则被新值代替。
(3)如果有以前登记的尚未超过的闹钟时间，而这次seconds值为0.则表示取消以前的闹钟。
（3）Pause
Pause函数使用进程挂起直至捕捉到一个信号。
#include <unistd.h>
int pause (void)
pause让进程一直等待；pause结束等待的条件，进程收到一个信号
信号的处理：
信号处理的主要方法有两种：一种：是使用简单的SIGNAL函数，
另一种：是使用信号集函数组。
signal
#include<signal.h>
void(*signal (int signal,void(*func)(int)))(int)
func 可能的值是：
1.SIG_IGN:忽略此信号；
2.SIG_DFL:按系统默认方式处理
3.信号处理函数名：使用该函数处理
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
void my_func(int sign_no) /*所有信号处理函数，只有一个参数，且必须是整型*/
{
if(sign_no==SIGBUS)
printf("I have get SIGBUS\n");
else if(sign_no==SIGQUIT)
printf("I have get SIGQUIT\n");
}
int main()
{
printf("Waiting for signal SIGINT or SIGQUIT \n ");
/*注册信号处理函数*/
signal(SIGBUS, my_func);
signal(SIGQUIT, my_func);
pause();/*等待。。。直到进程收到一个信号*/
exit(0);
}
运行结果
小结：
1、信号处理函数中注册和使用方法。
通过signal函数注册指定信号的处理方式，一旦注册了信号处理方式，该进程在收到指定信号后会产生软中断，使程序进入对应处理函数执行（如果处理方式为SIG_ING,则忽略此信号）。在该进程结束以后信号的处理方式又恢复到默认状态。
2、搜索进程号指令。
ps -ef|grep ./sig_bus（执行程序名）
3、发送一个信号给进程。 有两种方法：
1、在终端输入kill命令
kill -s SIGBUS 19558 (给进程为号19558的进程发送一个SIGBUS指令)
2、程序中调用kill（）函数实现