linux 信号-阿里云开发者社区

信号：消息，通知进程系统中发生了某种类型的事件，每种类型的信号对应某种系统事件。

信号是进程间通信的一种异步通信机制。在进程运行过程中，经常会产生一些事件，这些事件的产生和进程的执行往往是异步的，信号提供了一种在软件层面上的异步处理事件的机制。在硬件层面上的异步处理机制是中断，信号是中断的软件模拟。

每个信号用一个整型常量宏表示，以 SIG开头，在头文件<signal.h>中定义

# 查看信号列表
 kill -l 
 man 7 signal

1、信号的实现机制

发送信号到目的进程是由发送信号和接收信号两个步骤组成。

发送信号：内核通过更新目的进程上下文中的某个状态，发送一个信号给目的进程。
接收信号：目的进程被内核强迫以某种方式对信号的发送做出反应。

待处理信号（pending signal）：一个发出而没有接收的信号，又称为挂起信号或未决信号。

在任何时候，一种类型的信号至多只会有一个待处理信号。也就是说，如果一个进程有一个类型为 k 的待处理信号，那么任何接下来发送到这个进程的类型为 k 的信号都不会排队等待，它们只是被简单丢弃。一个进程可以选择性地阻塞接收某种信号，当一种信号被阻塞，它仍可以被发送，但是产生的待处理信号不会被接收，直到进程取消对这种信号的阻塞。

一个待处理信号最多只能被接收一次。内核为每个进程，在位图 pending 中维护着待处理信号的结合，在位图 blocked 集合（信号屏蔽字）中维护着被阻塞的信号集合。只要发送了一个类型为 k 的信号，内核就会设置 pending中的第 k 位，只要接收了一个类型为 k 的信号，内核就会清楚 pending中的第 k 位。

2、发送信号

2.1、发送信号的原因

内核检测到系统事件，例除零错误等
进程调用 kill 函数

2.2、发送信号的机制

unix 系统提供了大量向进程发送信号的机制，这些机制都是基于进程组的。每个进程拥有自己的 pid，每个进程属于一个进程组 pgid。

硬件来源：键盘。硬件触发中断，操作系统切换到内核态执行中断处理程序，中断处理程序发送信号，进程接收信号并处理。

ctrl + c: SIGINT，表示终止该进程
 ctrl + z: SIGTSTP，表示挂起该进程

软件来源：/bin/kill 程序，kill 函数，定时器函数。

kill 函数

进程通过 kill 函数发送信号给其他进程（包括自己）。

/*
 返回值：成功返回 0，失败返回 -1
 参数
 - pid: pid > 0，发送 sig 信号给进程 pid
        pid = 0, 发送 sig 信号给调用进程所在进程组中的每个进程（包括调用进程自己）
        pid < 0，发送 sig 信号给进程组 |pid| 中的每个进程
 - sig: 信号类型
 */
 int kill(pid_t pid, int sig);

3、接收信号

进程接收到信号，有三种处理方法：

默认处理：signal(SIGINT,SIG_DFL)
- Term：终止当前进程
- Ign：忽略该信号
- Core：终止当前进程，并且产生core dump
- Stop：停止（挂起）一个进程
- Cont：使当前停止的进程，继续运行
忽略信号：signal(SIGSEGV,SIG_IGN)
捕捉信号：自定义信号处理函数。用户自定义信号处理函数的目的就是实现进程的有序退出。

自定义信号处理函数设置原则

程序尽可能简单。例：处理程序简单设置全局标志并返回，所有与接收信号相关的处理由主程序执行。
函数内部只调用信号异步安全函数

安全函数：可重入的（例只访问局部变量），不能被信号处理程序中断。

3.1、处理信号

signal 函数

进程可以通过signal函数修改和信号相关联的默认行为。注意：SIGKILL 和 SIGSTOP这两个信号既不能被忽略也不能被捕捉，即进程接收到这两个信号后，只能接受系统的默认处理，即终止进程。

# include <signal.h> 
 // 信号回调函数，信号处理
 typedef void (*sighandler_t)(int);
 /*
 功能：捕获信号
 返回值：成功返回前次处理程序的指针，失败返回 SIG_ERR
 参数：
 - signum：要捕捉的信号值，
 - handler：函数处理函数。SIG_DFL 默认处理; SIG_IGN，忽略信号; 其他，执行信号回调函数
 */ 
 sighandler_t signal(int signum, sighandler_t handler);

sigaction 函数

signal函数处理机制在多信号处理的场景下

收到不同类型的信号：中断当前信号处理，优先处理新的信号，处理完后返回继续处理当前信号。
收到相同类型的信号：执行完当前信号处理，然后只执行新的相同信号一次，重复的信号被忽略。
当前进程阻塞在系统调用上，收到一个信号后，中断系统调用，执行信号处理函数。

不同的系统有不同的信号处理语义，但 signal函数的处理过程是固定的，无法调整。因此，Posix 标准定义了sigaction函数，允许用户自定义这些场景下进程的行为。

/*
 返回值：成功返回0，失败返回-1。
 参数：
 - signum：要捕捉的信号值 
 - act：自定义行为
 - oldact：保存原来信号的回调函数，通常传入空指针
 */
 int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)

其中 sigaction 结构体

struct sigaction {    
     // 联合体，新旧处理函数只有一个可以生效  
     union { 
         // 旧类型的信号处理函数 
         __sighandler_t _sa_handler; 
         // 新类型的信号处理函数，siginfo_t 保存信号的相关信息
         void (*_sa_sigaction)(int, struct siginfo *, void *);
     } _u;
     // 阻塞信号的结合 
     sigset_t sa_mask; 
     // 信号处理的方式，旧类型填 0。其他例如：
     // SA_SIGINFO，选择回调函数 sa_sigaction; 
     unsigned long sa_flags; 
     // 保留不用
     void (*sa_restorer)(void);
 };

3.2、信号阻塞 | 解除

Linux 提供阻塞信号的机制

隐式阻塞机制：内核默认阻塞任何当前处理程序正在处理信号类型的待处理信号。
显式阻塞机制： sigprocmask 函数

sigset_t 信号集合

#include <signal.h> 
 typedef struct { 
     unsigned long int __val[(1024/(8*sizeof(unsigned long int)))]; 
 } __sigset_t; 
 // sigset_t的本质就是一个位图，共有1024位
 typedef __sigset_t sigset_t; 
 // 初始化信号集，清除所有信号 
 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);

sigpending 函数

获取当前待处理信号的集合。通常在回调函数当中使用的，用于检查当前是否阻塞了某个信号

/*
 返回值：成功返回0，失败返回-1
 参数 set: 要检测的信号
 */
 int sigpending(sigset_t *set);

sigprocmask 函数

改变当前阻塞的信号集合（位图 blocked）

/*
 返回值：成功返回0， 失败返回-1
 参数
 - how:
     SIG_BLOCK: 把集合 set 中的信号加入到阻塞集合 blocked 当中 (blocked |= set)
     SIG_UNBLOCK: 把集合 set 从阻塞集合 blocked 中删除 (blocked = blocked & ~set)
     SIG_SETMASK: 把集合 set 替换阻塞集合 blocked (blocked = set)
 - set：阻塞集合
 - 参数3：原有的集合
 */
 int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

sigsuspend 函数

使用 sigprocmask 函数可以实现信号保护临界区。在临界区执行代码的时候，此时产生的信号将会被阻塞，临界区结束的位置只需要再使用 sigprocmask 即可。pause 系统调用可以唤醒一个阻塞进程，直到被一个信号唤醒。若采用 pause 函数捕捉临界区的信号，信号解除阻塞后，立即执行信号处理函数，无法捕捉信号。

为了捕捉临界区的信号，将解除阻塞和等待信号合并成一个原子操作，就是sigsuspend函数

int sigsuspend(const sigset_t *mask);

4、定时器

4.1、睡眠函数

sleep 函数

#include <unistd.h>
 // 休眠 sec 秒
 unsigned int sleep(unsigned int seconds);
 // 休眠 usec 秒
 int usleep(useconds_t usec);

pause 函数

阻塞一个进程，直到某个信号被递送时，进程会解除阻塞，然后终止进程或者执行信号处理函数

int pause(void);

alarm 函数

进程调用 alarm 函数向它自己发送 SIGALRM信号。

/*
 返回值：前一次闹钟剩余的秒数，若以前没有设定闹钟，则为 0
 参数：seconds: 闹钟的时间间隔
 */
 unsigned int alarm(unsigned int seconds);

alarm 函数安排内核在 secs 秒后发送一个 SIGALRM 信号给调用进程。在任何情况下，对 alarm 的调用都将取消任何待处理的闹钟，并且返回待处理的闹钟在被发送前还剩下的秒数，若没有代理处理的闹钟，返回 0。

4.2、定时器

setitimer 函数

setitimer 系统调用负责调整间隔定时器。间隔定时器在创建的时候，就会设置一个时间间隔，定时器到达时间间隔时，调用进程会产生一个信号，随后定时器被重置。

定时器的分类

真实计时器：程序实际运行的时间（时钟时间），时间到发送 SIGALARM信号
虚拟计时器：程序在用户态模式下的 CPU 时间，时间到发送SIGVTALARM信号，
实用计时器：程序在用户态和内核态所占用的 CPU 时间，时间到发送 SIGPROF信号

使用 fork 的时候子进程不会继承父进程的定时器，使用 exec 时候，定时器不会销毁。

/*
 返回值：成功返回0，失败返回-1.
 参数：
 - which：设置定时器的种类：真实计时器 SIGALARM、虚拟计时器 SIGVTALARM、实用计时器 SIGPROF
 - new_value：定时器的初始时间  
 - old_value: 定时器的间隔时间    
 */
 int getitimer(int which, struct itimerval *curr_value)
 int setitimer(int which, const struct itimerval *new_value, struct itimerval *old_value) 
 struct itimerval { 
     struct timeval it_interval; // 时间间隔 
     struct timeval it_value;    // 初始时间
 }; 
 struct timeval {
     time_t tv_sec;       // 秒 
     suseconds_t tv_usec; // 微秒
 };

例：使用真实计时器，实用计时器，统计程序执行时间，在实用计时器及虚拟计时器设定计时后，先睡眠，再让程序处于while(1)

#include <func.h>
 void sigFunc(int sigNum) {
     time_t now;
     time(&now);
     printf("now time = %s\n", ctime(&now));
 }
 int main(int argc,char*argv[]) {
     //真实计时器，信号SIGALRM
     signal(SIGALRM, sigFunc);
     struct itimerval  Time;
     memset(&Time, 0, sizeof(Time));
     Time.it_value.tv_sec = 1;    // 1s后启动
     Time.it_interval.tv_sec = 2; // 间隔2s
     time_t now;
     time(&now);
     printf("now time = %s", ctime(&now));
     // ITIMER_REAL
     setitimer(ITIMER_REAL, &Time, NULL);
     // ITIMER_PROF
     // setitimer(ITIMER_PROF, &Time, NULL);
     printf("before sleep\n");
     sleep(3);
     printf("after sleep\n");
     while(1);
     return 0;
 }

5、例：四窗口聊天

在四个终端上分别启动A、A1、B、B1四个进程。

A 和 B 负责通信，A1和B1负责显示信息。
A 和 B 使用有名管道进行通信
A 和 A1 进程通信采用共享内存（信号量同步），B 和 B1 进程通信采用消息队列
退出方式：ctrl + c 和 kill 命令，任意进程收到信号后，给所有进程发送 10 号信号，有序退出。有序退出要做的主要有：关闭管道，解除对共享内存的映射，删除共享内存，删除信号量，删除消息队列。

showA

#include <head.h>
 // 保存各个进程的pid
 typedef struct pidnums{
     int pidWriteA;
     int pidWriteB;
     int pidShowA;
     int pidShowB;
 } pidNums_t, *pPidNums_t;
 typedef struct package{
     int flag;
     char buf[64];
 }Package_t, *pPackage_t;
 pPidNums_t pidsets; 
 pPackage_t p;
 // 2 信号处理函数
 void sigFunc2(int signum,siginfo_t *p,void *p1){
     printf("%d is coming\n",signum);
     kill(pidsets->pidWriteA, 10);
     kill(pidsets->pidWriteB, 10);
     kill(pidsets->pidShowB, 10);
     kill(pidsets->pidShowA, 10);
 }
 // 10 信号处理函数：
 void sigFunc10(int signum, siginfo_t *p, void *p1){
     printf("%d is coming\n", signum);
     shmdt(pidsets);
     shmdt(p);
     exit(0);
 }
 int main(int argc, char *argv[]) {
     // 2 号信号
     struct sigaction act2;
     bzero(&act2, sizeof(act2));
     act2.sa_flags = SA_SIGINFO;
     act2.sa_sigaction = sigFunc2;
     int ret = sigaction(SIGINT, &act2, NULL);
     ERROR_CHECK(ret, -1, "sigaction 2");
     // 10 号信号
     struct sigaction act10;
     bzero(&act10, sizeof(act10));
     act10.sa_flags = SA_SIGINFO;
     act10.sa_sigaction = sigFunc10;
     ret = sigaction(10, &act10, NULL);
     ERROR_CHECK(ret, -1, "sigaction 10");
     // 创建共享内存
     int shmid = shmget(1000, 1024, IPC_CREAT|0600);
     ERROR_CHECK(shmid,-1,"shmget");
     // 映射地址空间
     p = (pPackage_t)shmat(shmid,NULL,0);
     ERROR_CHECK(p, (pPackage_t)-1, "shmat");
     int semArrId = semget(1000, 1, IPC_CREAT|0600);
     ERROR_CHECK(semArrId, -1, "semget");
     ret = semctl(semArrId, 0, SETVAL, 1);
     ERROR_CHECK(ret, -1, "semctl");
     struct sembuf sopp, sopv;
     sopp.sem_num = 0;
     sopp.sem_op = -1;
     sopp.sem_flg = SEM_UNDO;
     sopv.sem_num = 0;
     sopv.sem_op = 1;
     sopv.sem_flg = SEM_UNDO;
     int pid = getpid();
     int shmidPid = shmget(2000, 4096, IPC_CREAT|0600);
     ERROR_CHECK(shmidPid,- 1, "pid shmget");
     pidsets = (pPidNums_t)shmat(shmidPid, NULL, 0);
     ERROR_CHECK(pidsets, (pPidNums_t) - 1, "pid shmat");
     pidsets->pidShowA = pid;
     while(1){
         semop(semArrId, &sopp, 1);
         if(p->flag == 1){
             puts(p->buf);
             printf("\n");
             memset(p->buf, 0, sizeof(p->buf));
             p->flag = 0;
         }
         if(p->flag == 2){
             printf("%*s%s\n", 10, "", p->buf);
             memset(p->buf, 0, sizeof(p->buf));
             p->flag = 0;
         }
         semop(semArrId, &sopv, 1);
     }
     return 0;
 }

write A

#include <head.h>
 typedef struct package{
     int flag;
     char buf[64];
 }Package_t, *pPackage_t;
 typedef struct pidnums{
     int pidWriteA;
     int pidWriteB;
     int pidShowA;
     int pidShowB;
 } pidNums_t, *pPidNums_t;
 pPidNums_t pidsets; 
 int fdr = 0,fdw = 0;
 int shmid = 0;
 int semArrId = 0;
 int shmidPid = 0;
 pPackage_t p;
 void sigFunc2(int signum,siginfo_t *p,void *p1){
     printf("%d is coming\n",signum);
     kill(pidsets->pidWriteB, 10);
     kill(pidsets->pidShowA, 10);
     kill(pidsets->pidShowB, 10);
     kill(pidsets->pidWriteA, 10);
 }
 void sigFunc10(int signum,siginfo_t *p,void *p1){
     printf("%d is coming\n", signum);
     semctl(semArrId, 0, IPC_RMID);
     shmdt(p);
     shmdt(pidsets);
     shmctl(shmid, IPC_RMID, NULL);
     shmctl(shmidPid, IPC_RMID, NULL);
     close(fdr);
     close(fdw);
     exit(0);
 }
 int main(int argc,char *argv[]) {
     ARGS_CHECK(argc, 3);
     struct sigaction act2;
     bzero(&act2, sizeof(act2));
     act2.sa_flags = SA_SIGINFO;
     act2.sa_sigaction = sigFunc2;
     int ret = sigaction(SIGINT, &act2, NULL);
     ERROR_CHECK(ret, -1, "sigaction 2");
     struct sigaction act10;
     bzero(&act10, sizeof(act10));
     act10.sa_flags = SA_SIGINFO;
     act10.sa_sigaction = sigFunc10;
     ret=sigaction(10, &act10, NULL);
     ERROR_CHECK(ret, -1, "sigaction 10");
     //A和B的读写管道
     fdr=open(argv[1], O_RDONLY);
     ERROR_CHECK(fdr, -1, "open1");
     fdw=open(argv[2], O_WRONLY);
     ERROR_CHECK(fdw, -1, "open2");
     printf("i am chat1, fdr=%d fdw=%d\n",fdr,fdw);
     char buf[128] = {0};
     fd_set rdset;
     // A和showA之间的共享内存
     shmid=shmget(1000, 1024, IPC_CREAT|0600);
     ERROR_CHECK(shmid, -1, "shmget");
     p=(pPackage_t)shmat(shmid, NULL, 0);
     ERROR_CHECK(p, (pPackage_t) - 1, "shmat");
     p->flag = 0;
     // A和showA之间的互斥锁
     semArrId = semget(1000, 1, IPC_CREAT|0600);
     ERROR_CHECK(semArrId, -1, "semget");
     ret=semctl(semArrId, 0, SETVAL, 1);
     ERROR_CHECK(ret, -1, "semctl");
     struct sembuf sopp, sopv;
     sopp.sem_num = 0;
     sopp.sem_op = -1;
     sopp.sem_flg = SEM_UNDO;
     sopv.sem_num = 0;
     sopv.sem_op = 1;
     sopv.sem_flg = SEM_UNDO;
     // pid存储的共享内存
     int pid = getpid();
     shmidPid = shmget(2000, 4096, IPC_CREAT|0600);
     ERROR_CHECK(shmidPid, -1, "pid shmget");
     pidsets=(pPidNums_t)shmat(shmidPid, NULL, 0);
     ERROR_CHECK(pidsets, (pPidNums_t) - 1, "pid shmat");
     pidsets->pidWriteA = pid;
     while(1){
         FD_ZERO(&rdset);
         FD_SET(STDIN_FILENO, &rdset);
         FD_SET(fdr, &rdset);
         ret = select(fdw + 1, &rdset, NULL, NULL, NULL);
         ERROR_CHECK(ret, -1, "select");
         printf("ret = %d\n", ret);
         if(FD_ISSET(STDIN_FILENO,&rdset)){
             memset(buf, 0, sizeof(buf));
             ret=read(STDIN_FILENO, buf, sizeof(buf));
             //        if(0==ret){
             //            printf("主动断开\n");
             //            break;
             //        }
             if(strcmp(buf,"\n")!=0){
                 write(fdw,buf,strlen(buf)-1);
                 ret = semop(semArrId,&sopp,1);
                 ERROR_CHECK(ret, -1, "semop1");
                 p->flag=2;
                 strcpy(p->buf,buf);
                 ret = semop(semArrId,&sopv,1);
                 ERROR_CHECK(ret, -1, "semop2");
             }
         }
         if(FD_ISSET(fdr, &rdset)){
             memset(buf, 0, sizeof(buf));
             ret=read(fdr, buf, sizeof(buf));
             ERROR_CHECK(ret, -1, "read");
             printf("ret = %d\n", ret);
             //        if(0==ret){
             //            printf("连接已断开\n");
             //            break;
             //        }
             ret = semop(semArrId, &sopp, 1);
             ERROR_CHECK(ret, -1, "semop1");
             p->flag = 1;
             strcpy(p->buf, buf);
             ret = semop(semArrId, &sopv, 1);
             ERROR_CHECK(ret, -1, "semop2");
             puts(buf);
         }
     }
     return 0;
 }

showB

#include <head.h>
 typedef struct pidnums{
     int pidWriteA;
     int pidWriteB;
     int pidShowA;
     int pidShowB;
 } pidNums_t,*pPidNums_t;
 typedef struct mymsgbuf{
     long mtype;
     char mtext[64];
 }MSG_t;
 pPidNums_t pidsets;
 void sigFunc2(int signum, siginfo_t *p, void *p1){
     printf("%d is coming\n", signum);
     kill(pidsets->pidWriteA, 10);
     kill(pidsets->pidWriteB, 10);
     kill(pidsets->pidShowA, 10);
     kill(pidsets->pidShowB, 10);
 }
 void sigFunc10(int signum, siginfo_t *p, void *p1){
     printf("%d is coming\n", signum);
     shmdt(pidsets);
     exit(0);
 }
 int main(int argc,char *argv[]) {
     struct sigaction act2;
     bzero(&act2,sizeof(act2));
     act2.sa_flags =S A_SIGINFO;
     act2.sa_sigaction = sigFunc2;
     int ret =s igaction(SIGINT,&act2,NULL);
     ERROR_CHECK(ret, -1, "sigaction 2");
     struct sigaction act10;
     bzero(&act10, sizeof(act10));
     act10.sa_flags = SA_SIGINFO;
     act10.sa_sigaction = sigFunc10;
     ret=sigaction(10, &act10, NULL);
     ERROR_CHECK(ret, -1, "sigaction");
     int msgid=msgget(1000, IPC_CREAT|0600);
     ERROR_CHECK(msgid, -1, "msgget");
     struct mymsgbuf msgInfo;
     int pid = getpid();
     int shmidPid = shmget(2000, 4096, IPC_CREAT|0600);
     ERROR_CHECK(shmidPid, -1, "pid shmget");
     pidsets=(pPidNums_t)shmat(shmidPid, NULL, 0);
     ERROR_CHECK(pidsets, (pPidNums_t) - 1, "pid shmat");
     pidsets->pidShowB = pid;
     while(1){
         bzero(&msgInfo, sizeof(msgInfo));
         ret = msgrcv(msgid, &msgInfo, sizeof(msgInfo), 0, 0);
         ERROR_CHECK(ret, -1, "msgrcv");
         if(msgInfo.mtype == 1){
             printf("%s\n\n", msgInfo.mtext);
         }
         if(msgInfo.mtype == 2){
             printf("%*s%s\n", 10, "", msgInfo.mtext);
         }
     }
     return 0;
 }

wirteB

#include <head.h>
 typedef struct pidnums{
     int pidWriteA;
     int pidWriteB;
     int pidShowA;
     int pidShowB;
 }pidNums_t, *pPidNums_t;
 pPidNums_t pidsets; 
 int fdr,fdw;
 int msgid;
 typedef struct mymsgbuf{
     long mtype;
     char mtext[64];
 } Msg_t,*pMsg_t;
 void sigFunc2(int signum, siginfo_t *p, void *p1){
     printf("%d is coming\n", signum);
     kill(pidsets->pidWriteA, 10);
     kill(pidsets->pidShowA, 10);
     kill(pidsets->pidShowB, 10);
     kill(pidsets->pidWriteB, 10);
 }
 void sigFunc10(int signum, siginfo_t *p, void *p1){
     printf("%d is coming\n", signum);
     close(fdr);
     close(fdw);
     shmdt(pidsets);
     msgctl(msgid, IPC_RMID,NULL);
     exit(0);
 }
 int main(int argc,char *argv[]) {
     ARGS_CHECK(argc, 3);
     struct sigaction act2;
     bzero(&act2, sizeof(act2));
     act2.sa_flags = SA_SIGINFO;
     act2.sa_sigaction =s igFunc2;
     int ret=sigaction(SIGINT, &act2, NULL);
     ERROR_CHECK(ret, -1, "sigaction 2");
     struct sigaction act10;
     bzero(&act10, sizeof(act10));
     act10.sa_flags =S A_SIGINFO;
     act10.sa_sigactio n= sigFunc10;
     ret=sigaction(10, &act10, NULL);
     ERROR_CHECK(ret, -1, "sigaction");
     fdw = open(argv[1], O_WRONLY);
     fdr = open(argv[2], O_RDONLY);
     printf("i am chat2 , fdr=%d fdw=%d\n", fdr, fdw);
     // B 和 showB 的消息队列
     char buf[128] = {0};
     fd_set rdset;
     msgid = msgget(1000, IPC_CREAT|0600);
     ERROR_CHECK(ret, -1, "msgget");
     struct mymsgbuf msgInfo;
     // pid 共享内存
     int pid = getpid();
     int shmidPid = shmget(2000, 4096, IPC_CREAT|0600);
     ERROR_CHECK(shmidPid, -1, "pid shmget");
     pidsets = (pPidNums_t)shmat(shmidPid, NULL, 0);
     ERROR_CHECK(pidsets, (pPidNums_t) - 1, "pid shmat");
     pidsets->pidWriteB = pid;
     while(1){
         FD_ZERO(&rdset);
         FD_SET(STDIN_FILENO, &rdset);
         FD_SET(fdr, &rdset);
         ret=select(fdr + 1, &rdset, NULL, NULL, NULL);
         ERROR_CHECK(ret, -1, "select");
         if(FD_ISSET(STDIN_FILENO, &rdset)){
             memset(buf, 0, sizeof(buf));
             ret = read(STDIN_FILENO, buf, sizeof(buf));
             //     if(0==ret){
             //         printf("主动断开\n");
             //         break;
             //     }
             if(strcmp(buf, "\n") != 0){
                 write(fdw,buf,strlen(buf) - 1);
                 msgInfo.mtype = 2;
                 strcpy(msgInfo.mtext, buf);
                 ret = msgsnd(msgid, &msgInfo, strlen(msgInfo.mtext), 0);
                 ERROR_CHECK(ret,-1,"msgsnd");
             }
         }
         if(FD_ISSET(fdr, &rdset)){
             memset(buf, 0, sizeof(buf));
             ret=read(fdr, buf, sizeof(buf));
             ERROR_CHECK(ret, -1, "read");
             //     if(0==ret){
             //         printf("连接已断开\n");
             //         break;
             //     }
             if(strlen(buf) != 0){
                 puts(buf);
                 msgInfo.mtype = 1;
                 strcpy(msgInfo.mtext, buf);
                 ret = msgsnd(msgid, &msgInfo, strlen(msgInfo.mtext), 0);
                 ERROR_CHECK(ret, -1, "msgsnd");
             }
         }
     }
     close(fdr);
     close(fdw);
     return 0;
 }

linux 信号