ECF入门（下）

上一次聊了聊fork，接下来我们看一看signal
首先讲一下LINUX中的一部分下面会用到的信号：

2 SIGINT 来自键盘的中断
9 SIGKILL 杀死程序
11 SIGSEGV 无效的内存引用（段故障）
14 SIGALARM 来自alarm函数的定时器信号
17 SIGCHILD 一个子进程停止或终止

接下来来看几个下面会用到的函数:

kill函数

#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid,int sig)

pid>0 kill函数发送sig信号给指定的进程pid
pid=0 kill函数发送sig信号给调用进程所在进程组的每个进程,包括调用进程自己
pid<0 kill函数发送sig信号给进程组|pid|中的每个进程

alarm函数

#include <unistd.h>
unsigned int alarm(unsigned int secs);

alarm函数安排内核在secs秒后发送一个SIGALARM信号给调用进程

signal函数

#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum,sighandler_t handler)

每个信号其实是由相关联的默认行为的，但是 signal函数可以规定接收到除了SIGKILL和SIGSTOP以外的信号的操作。
如果handler是SIG_IGN的话，就忽略到signum信号
若果handler是SIG_DEL的话，就恢复signum信号的默认行为
否则程序受到signum是就调用handler定义的信号处理程序进行运行。

然后放一下Linux的信号表：

接下来我们看看程序

fork12

void fork12()
{
    pid_t pid[N];
    int i;
    int child_status;

    for (i = 0; i < N; i++)
	if ((pid[i] = fork()) == 0) {
	    /* Child: Infinite Loop */
	    while(1)
		;
	}
    for (i = 0; i < N; i++) {
	printf("Killing process %d\n", pid[i]);
	kill(pid[i], SIGINT);
    }

    for (i = 0; i < N; i++) {
	pid_t wpid = wait(&child_status);
	if (WIFEXITED(child_status))
	    printf("Child %d terminated with exit status %d\n",
		   wpid, WEXITSTATUS(child_status));
	else
	    printf("Child %d terminated abnormally\n", wpid);
    }
}

这里运行了五次fork，每一次fork产生的子进程都陷入了死循环。

然后，父进程给PID为pid[0]-pid[4]的子进程发送了一个来自键盘的中断信号SIGINT，因为没有定义signal接收到SIGINT的行为，所以它的默认行为就是终止。


接着父进程继续运行wait函数查看子进程是否终止，他会查看N次，正好对应N个子进程，然后发现子进程都终止了，但都不是调用exit或者return正常终止的，所以在这里查看WIFEXITED返回的是假，那么就会打印后面一句非正常终止。
程序运行结果如下：

fork13

/*
 * int_handler - SIGINT handler
 */
void int_handler(int sig)
{
    printf("Process %d received signal %d\n", getpid(), sig); /* Unsafe */
    exit(0);
}

/*
 * fork13 - Simple signal handler example
 */
void fork13()
{
    pid_t pid[N];
    int i;
    int child_status;

    signal(SIGINT, int_handler);
    for (i = 0; i < N; i++)
	if ((pid[i] = fork()) == 0) {
	    /* Child: Infinite Loop */
	    while(1)
		;
	}

    for (i = 0; i < N; i++) {
	printf("Killing process %d\n", pid[i]);
	kill(pid[i], SIGINT);
    }

    for (i = 0; i < N; i++) {
	pid_t wpid = wait(&child_status);
	if (WIFEXITED(child_status))
	    printf("Child %d terminated with exit status %d\n",
		   wpid, WEXITSTATUS(child_status));
	else
	    printf("Child %d terminated abnormally\n", wpid);
    }
}

这个程序和上面一个十分相像，但是它用signal(SIGINT, int_handler)修改了进程受到SIGINT时的默认行为。从原来表中查询到的中断变成了打印一句话，然后正常退出，所以后续的WIFEXITED就为真，打印了上一句话。因为程序长得差不多，操作也几乎差不多，这里就不再放进程图了。
运行结果：

fork14

/*
 * child_handler - SIGCHLD handler that reaps one terminated child
 */
int ccount = 0;
void child_handler(int sig)
{
    int child_status;
    pid_t pid = wait(&child_status);
    ccount--;
    printf("Received SIGCHLD signal %d for process %d\n", sig, pid); /* Unsafe */
    fflush(stdout); /* Unsafe */
}

/*
 * fork14 - Signal funkiness: Pending signals are not queued
 */
void fork14()
{
    pid_t pid[N];
    int i;
    ccount = N;
    signal(SIGCHLD, child_handler);

    for (i = 0; i < N; i++) {
	if ((pid[i] = fork()) == 0) {
	    sleep(1);
	    exit(0);  /* Child: Exit */
	}
    }
    while (ccount > 0)
	;
}

这里就是fork了五个子进程，然后让他们各自休眠1，然后子进程退出，发送SIGCHILD信号给父进程，父进程调用child_handler函数，随机检查一个进程的状态，然后打印，一些操作后程序陷入死循环。
先看一下结果:

然后我们来分析一下（只是我的拙见）：
首先先fork出的进程先结束休眠退出发信号，但是这些等待父进程处理的信号并不是有序排队的，所以父进程在还未进入死循环之前处理了一部分信号，就如图所示，紧接着父进程进入死循环，就不在处理信号了，子进程就变成僵死进程。

/*
 * child_handler2 - SIGCHLD handler that reaps all terminated children
 */
void child_handler2(int sig)
{
    int child_status;
    pid_t pid;
    while ((pid = wait(&child_status)) > 0) {
	ccount--;
	printf("Received signal %d from process %d\n", sig, pid); /* Unsafe */
	fflush(stdout); /* Unsafe */
    }
}
/*
 * fork15 - Using a handler that reaps multiple children
 */
void fork15()
{
    pid_t pid[N];
    int i;
    ccount = N;

    signal(SIGCHLD, child_handler2);

    for (i = 0; i < N; i++)
	if ((pid[i] = fork()) == 0) {
	    sleep(1);
	    exit(0); /* Child: Exit */

	}
    while (ccount > 0) {
	pause();
    }
}

先看一下运行结果：

然后我再来发表一下拙见：这里首先最后的死循环里面用到了pause函数，pause函数使得父进程一直能够等待接收外来的信号，所以上一个程序里出现的子进程退出发送的SIGCHILD父进程接收不到的问题就不会再出现了，此外在接收到SIGCHILD后调用的程序里，添加了一条循环，只要有子进程退出，他都要打印出来并且回收。（但这里我感觉其实起作用的还是在于handler2，因为这里会一直等子进程结束，其实pause不会起到真正的作用)

fork16

void fork16()
{
    if (fork() == 0) {
	printf("Child1: pid=%d pgrp=%d\n",
	       getpid(), getpgrp());
	if (fork() == 0)
	    printf("Child2: pid=%d pgrp=%d\n",
		   getpid(), getpgrp());
	while(1);
    }
}

fork17

void fork17()
{
    if (fork() == 0) {
	printf("Child: pid=%d pgrp=%d\n",
	       getpid(), getpgrp());
    }
    else {
	printf("Parent: pid=%d pgrp=%d\n",
	       getpid(), getpgrp());
    }
    while(1);
}

这里我们要了解到一个组的概念，这里简单来说就是凡是一个父进程fork出来的子进程都在和父进程的一个组里。
来看看果然如此的结果：

本文部分图片引用自CMU的CSAPP