Linux学习总结（十四）IPC方法-信号

系统中的信号

使用kill -l命令产看当前系统中可使用的信号：

每个进程都可以收到上面这些信号，这些信号都是由内核负责返送，内核负责处理。
特别强调，9号和19号信号不允许忽略和捕捉和阻塞，只能执行默认动作

信号的产生和处理

产生信号：
1.按键产生:
Ctrl + c → 2) SIGINT（终止/中断） “INT” ----Interrupt
Ctrl + z → 20) SIGTSTP（暂停/停止） “T” ----Terminal 终端。
Ctrl + \ → 3) SIGQUIT（退出）
2.系统调用产生，如：kill、raise、abort
3.软件条件产生，如：定时器alarm
4.硬件异常产生:
除0操作 → 8) SIGFPE (浮点数例外) “F” -----float 浮点数。
非法访问内存 → 11) SIGSEGV (段错误)
总线错误 → 7) SIGBUS

未决：产生和递达之间的状态，主要由于阻塞(屏蔽)导致该状态
信号处理方式：

• 执行默认动作

Term：终止进程
Ign：忽略信号(默认即对该种信号忽略操作)
Core：终止进程，生成Core文件。(检验进程死亡原因，用于gdb调试)
Stop：停止(暂停)进程
Cont：继续运行进程

• 忽略(丢弃)
• 捕捉(调用用户处理函数)

阻塞信号集(信号屏蔽字)：将某些信号加入集合，对他们设置屏蔽，当屏蔽X信号后，再收到该信号，该信号的处理将推后。
未决信号集：

• 信号产生，未决信号集中描述该信号的位立刻翻转为1，表示信号处于未决状态，当信号被处理对应位翻转为0，这一时刻往往非常短暂。
• 信号产生后由于某些原因(主要时阻塞)不能抵达，这类信号的集合称之为未决信号集，在解除屏蔽前，信号一直处于未决状态，也就是1。

kill函数

kill命令产生信号：kill -SIGKILL pid
kill函数：给指定进程发送指定信号

int kill(pid_t pid, int sig); 成功返回0，失败返回-1，sig不推荐直接使用数字，应该使用宏名，因为不同操作系统信号编号可能不同，但是名称是一样的。
pid > 0：发送信号给指定进程
pid = 0：发送信号给与调用kill函数进程属于同一进程组的所有进程
pid < 0：取|pid|发给对应进程组
pid = -1：发送给进程有权限发送的系统中所有进程。

进程组：每个进程都属于一个进程组，进程组是一个或多个进程集合，他们相互关联，共同完成一个实体任务，每个进程组都有一个进程组长，默认进程组ID与进程组长ID相同。
权限保护：super用户(root)可以发送信号给任意用户，普通用户是不能向系统用户发送信号的，kill -9 root用户的pid 是不可以的，同样，普通用户也不能向其他普通用户发送信号，终止其进程，只能向自己创建的进程发送信号。普通用户基本规则是：发送者实际或有效用户ID == 接收者实际或有效用户ID。
练习：循环创建5个子进程，父进程终止第三个子进程。

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <signal.h>

#define N 5
int main(void)
{
    int i;
    pid_t pid, q;
    for (i = 0; i < N; i++) {
        pid = fork();
        if (pid == 0)
            break;
        if (i == 2)
            q = pid;
    }
    if (i < 5) {
        while(1) {
            printf("I'm child %d, getpid = %u\n", i, getpid());
            sleep(1);
        }

    } else {
        sleep(1);
        kill(q, SIGKILL);
        while (1);
    }

    return 0;
}

raise和abort函数

raise函数：给当前进程发送指定信号(自己给自己发)

raise(signo) == kill(getpid(), signo);
int raise(int sig); 成功返回0，失败非0值

abort函数：给自己发送异常终止信号6)SIGABRT信号，终止并产生core文件

void abort(void); 该函数没有返回值

alarm和setitimer函数

alarm函数

设置定时器(闹钟)，在指定seconds后，内核会给当前进程发送14)SIGALRM信号。进程收到该信号，默认动作终止。
每个进程都有且只有唯一一个定时器

unsigned int alarm(unsigned int seconds); 返回0或者剩余的秒数，无失败
常用：取消定时器alarm(0)，返回旧闹钟余下秒数。

练习：编写程序，测试你使用的计算机1秒钟能数多少个数。

#include <stdio.h>
#include <unistd.h>

int main(void)
{
	int i;
	alarm(1);

	for(i = 0; ; i++)
		printf("%d\n", i);

	return 0;
}

setitmer函数

设置定时器(闹钟)，可替代alarm函数，精确到微秒，还可以实现周期定时。

int setitimer(int which, const struct itimerval *new_value, struct itimer *old_value);
成功返回0，失败返回-1，设置errno;

参数which：指定定时方式

• 自然定时：ITIMER_REAL →14)SIGLARM 计算自然时间
• 虚拟空间计时(用户空间)：ITIMER_VIRTUAL→26)SIGVTALRM 只计算进程占用cpu的时间
• 运行时计时(用户+内核)：ITIMER_PROF→27)SIGPROF 计算占用cpu及执行系统调用的时间

练习：使用seitimer函数实现alarm函数，重复计算机1秒数多少个数

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
/*
 * struct itimerval  {
        struct timeval{
            it_value.tv_sec;
            it_value.tv_usec;
        } it_interval;

        struct timeval {
            it_value.tv_sec;
            it_value.tv_usec;
        } it_value;

    } it, oldit;
*/
unsigned int my_alarm(unsigned int sec)
{
	struct itimerval it, oldit;
    int ret;

	it.it_value.tv_sec = sec;
	it.it_value.tv_usec = 0;
	it.it_interval.tv_sec = 0;
	it.it_interval.tv_usec = 0;

	ret = setitimer(ITIMER_REAL, &it, &oldit);
    if (ret == -1) {
        perror("setitimer");
        exit(1);
    }
	return oldit.it_value.tv_sec;
}

int main(void)
{
	int i;
	my_alarm(1);  //alarm(sec);

	for(i = 0; ; i++)
		printf("%d\n", i);

	return 0;
}

信号集操作函数

内核通过读取未决信号集来判断信号是否应被处理，信号屏蔽字mask可以影响未决信号集，而我们可以在应用程序中自定义set来改变mask，来达到屏蔽指定信号的目的。

sigset_t set; //typedef unsigned long sigset_t
int sigemptyset(sigset_t *set);         将某个信号集清0
int sigfillset(sigset_t *set);            将某个信号集置1
int sigaddset(sigset_t *set, int signum);      将某个信号加入信号集
int sigdellset(sigset_t *set, int signum);      将某个信号清出信号集
int sigismemeber(const sigset_t *set, int signum);  判断某个信号是否在信号集中
上面这几个信号集操作函数都是成功返回0，失败返回-1

sigset_t类型的本质是位图，但不应该直接使用位操作，而应该使用上述函数，保证跨系统操作有效。

sigprocmask函数

用来屏蔽信号，解除屏蔽也使用该函数，其本质是读取或修改进程的信号屏蔽字(PCB中)，严格注意，屏蔽信号只是将信号处理延后执行(延至解除屏蔽)，而忽略表示将信号丢处理。

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);成功返回0，失败返回-1
参数：
set：传入参数，是一个位图，set中哪个位置为1，就表示当前进程屏蔽哪个信号。
oldset：传出参数，保存旧的信号屏蔽集。
how参数取值，假设当前的信号屏蔽字为mask
  1.SIG_BLOCK：当how设置为此值，set表示需要屏蔽的信号，相当于mask=mask|set
  2.SIG_UNBLOCK：当how设置为此值，set表示需要解除屏蔽的信号，相当于mask=mask& ~set
  3.SIG_SETMASK：当how设置为此值，set表示用于替代原始屏蔽集的新屏蔽集，相当于mask=set

sigpending函数

读取当前进程的未决信号集
int sigpending(sigset_t *set);
set表示传出参数，成功返回0，失败返回-1，设置errno
练习：编写程序，把所有常规信号的未决状态打印至屏幕。

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

void printset(sigset_t *ped)
{
	int i;
	for(i = 1; i < 32; i++){
		if((sigismember(ped, i) == 1)){
			putchar('1');
		} else {
			putchar('0');
		}
	}
	printf("\n");
}

int main(void)
{
	sigset_t ped;
	while(1){
		sigpending(&ped);       //获取未决信号集
		printset(&ped);
		sleep(1);
	}
	return 0;
}

信号捕捉

singal函数

注册一个信号捕捉函数：
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);
该函数由ANSI定义，由于历史原因在不同版本的Unix和不同版本的Linux中可能有不同的行为，因此应该尽量避免使用它，取而代之使用sigaction函数。
void (*signal(int signum, void(*sighandler_t)(int)))(int);

#include <signal.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
typedef void (*sighandler_t) (int);
void catchsigint(int signo)
{
    printf("-----------------catch\n");
}

int main(void)
{
    sighandler_t handler;

    handler = signal(SIGINT, catchsigint);
    if (handler == SIG_ERR) {
        perror("signal error");
        exit(1);
    }

    while (1);
    return 0;
}

sigaction函数

修改信号处理动作(通常在Linux中用来注册一个信号的捕捉函数)
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
成功返回0失败返回-1，设置errno
参数：
 act：传入参数，新的处理方式
 oldset：传出参数，旧的处理方式
 struct sigaction结构体：

struct sigaction {
        void     (*sa_handler)(int);
        void     (*sa_sigaction)(int, siginfo_t *, void *);
        sigset_t   sa_mask; 
        int       sa_flags; 
        void     (*sa_restorer)(void);
    };
 sa_restorer:该元素是过时的，不应该使用，POSIX.1标准将不指定该元素，已弃用
 sa_sigaction:当sa_flags被指定为SA_SIGINFO标志时，使用该信号处理程序，很少使用。
 重点掌握：
 sa_handler:指定信号捕捉后的处理函数名(即注册函数)，也可赋值为SIG_IGN表示忽略，或者SIG_DFL表示执行默认动作。
 sa_mask:调用信号处理函数时，所要屏蔽的信号集合(信号屏蔽字),仅在处理函数被调用期间屏蔽生效，是临时设置。
 sa_flags:通常设置为0，表示使用默认属性。

信号捕捉特性

1.进程正常运行时，默认PCB中有一个信号屏蔽字，假设为mask，它决定了进程自动屏蔽哪些信号，当注册了某个信号捕捉函数，捕捉到该信号以后，要调用捕捉函数，而捕捉函数有可能执行很长时间，在这期间所屏蔽的信号不由mask来指定，而是用sa_mask来指定，当调用完信号捕捉函数后，再恢复为mask。如果在捕捉函数执行期间，收到的信号没有被屏蔽，则立即跳出该捕捉函数去处理没有被屏蔽的信号。
2.XXX信号捕捉函数执行期间，XXX信号自动被屏蔽。
3.阻塞的常规信号不支持排队，产生多次只记录一次，后32个实时信号支持排队。
练习：为某个信号设置捕捉函数

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

/*自定义的信号捕捉函数*/
void sig_int(int signo)
{
	printf("catch signal SIGINT\n");//单次打印
    sleep(10);
    printf("----slept 10 s\n");
}

int main(void)
{
	struct sigaction act;		

	act.sa_handler = sig_int;
	act.sa_flags = 0;
	sigemptyset(&act.sa_mask);		//不屏蔽任何信号
    sigaddset(&act.sa_mask, SIGQUIT);

	sigaction(SIGINT, &act, NULL);

    printf("------------main slept 10\n");
    sleep(10);

	while(1);//该循环只是为了保证有足够的时间来测试函数特性

	return 0;
}

练习：验证在信号处理函数执行期间，该信号多次递送，那么只在处理函数执行结束之后，处理一次

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

/*自定义的信号捕捉函数*/
void sig_int(int signo)
{
	printf("catch signal SIGINT\n");//单次打印
    sleep(10);
    printf("----slept 10 s\n");
}

int main(void)
{
	struct sigaction act;		

	act.sa_handler = sig_int;
	act.sa_flags = 0;
	sigemptyset(&act.sa_mask);		//不屏蔽任何信号
    sigaddset(&act.sa_mask, SIGQUIT);

	sigaction(SIGINT, &act, NULL);

    printf("------------main slept 10\n");
    sleep(10);

	while(1);//该循环只是为了保证有足够的时间来测试函数特性

	return 0;
}

练习：验证sa_mask在捕捉函数执行期间的屏蔽作用

/*当执行SIGINT信号处理函数期间
 *多次收到SIGQUIT信号都将被屏蔽(阻塞)
 *SIGINT信号处理函数处理完，立刻解除对
 *SIGQUIT信号的屏蔽，由于没有捕捉该信号，
 *将立刻执行该信号的默认动作，程序退出
 */
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void sig_int(int signo)
{
	printf("catch signal SIGINT\n");
	sleep(10);			//模拟信号处理函数执行很长时间
	printf("end of handler\n");
}

int main(void)
{
	struct sigaction act;		


	act.sa_handler = sig_int;
	sigemptyset(&act.sa_mask);		
	sigaddset(&act.sa_mask, SIGQUIT);	

	/*将SIGQUIT加入信号屏蔽集,这就导致,在调用信号处理函数期间
	 *不仅不响应SIGINT信号本身,还不响应SIGQUIT*/
	act.sa_flags = 0;

	sigaction(SIGINT, &act, NULL);		//注册信号SIGINT捕捉函数

	while(1);

	return 0;
}

内核实现信号捕捉过程

竞态条件(时序竞态)

pause函数

调用该函数可以造成进程主动挂起，等待信号唤醒，调用该系统调用的进程将处于阻塞状态(主动放弃cpu)直到有信号递达将其唤醒。

int pause(void);
返回值：
1.如果信号的默认处理动作是终止进程，则进程终止，pause函数没有机会返回。
2.如果信号的默认处理动作是忽略，则进程继续处于挂起状态，pause函数不返回。
3.如果信号的处理动作是捕捉，则调用完信号处理函数之后，pause返回-1，errno设置未EINTR，表示“被信号中断”。
4.pause收到的信号不能被屏蔽，如果被屏蔽，那么pause就不能被唤醒。

练习：使用pause和alarm来实现sleep函数。

#include <unistd.h>
#include <signal.h>
#include <stdio.h>

void sig_alrm(int signo)
{
    /* nothing to do */
}

unsigned int mysleep(unsigned int nsecs)
{
    struct sigaction newact, oldact;
    unsigned int unslept;

    newact.sa_handler = sig_alrm;
    sigemptyset(&newact.sa_mask);
    newact.sa_flags = 0;
    sigaction(SIGALRM, &newact, &oldact);

    alarm(nsecs); 
    pause();

	//取消闹铃，将SIGALRM信号处理还原
    unslept = alarm(0);
    sigaction(SIGALRM, &oldact, NULL);

    return unslept;
}

int main(void)
{
    while(1){
        mysleep(2);
        printf("Two seconds passed\n");
    }

    return 0;
}

注意alarm(0)的用法：
例如：睡觉，alarm(10)闹铃
 正常：10秒后闹钟将我唤醒，这时额外设置alarm(0)取消闹铃，不会出错。
 异常：5秒后，被其他事物吵醒，alarm(0)取消闹铃防止打扰。

时序竞态问题(sigsuspend函数)

回看pause和alarm实现的mysleep函数，设想如下时序：

1.注册SIGALRM信号处理函数
2.调用ararm(2)设定闹钟
3.函数调用刚结束，开始倒计时2秒，当前进程失去cpu，内核调度优先级高的进程(有多个)取代当前进程，当前进程无法获得cpu，进入就绪态等待cpu。
4.经过2秒后，闹钟超时，内核向当前进程发送SIGALRM信号(自然定时法，与进程状态无关)，高优先级进程尚未执行完，当前进程仍处于就绪状态，信号无法处理(未决)。
5.优先级高的进程执行完，当前进程获得cpu资源，内核调度回当前进程执行，SIGALRM信号递达，信号设置捕捉，执行处理函数sig_alrm.
6.信号处理函数执行结束，返回当前进程主控流程，pause()被调用挂起等待(欲等待alarm函数发送的SIGALRM信号将自己唤醒)。
7.SIGALRM信号已经处理完毕，pause不会等到。

  想要解决上面的时序问题，可以通过设置屏蔽SIGALRM的方法来控制程序执行逻辑，但无论如何设置，程序都有可能在解除信号屏蔽与挂起等待信号这两个操作间隙失去cpu资源，除非将这两个步骤合并成一个原子操作。sigsuspend函数具备这个功能，在对时序要求严格的场合下都应该使用sigsuspend替换pause。
  int sigsuspend(const sigset_t *mask); 挂起等待信号。
  sigsuspend函数调用期间，进程信号屏蔽字由其参数mask指定。
  可将某个信号(如SIGALRM)从临时信号屏蔽字mask中删除，这样在调用sigsuspend时将解除对该信号的屏蔽，然后挂起等待，当sigsuspend返回时，进程的信号屏蔽字恢复为原来的值，如果原来对该信号是屏蔽态，sigsuspend函数返回后仍然屏蔽该信号。

#include <unistd.h>
#include <signal.h>
#include <stdio.h>

void sig_alrm(int signo)
{
    /* nothing to do */
}

unsigned int mysleep(unsigned int nsecs)
{
    struct sigaction newact, oldact;
    sigset_t newmask, oldmask, suspmask;
    unsigned int unslept;

    //1.为SIGALRM设置捕捉函数，一个空函数
    newact.sa_handler = sig_alrm;
    sigemptyset(&newact.sa_mask);
    newact.sa_flags = 0;
    sigaction(SIGALRM, &newact, &oldact);

    //2.设置阻塞信号集，阻塞SIGALRM信号
    sigemptyset(&newmask);
    sigaddset(&newmask, SIGALRM);
    sigprocmask(SIG_BLOCK, &newmask, &oldmask);   //信号屏蔽字 mask

    //3.定时n秒，到时后可以产生SIGALRM信号
    alarm(nsecs);

    /*4.构造一个调用sigsuspend临时有效的阻塞信号集，
     *  在临时阻塞信号集里解除SIGALRM的阻塞*/
    suspmask = oldmask;
    sigdelset(&suspmask, SIGALRM);

    /*5.sigsuspend调用期间，采用临时阻塞信号集suspmask替换原有阻塞信号集
     *  这个信号集中不包含SIGALRM信号,同时挂起等待，
     *  当sigsuspend被信号唤醒返回时，恢复原有的阻塞信号集*/
    sigsuspend(&suspmask); 

    unslept = alarm(0);
    //6.恢复SIGALRM原有的处理动作，呼应前面注释1
    sigaction(SIGALRM, &oldact, NULL);

    //7.解除对SIGALRM的阻塞，呼应前面注释2
    sigprocmask(SIG_SETMASK, &oldmask, NULL);

    return(unslept);
}

int main(void)
{
    while(1){
        mysleep(2);
        printf("Two seconds passed\n");
    }

    return 0;
}

总结：
  竞态条件，跟系统负载有很密切的关系，体现出信号的不可靠性，系统负载越严重，信号不可靠性越强。
  不可靠由其实现原理所致，信号是通过软件方法实现(跟内核调度高度依赖，延时性强)，每次系统调用结束或中断处理结束后，需要通过扫描PCB中的未决信号集来判断是否应该处理某个信号，当系统负载过重时，会出现时序混乱。
  这种意外情况只能在编写程序过程中，提早预见，主动规避，而无法通过gdb程序调试等其他手段弥补，且由于该错误不具规律性，后期捕捉和重现十分困难。

全局变量异步I/O

分析如下父子进程交替数数程序，重点分析程序中3个sleep函数的作用，如果取消掉用户处理函数中的两个sleep函数会发生什么问题：

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>

int n = 0, flag = 0;

void sys_err(char *str)
{
    perror(str);
    exit(1);
}

void do_sig_child(int num)
{
    printf("I am child  %d\t%d\n", getpid(), n);
    n += 2;
    flag = 1;
    sleep(1);
}

void do_sig_parent(int num)
{
    printf("I am parent %d\t%d\n", getpid(), n);
    n += 2;
    flag = 1;
    sleep(1);
}

int main(void)
{
    pid_t pid;
    struct sigaction act;

    if ((pid = fork()) < 0)
        sys_err("fork");

    else if (pid > 0) {     
        n = 1;
        sleep(1);
        act.sa_handler = do_sig_parent;
        sigemptyset(&act.sa_mask);
        act.sa_flags = 0;
        sigaction(SIGUSR2, &act, NULL);             //注册自己的信号捕捉函数   父使用SIGUSR2信号

        do_sig_parent(0);

        while(1) {
            /* wait for signal */;
           if (flag == 1) {                         //父进程数数完成
                kill(pid, SIGUSR1);
                flag = 0;                           //标志已经给子进程发送完信号
            }
        }

    } else if (pid == 0){       
        n = 2;
        act.sa_handler = do_sig_child;
        sigemptyset(&act.sa_mask);
        act.sa_flags = 0;
        sigaction(SIGUSR1, &act, NULL);

        while(1) {
            /* wait for signal */;
            if (flag == 1) {
                kill(getppid(), SIGUSR2);
                flag = 0;
            }
        }
    }

    return 0;
}

SIGUSR1和SIGUSR2信号。用户自定义信号，程序员可以在程序中定义并使用该信号。默认动作为终止进程。

上述函数的正常执行结果本应该是：父进程数1、3、5、7、······；子进程数2、4、6、8、·······，且它们之间交替数数。

父进程中的第一个sleep函数确保在父进程向子进程发送信号前，子进程已经完成了对信号的注册（因为子进程有可能失去CPU时间太长而未完成对信号的注册），否则会导致子进程收到信号被终结。

在父进程中的全局变量flag在用户处理函数中和主控程序（while循环中）都会被修改（子进程也一样），但是正确的执行顺序必须是：父进程完成数数→用户处理函数置flag为1→父进程发信号→主控程序置flag为0。flag为1确保向进程发送信号，flag为0确保信号只是发送一次，不重复发送。但是，如果其中某一个进程（父进程或子进程）在while循环中刚发送完信号就失去了CPU，还未对flag进行修改，此时另一个进程处理完信号后，再次向该进程发送信号，此时该进程接收到信号不会接着执行flag=0的操作了，会马上去处理信号，信号处理完后，才会回到主控程序执行flag=0的操作，此时显然顺序发生了颠倒，导致最终flag错误置为0。因此，该进程处理完信号后再也不会发送信号了，另一个进程也再也不会收到信号，从而更不会再发信号。两个进程都在while循环中重复判断条件，但是条件永远不满足。因此，用户捕捉函数中的两个sleep函数的作用就是确保，一个进程在向两一个进程发送信号前，另一个进程主控程序中的flag=0的操作已经执行了，确保变量值修改的正确性。

如何解决该问题呢？可以使用后续章节讲到的“锁”机制。当操作全局变量的时候，通过加锁、解锁来解决该问题（互斥访问，进程同步）。

现阶段，我们在编程期间如若使用全局变量，应在主观上注意全局变量的异步IO可能造成的问题。

上述问题虽然可以通过sleep函数来解决，但是sleep函数会导致数数效率太低，可以取消全局变量flag，让发送信号的操作在用户处理函数中完成即可。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
 
int n = 0;
pid_t pid;
 
void sys_err(char *str)
{
    perror(str);
    exit(1);
}
 
void do_sig_child(int num)
{
    printf("I am child  %d\t%d\n", getpid(), n);
    n += 2;
    kill(getppid( ) , SIGUSR2);
}
 
void do_sig_parent(int num)
{
    printf("I am parent %d\t%d\n", getpid(), n);
    n += 2;
    kill(pid , SIGUSR1);
}
 
int main(void)
{
    struct sigaction act;
 
    if ((pid = fork()) < 0)
        sys_err("fork");
 
    else if (pid > 0) {
        n = 1;
        sleep(1);
        act.sa_handler = do_sig_parent;
        sigemptyset(&act.sa_mask);
        act.sa_flags = 0;
        sigaction(SIGUSR2, &act, NULL);            
        do_sig_parent(0);
 
        while(1) {
            ;
        }
    } else if (pid == 0){
        n = 2;
        act.sa_handler = do_sig_child;
        sigemptyset(&act.sa_mask);
        act.sa_flags = 0;
        sigaction(SIGUSR1, &act, NULL);
 
        while(1) {
            ;
        }
      }
 
    return 0;
}

可/不可重入函数

一个函数在被调用执行期间(尚未调用结束)，由于某种时序又被重复调用，称之为重入。根据数实现的方法可分为可重入函数和不可重入函数两种。

显然，insert函数是不可重入函数，会导致意外结果出现，究其原因，是该函数内部实现使用了全局变量。
注意：
1.定义可重入函数，函数内不能含有全局变量及static变量，不能使用malloc和free。
2.信号捕捉函数应设计为可重入函数。
3.信号处理程序可以调用的可重入函数可参阅man 7 signal。
4.没有包含在上述列表中的函数大多是不可重入的，因为：
  a)使用了静态数据结构
  b)调用了malloc或free
  c)是标准I/O函数

SIGCHLD信号

产生条件：
1.子进程终止时
2.子进程收到SIGSTOP信号停止时
3.子进程处在停止态，接收到SIGCONT后唤醒时
可以借助SIGCHLD信号回收子进程
子进程结束时，其父进程会收到SIGCHLD信号，该信号的默认处理动作是忽略，可以捕捉该信号，在捕捉函数中完成子进程状态的回收。

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

void sys_err(char *str)
{
    perror(str);
    exit(1);
}

void do_sig_child(int signo)
{
    int status;
    pid_t pid;

//    if ((pid = waitpid(0, &status, WNOHANG)) > 0) {
    while ((pid = waitpid(0, &status, WNOHANG)) > 0) {
        if (WIFEXITED(status))
            printf("------------child %d exit %d\n", pid, WEXITSTATUS(status));
        else if (WIFSIGNALED(status))
            printf("child %d cancel signal %d\n", pid, WTERMSIG(status));
    }
}

int main(void)
{
    pid_t pid;
    int i;
    //阻塞SIGCHLD
    for (i = 0; i < 10; i++) {
        if ((pid = fork()) == 0)
            break;
        else if (pid < 0)
            sys_err("fork");
    }

    if (pid == 0) {     //10个子进程
        int n = 1;
        while (n--) {
            printf("child ID %d\n", getpid());
            sleep(1);
        }
        return i+1;
    } else if (pid > 0) {
        //SIGCHLD阻塞
        struct sigaction act;

        act.sa_handler = do_sig_child;
        sigemptyset(&act.sa_mask);
        act.sa_flags = 0;
        sigaction(SIGCHLD, &act, NULL);
        //解除对SIGCHLD的阻塞
        
        while (1) {
            printf("Parent ID %d\n", getpid());
            sleep(1);
        }
    }
    return 0;
}

如果每创建一个子进程后不使用sleep可以吗？可不可以将信号捕捉函数的while替换为if，为什么？
if((pid = waitpid(0, &status, WNOHANG)) > 0){…}
  最好使用sleep，防止父进程还没有捕获SIGCHILD信号，子进程就结束了。
  不能将while替换为if，会导致有些子进程没有回收，因为信号不支持排队，当一个子进程的SIGCHLD信号被捕获，进入捕捉函数之后，如果同时有其他三个子进程发送SIGCHLD，依据信号捕捉特性，这三个子进程的信号只捕捉一个，从而导致其他两个子进程没有被捕捉。

信号传参

sigqueue函数对应kill函数，可在指定进程发送信号的同时携带参数

int sigqueue(pid_t pid, int sig, const union sigval value);//成功返回0，失败返回-1，设置errno
union sigval
{
	int sival int;
	void *sival_ptr;
}

向指定进程发送指定信号的同时，携带数据，如果传地址需要注意，不同进程之间虚拟地址控件各自独立，将当前进程地址传递给另一个进程没有实际意义。

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
struct sigaction
{
	void (*sa_handler)(int);
	void (*sa_sigaction)(int, siginfo_t*, void *);
	sigset_t sa_mask;
	int sa_flags;
	void (*sa_restorer)(void);
};

当注册信号捕捉函数，希望获得更多信号相关信息，不应使用sa_handler而应该使用sa_sigaction，但此时sa_flags必须指定为SA_SIGINFO，siginfo_t是一个成员十分丰富的结构体类型，可以携带各种与信号相关的数据。

中断系统调用

系统调用可以分为两类：慢速系统调用和其他系统调用
  1.慢速系统调用：可能会使进程永远阻塞的一类，如果在阻塞期间收到一个信号，该系统调用就被中断，不再继续执行(早期)，也可以设定系统调用是否重启，如：read,write,pause,wait…
  2.其他系统调用：getpid,getppid,fork…
结合pause，回顾慢速系统调用：
慢速系统调用被中断的相关行为，实际上就是pause的行为：如，read
  1.想中断pause，信号不能被屏蔽
  2.信号的处理方式必须是捕捉(默认和忽略都不可以)
  3.中断后返回-1，设置errno为EINTR(表示被信号中断)
可修改sa_flags参数来设置被信号中断后系统调用是否重启，SA_INTERRURT不重启，sa_flags还有很多可选参数，适用于不同情况，如：捕捉到信号后，在执行捕捉函数期间，不希望自动阻塞该信号，可将sa_flags设置为SA_NODEFER，除非sa_mask中包含该信号。