posix进程间的通信

1.无名管道

1.1管道是Linux支持的最初Unix IPC形式之一，具有以下特点：

• 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道；
• 只能用于父子进程或者兄弟进程之间（具有亲缘关系的进程）；
• 单独构成一种独立的文件系统：管道对于管道两端的进程而言，就是一个文件，但它不是普通的文件，它不属于某种文件系统，而是自立门户，单独构成一种文件系统，并且只存在与内存中。
• 数据的读出和写入：一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾，并且每次都是从缓冲区的头部读出数据。

1.2管道的局限性

管道的主要局限性正体现在它的特点上：

• 只支持单向数据流；
• 只能用于具有亲缘关系的进程之间；
• 没有名字；
• 管道的缓冲区是有限的（管道制存在于内存中，在管道创建时，为缓冲区分配一个页面大小）；
• 管道所传送的是无格式字节流，这就要求管道的读出方和写入方必须事先约定好数据的格式，比如多少字节算作一个消息（或命令、或记录）等等；

２有名管道

 　基本同普通文件操作　

　　　mkfifo创建管道文件，open打开管道，write向管道中写数据，read从管道中读数据。

３.信号及信号来源

　3.1信号是在软件层次上对中断机制的一种模拟，在原理上，一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的，一个进程不必通过任何操作来等待信号的到达，事实上，进程也不知道信号到底什么时候到达。

信号是进程间通信机制中唯一的异步通信机制，可以看作是异步通知，通知接收信号的进程有哪些事情发生了。信号机制经过POSIX实时扩展后，功能更加强大，除了基本通知功能外，还可以传递附加信息。

信号来源

信号事件的发生有两个来源：硬件来源(比如我们按下了键盘或者其它硬件故障)；软件来源，最常用发送信号的系统函数是kill, raise, alarm和setitimer以及sigqueue函数，软件来源还包括一些非法运算等操作。

3.2

信号值位于SIGRTMIN和SIGRTMAX之间的信号都是可靠信号，可靠信号克服了信号可能丢失的问题。Linux在支持新版本的信号安装函数 sigation（）以及信号发送函数sigqueue()的同时，仍然支持早期的signal（）信号安装函数，支持信号发送函数kill()。

注：不要有这样的误解：由sigqueue()发送、sigaction安装的信号就是可靠的。事实上，可靠信号是指后来添加的新信号（信号值位于 SIGRTMIN及SIGRTMAX之间）；不可靠信号是信号值小于SIGRTMIN的信号。信号的可靠与不可靠只与信号值有关，与信号的发送及安装函数 无关。目前linux中的signal()是通过sigation()函数实现的，因此，即使通过signal（）安装的信号，在信号处理函数的结尾也不 必再调用一次信号安装函数。同时，由signal()安装的实时信号支持排队，同样不会丢失。

对于目前linux的两个信号安装函数:signal()及sigaction()来说，它们都不能把SIGRTMIN以前的信号变成 可靠信号（都不支持排队，仍有可能丢失，仍然是不可靠信号），而且对SIGRTMIN以后的信号都支持排队。这两个函数的最大区别在于，经过 sigaction安装的信号都能传递信息给信号处理函数（对所有信号这一点都成立），而经过signal安装的信号却不能向信号处理函数传递信息。对于 信号发送函数来说也是一样的。

3.3实时信号与非实时信号

非实时信号都不支持排队，都是不可靠信号；实时信号都支持排队，都是可靠信号。

3.４信号对进程的响应

进程可以通过三种方式来响应一个信号：（1）忽略信号，即对信号不做任何处理，其中，有两个信号不能忽略：SIGKILL及SIGSTOP；（2） 捕捉信号。定义信号处理函数，当信号发生时，执行相应的处理函数；（3）执行缺省操作，Linux对每种信号都规定了默认操作，详细情况请参考[2]以及 其它资料。注意，进程对实时信号的缺省反应是进程终止。

各信号意义：

　　SIGHUP 终止进程 终端线路挂断　　　　　　　　　　　　　　　SIGINT 终止进程 中断进程  　　　　　　　　SIGQUIT 建立CORE文件 终止进程，并且生成core文件

    SIGILL 建立CORE文件 非法指令　　　　　　　　　　　　　　　 SIGTRAP 建立CORE文件 跟踪自陷　　　 　SIGBUS 建立CORE文件 总线错误

    SIGSEGV 建立CORE文件 段非法错误　　　　　　　　　　　　　SIGFPE 建立CORE文件 浮点异常　　　　　SIGIOT 建立CORE文件 执行I/O自陷

    SIGKILL 终止进程 杀死进程　　　　　　　　　　　　　　　　　　SIGPIPE 终止进程 向一个没有读进程的管道写数据

    SIGALARM 终止进程 计时器到时

    SIGTERM 终止进程 软件终止信号

    SIGSTOP 停止进程 非终端来的停止信号

    SIGTSTP 停止进程 终端来的停止信号

    SIGCONT 忽略信号 继续执行一个停止的进程

    SIGURG 忽略信号 I/O紧急信号

    SIGIO 忽略信号 描述符上可以进行I/O

    SIGCHLD 忽略信号 当子进程停止或退出时通知父进程

    SIGTTOU 停止进程 后台进程写终端

    SIGTTIN 停止进程 后台进程读终端

    SIGXGPU 终止进程 CPU时限超时

    SIGXFSZ 终止进程 文件长度过长

    SIGWINCH 忽略信号 窗口大小发生变化

    SIGPROF 终止进程 统计分布图用计时器到时

    SIGUSR1 终止进程 用户定义信号1

    SIGUSR2 终止进程 用户定义信号2

    SIGVTALRM 终止进程 虚拟计时器到时

3.5信号的发送

发送信号的主要函数有：kill()、raise()、 sigqueue()、alarm()、setitimer()以及abort()

如果是向进程本身发送信号

1.raise()：向进程本身发送信号。

2.int kill(pid_t pid,int signo)

参数pid的值	信号的接收进程
pid>0	进程ID为pid的进程
pid=0	同一个进程组的进程
pid<0 pid!=-1	进程组ID为 -pid的所有进程
pid=-1	除发送进程自身外，所有进程ID大于1的进程

Sinno是信号值，当为0时（即空信号），实际不发送任何信号，但照常进行错误检查，因此，可用于检查目标进程是否存在，以及当前进 程是否具有向目标发送信号的权限（root权限的进程可以向任何进程发送信号，非root权限的进程只能向属于同一个session或者同一个用户的进程 发送信号）。

3、sigqueue（）
int sigqueue(pid_t pid, int sig, const union sigval val)
调用成功返回 0；否则，返回 -1。

sigqueue()是比较新的发送信号系统调用，主要是针对实时信号提出的（当然也支持前32种），支持信号带有参数，与函数sigaction()配合使用。

sigqueue的第一个参数是指定接收信号的进程ID，第二个参数确定即将发送的信号，第三个参数是一个联合数据结构union sigval，指定了信号传递的参数，即通常所说的4字节值。

 typedef union sigval { 

             int sival_int; 

             void *sival_ptr; 

             }sigval_t; 

sigqueue()比kill()传递了更多的附加信息，但sigqueue()只能向一个进程发送信号，而不能发送信号给一个进程 组。如果signo=0，将会执行错误检查，但实际上不发送任何信号，0值信号可用于检查pid的有效性以及当前进程是否有权限向目标进程发送信号。

在调用sigqueue时，sigval_t指定的信息会拷贝到3参数信号处理函数（3参数信号处理函数指的是信号处理函数由 sigaction安装，并设定了sa_sigaction指针，稍后将阐述）的siginfo_t结构中，这样信号处理函数就可以处理这些信息了。由于 sigqueue系统调用支持发送带参数信号，所以比kill()系统调用的功能要灵活和强大得多。

注：sigqueue（）发送非实时信号时，第三个参数包含的信息仍然能够传递给信号处理函数； sigqueue（）发送非实时信号时，仍然不支持排队，即在信号处理函数执行过程中到来的所有相同信号，都被合并为一个信号。

4、alarm（）
#include <unistd.h>
unsigned int alarm(unsigned int seconds)
专门为SIGALRM信号而设，在指定的时间seconds秒后，将向进程本身发送SIGALRM信号，又称为闹钟时间。进程调用alarm后，任何以前的alarm()调用都将无效。如果参数seconds为零，那么进程内将不再包含任何闹钟时间。
返回值，如果调用alarm（）前，进程中已经设置了闹钟时间，则返回上一个闹钟时间的剩余时间，否则返回0。

5、setitimer（）
#include <sys/time.h>
int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue));
setitimer()比alarm功能强大，支持3种类型的定时器：

• ITIMER_REAL： 设定绝对时间；经过指定的时间后，内核将发送SIGALRM信号给本进程；
• ITIMER_VIRTUAL 设定程序执行时间；经过指定的时间后，内核将发送SIGVTALRM信号给本进程；
• ITIMER_PROF 设定进程执行以及内核因本进程而消耗的时间和，经过指定的时间后，内核将发送ITIMER_VIRTUAL信号给本进程；

6、abort()
#include <stdlib.h>
void abort(void);

向进程发送SIGABORT信号，默认情况下进程会异常退出，当然可定义自己的信号处理函数。即使SIGABORT被进程设置为阻塞信号，调用abort()后，SIGABORT仍然能被进程接收。该函数无返回值。

 3.5信号的安装

linux主要有两个函数实现信号的安装：signal()、sigaction()。其中signal()在可靠信号系统调用的基础上实现, 是库函数。它只有两个参数，不支持信号传递信息，主要是用于前32种非实时信号的安装；而sigaction()是较新的函数（由两个系统调用实 现：sys_signal以及sys_rt_sigaction），有三个参数，支持信号传递信息，主要用来与 sigqueue() 系统调用配合使用，当然，sigaction()同样支持非实时信号的安装。sigaction()优于signal()主要体现在支持信号带有参数。

1、signal()
#include <signal.h>
void (*signal(int signum, void (*handler))(int)))(int);
如果该函数原型不容易理解的话，可以参考下面的分解方式来理解：
typedef void (*sighandler_t)(int)；
sighandler_t signal(int signum, sighandler_t handler));
第一个参数指定信号的值，第二个参数指定针对前面信号值的处理，可以忽略该信号（参数设为SIG_IGN）；可以采用系统默认方式处理信号(参数设为SIG_DFL)；也可以自己实现处理方式(参数指定一个函数地址)。
如果signal()调用成功，返回最后一次为安装信号signum而调用signal()时的handler值；失败则返回SIG_ERR。

#include <signal.h>

  3 

  4 

  5 #if 1

  6 void func(int tmp);

  7 

  8 int main(int argc,char *argv[]){

  9     

 10     int signum;

 11 

 12     if(argc<2){

 13         printf("Usage Please Signum");

 14     }

 15 

 16     signum = atoi(argv[1]);

 17 

 18     signal(signum,func);

 19     while(1){

 20         printf("wait the signal!
");

 21         sleep(2);

 22     }

 23 

 24     return 0;

 25 }

 26 

 27 void func(int tmp){

 28     sleep(4);

 29     printf("%s, %d
",__FILE__,__LINE__);

 30 

 31 }

 32 #endif

2、sigaction()
#include <signal.h>
int sigaction(int signum,const struct sigaction *act,struct sigaction *oldact));

sigaction函数用于改变进程接收到特定信号后的行为。该函数的第一个参数为信号的值，可以为除SIGKILL及SIGSTOP 外的任何一个特定有效的信号（为这两个信号定义自己的处理函数，将导致信号安装错误）。第二个参数是指向结构sigaction的一个实例的指针，在结构 sigaction的实例中，指定了对特定信号的处理，可以为空，进程会以缺省方式对信号处理；第三个参数oldact指向的对象用来保存原来对相应信号 的处理，可指定oldact为NULL。如果把第二、第三个参数都设为NULL，那么该函数可用于检查信号的有效性。

第二个参数最为重要，其中包含了对指定信号的处理、信号所传递的信息、信号处理函数执行过程中应屏蔽掉哪些函数等等。

sigaction结构定义如下：

 struct sigaction { 

             union{ 

             __sighandler_t _sa_handler; 

             void (*_sa_sigaction)(int,struct siginfo *, void *)； 

             }_u 

             sigset_t sa_mask； 

             unsigned long sa_flags； 

             void (*sa_restorer)(void)； 

             } 

其中，sa_restorer，已过时，POSIX不支持它，不应再被使用。

1、联合数据结构中的两个元素_sa_handler以及*_sa_sigaction指定信号关联函数，即用户指定的信号处理函数。除了可以是用户自定义的处理函数外，还可以为SIG_DFL(采用缺省的处理方式)，也可以为SIG_IGN（忽略信号）。

2、由_sa_handler指定的处理函数只有一个参数，即信号值，所以信号不能传递除信号值之外的任何信息；由 _sa_sigaction是指定的信号处理函数带有三个参数，是为实时信号而设的（当然同样支持非实时信号），它指定一个3参数信号处理函数。第一个参 数为信号值，第三个参数没有使用（posix没有规范使用该参数的标准），第二个参数是指向siginfo_t结构的指针，结构中包含信号携带的数据值， 参数所指向的结构如下：

 siginfo_t { 

             int si_signo; /* 信号值，对所有信号有意义*/ 

             int si_errno; /* errno值，对所有信号有意义*/ 

             int si_code; /* 信号产生的原因，对所有信号有意义*/ 

             union{ /* 联合数据结构，不同成员适应不同信号 */ //确保分配足够大的存储空间 

             int _pad[SI_PAD_SIZE]; //对SIGKILL有意义的结构 

             struct{ ... }... 

             ... ... ... ... //对SIGILL, SIGFPE, SIGSEGV, SIGBUS有意义的结构 

             struct{ ... }... ... ... } } 

注：为了更便于阅读，在说明问题时常把该结构表示为附录2所表示的形式。

siginfo_t结构中的联合数据成员确保该结构适应所有的信号，比如对于实时信号来说，则实际采用下面的结构形式：

	typedef struct { 

             int si_signo; 

             int si_errno; 

             int si_code; 

             union sigval si_value; 

             } siginfo_t; 

结构的第四个域同样为一个联合数据结构：

	union sigval { 

             int sival_int; 

             void *sival_ptr; 

             } 

采用联合数据结构，说明siginfo_t结构中的si_value要么持有一个4字节的整数值，要么持有一个指针，这就构成了与信号 相关的数据。在信号的处理函数中，包含这样的信号相关数据指针，但没有规定具体如何对这些数据进行操作，操作方法应该由程序开发人员根据具体任务事先约 定。

前面在讨论系统调用sigqueue发送信号时，sigqueue的第三个参数就是sigval联合数据结构，当调用sigqueue 时，该数据结构中的数据就将拷贝到信号处理函数的第二个参数中。这样，在发送信号同时，就可以让信号传递一些附加信息。信号可以传递信息对程序开发是非常 有意义的。

信号参数的传递过程可图示如下：

3、sa_mask指定在信号处理程序执行过程中，哪些信号应当被阻塞。缺省情况下当前信号本身被阻塞，防止信号的嵌套发送，除非指定SA_NODEFER或者SA_NOMASK标志位。

注：请注意sa_mask指定的信号阻塞的前提条件，是在由sigaction（）安装信号的处理函数执行过程中由sa_mask指定的信号才被阻塞。

4、sa_flags中包含了许多标志位，包括刚刚提到的SA_NODEFER及SA_NOMASK标志位。另一个比较重要的标志位是 SA_SIGINFO，当设定了该标志位时，表示信号附带的参数可以被传递到信号处理函数中，因此，应该为sigaction结构中的 sa_sigaction指定处理函数，而不应该为sa_handler指定信号处理函数，否则，设置该标志变得毫无意义。即使为 sa_sigaction指定了信号处理函数，如果不设置SA_SIGINFO，信号处理函数同样不能得到信号传递过来的数据，在信号处理函数中对这些信 息的访问都将导致段错误（Segmentation fault）。

注：很多文献在阐述该标志位时都认为，如果设置了该标志位，就必须定义三参数信号处理函数。实际不是这样的，验证方法很简单：自己实现 一个单一参数信号处理函数，并在程序中设置该标志位，可以察看程序的运行结果。实际上，可以把该标志位看成信号是否传递参数的开关，如果设置该位，则传递 参数；否则，不传递参数。

#if 1 

 34 #include <signal.h>

 35 #include <sys/types.h>

 36 #include <unistd.h>

 37 void new_op(int,siginfo_t*,void*);

 38 

 39 int main(int argc,char**argv)

 40 {

 41     struct sigaction act;

 42     int sig;                                                                                                                                       

 43     sig=atoi(argv[1]);

 44     sigemptyset(&act.sa_mask);

 45     act.sa_flags=SA_SIGINFO;

 46     act.sa_sigaction=new_op;

 47 

 48     if(sigaction(sig,&act,NULL) < 0)

 49     {

 50         printf("install sigal error
");

 51     }

 52 

 53     while(1)

 54     {

 55         sleep(2);

 56         printf("wait for the signal
");

 57     }

 58 }

 59 void new_op(int signum,siginfo_t *info,void *myact)

 60 {

 61     printf("receive signal %d", signum);

 62     sleep(5);

 63 }

 64 #endif

 3.6信号集及信号集操作函数

信号集被定义为一种数据类型：



    typedef struct {

            unsigned long sig[_NSIG_WORDS]；

            } sigset_t





信号集用来描述信号的集合，linux所支持的所有信号可以全部或部分的出现在信号集中，主要与信号阻塞相关函数配合使用。下面是为信号集操作定义的相关函数：



#include <signal.h>

int sigemptyset(sigset_t *set)；

int sigfillset(sigset_t *set)；

int sigaddset(sigset_t *set, int signum)

int sigdelset(sigset_t *set, int signum)；

int sigismember(const sigset_t *set, int signum)；

sigemptyset(sigset_t *set)初始化由set指定的信号集，信号集里面的所有信号被清空；

sigfillset(sigset_t *set)调用该函数后，set指向的信号集中将包含linux支持的64种信号；

sigaddset(sigset_t *set, int signum)在set指向的信号集中加入signum信号；

sigdelset(sigset_t *set, int signum)在set指向的信号集中删除signum信号；

sigismember(const sigset_t *set, int signum)判定信号signum是否在set指向的信号集中。

3.6信号的阻塞与信号未决

每个进程都有一个用来描述哪些信号递送到进程时将被阻塞的信号集，该信号集中的所有信号在递送到进程后都将被阻塞。下面是与信号阻塞相关的几个函数：



#include <signal.h>

int  sigprocmask(int  how,  const  sigset_t *set, sigset_t *oldset))；

int sigpending(sigset_t *set));

int sigsuspend(const sigset_t *mask))；





sigprocmask()函数能够根据参数how来实现对信号集的操作，操作主要有三种：

参数how    进程当前信号集

SIG_BLOCK    在进程当前阻塞信号集中添加set指向信号集中的信号

SIG_UNBLOCK    如果进程阻塞信号集中包含set指向信号集中的信号，则解除对该信号的阻塞

SIG_SETMASK    更新进程阻塞信号集为set指向的信号集



sigpending(sigset_t *set))获得当前已递送到进程，却被阻塞的所有信号，在set指向的信号集中返回结果。



sigsuspend(const sigset_t *mask))用于在接收到某个信号之前, 临时用mask替换进程的信号掩码, 并暂停进程执行，直到收到信号为止。sigsuspend 返回后将恢复调用之前的信号掩码。信号处理函数完成后，进程将继续执行。该系统调用始终返回-1，并将errno设置为EINTR。



附录1：结构itimerval：



            struct itimerval {

                struct timeval it_interval; /* next value */

                struct timeval it_value;    /* current value */

            };

            struct timeval {

                long tv_sec;                /* seconds */

                long tv_usec;               /* microseconds */

            };





附录2：三参数信号处理函数中第二个参数的说明性描述：



siginfo_t {

int      si_signo;  /* 信号值，对所有信号有意义*/

int      si_errno;  /* errno值，对所有信号有意义*/

int      si_code;   /* 信号产生的原因，对所有信号有意义*/

pid_t    si_pid;    /* 发送信号的进程ID,对kill(2),实时信号以及SIGCHLD有意义 */

uid_t    si_uid;    /* 发送信号进程的真实用户ID，对kill(2),实时信号以及SIGCHLD有意义 */

int      si_status; /* 退出状态，对SIGCHLD有意义*/

clock_t  si_utime;  /* 用户消耗的时间，对SIGCHLD有意义 */

clock_t  si_stime;  /* 内核消耗的时间，对SIGCHLD有意义 */

sigval_t si_value;  /* 信号值，对所有实时有意义，是一个联合数据结构，

                          /*可以为一个整数（由si_int标示，也可以为一个指针，由si_ptr标示）*/

    

void *   si_addr;   /* 触发fault的内存地址，对SIGILL,SIGFPE,SIGSEGV,SIGBUS 信号有意义*/

int      si_band;   /* 对SIGPOLL信号有意义 */

int      si_fd;     /* 对SIGPOLL信号有意义 */

}





实际上，除了前三个元素外，其他元素组织在一个联合结构中，在联合数据结构中，又根据不同的信号组织成不同的结构。注释中提到的对某种信号有意义指的是，在该信号的处理函数中可以访问这些域来获得与信号相关的有意义的信息，只不过特定信号只对特定信息感兴趣而已。

 不同进程间的附带信号与值传递

  发送程序：

Send.c

#include <signal.h>

#include <unistd.h>





#define ABORT()  {printf("File:%s,Line:%d
",__FILE__,__LINE__);abort();}



int main(int argc,char *argv[]){

    int signum;

    signum = atoi(argv[1]);



    int pid ;

    pid   = atoi(argv[2]);



    union sigval value;

    value.sival_int  = 18;



    if(-1==sigqueue(pid,signum,value)){

        ABORT();

    }

    printf("Have send!
");  

}

 接收程序：

#include <signal.h>

#include <sys/types.h>



#define ABORT() { printf("File:%s,Line:%d",__FILE__,__LINE__);abort();}



void func(int signum,struct  siginfo *info,void *tmp);



int main(int argc,char *argv[]){



    struct sigaction act;

    

    int signum = atoi(argv[1]);



    act.sa_sigaction=func;

    act.sa_flags = SA_SIGINFO;



    if(-1==sigaction(signum,&act,NULL)){

        ABORT();

    }

    while(1){

        printf("wait the signal!
");

    }

    return 0;

}



void func(int signum, struct siginfo *info,void *tmp){

    printf("the value is %d 
",info->si_int);

    sleep(2);

}

 

 

main()
  8 {
  9     sigset_t new_mask,old_mask,pending_mask;
 10     struct sigaction act;
 11     sigemptyset(&act.sa_mask);
 12     act.sa_flags=SA_SIGINFO;
 13     act.sa_sigaction=(void*)my_op;
 14 
 15     if(sigaction(SIGRTMIN+10,&act,NULL))
 16         printf("install signal SIGRTMIN+10 error ");
 17 
 18     if(sigprocmask(SIG_BLOCK, &new_mask,&old_mask))
 19         printf("block signal SIGRTMIN+10 error ");
 20 
 21     sleep(10);
 22     printf("now begin to get pending mask and unblock SIGRTMIN+10 ");
 23 
 24     if(sigpending(&pending_mask)<0)
 25         printf("get pending mask error ");
 26 
 27     if(sigismember(&pending_mask,SIGRTMIN+10))
 28         printf("signal SIGRTMIN+10 is pending ");                                                                                                 
 29 
 30     if(sigprocmask(SIG_SETMASK,&old_mask,NULL)<0)
 31         printf("unblock signal error ");
 32 
 33     printf("signal unblocked ");
 34     sleep(10);
 35 }
 36 static void my_op(int signum)
 37 {
 38         printf("receive signal %d  ",signum);
 39 }