信号处理
本章接上一章TCP/IP网络编程之多进程服务端（一），在上一章中，我们介绍了进程的创建和销毁，以及如何销毁僵尸进程。前面我们讲过，waitpid是非阻塞等待子进程销毁的函数，但有一个不好的缺点就是要每隔一段时间判断子进程是否销毁，只有销毁完后才能执行父进程接下去的程序。这样显然会造成父进程一些资源上的浪费，那么有没有又可以销毁子进程，又不用让父进程等待的解决方案呢？答案当然是有的
子进程终止的识别主体是操作系统，因此，若操作系统能主动告诉通知正忙于执行程序的父进程说，子进程已经终止了，于是父进程放下手上的工作，处理子进程终止相关事宜，这不是两全其美吗？为了实现这样的想法，我们引入了“信号机制”。此处的“信号”是在特定事件发生时由操作系统向进程发送的消息。另外，为了响应该消息，执行与消息相关的自定义操作的过程称为“处理”或“信号处理”
信号与signal函数
#include <signal.h>
void (*signal(int signo, void (*func)(int)))(int);//为了在产生信号时调用，返回之前注册的函数指针
上述函数的返回值类型为函数指针，因此函数声明有些繁琐，现在讲解下函数声明：
- 函数名：signal
- 参数：int signo，void (* func)(int)
- 返回类型：参数为int型，返回void型函数指针
调用上述函数时，第一个参数为特殊情况信息，第二个参数为特殊情况下将要调用的函数的地址值（指针）。发生第一个参数代表的情况时，调用第二个参数所指的函数。下面给出可以在signal函数中注册的部分特殊情况和对应常数：
- SIGALRM：已到通过调用alarm函数注册的时间，alarm也称为闹钟函数，它可以在进程中设置一个定时器，当定时器指定的时间到时，它向进程发送SIGALRM信号。可以设置忽略或者不捕获此信号，如果采用默认方式其动作是终止调用该alarm函数的进程
- SIGINT：输入CTRL+C
- SIGCHLD：子进程终止
接下来编写调用signal函数的语句完成的请求：子进程终止则调用mychild函数。此时mychild函数的参数应为int，返回值类型应为void。只有这样才能称为signal函数的第二个参数，另外，常数SIGCHLD定义了子进程终止的情况，应成为signal函数的第一个参数。也就是说，signal函数调用语句如下：
signal(SIGCHLD, mychild);
接下来编写signal函数的调用语句，分别完成如下两个请求：
- 已经通过alarm函数注册的时间，请调用timeout函数
- 输入CTRL+C时调用keycontrol函数
代表这两种情况的常数分别为SIGALRM和SIGINT，因此按如下方式调用signal函数
signal(SIGALRM, timeout);
signal(SIGINT, keycontrol);
以上就是信号注册的过程，注册好信号后，发生注册信号时，操作系统将调用该信号对应的函数。下面通过示例验证，先介绍alarm函数
#include<unistd.h>
unsigned int alarm（unsigned int seconds);//返回0或以秒为单位的距SIGALRM信号发生所剩时间
如果调用该函数的同时向它传递一个正整形参数，相应时间后（以秒为单位）将产生SIGALRM信号。若向该函数传递0，则之前对SIGALRM信号的预约将取消。如果通过该函数预约信号后未指定该信号对应的处理函数，则（通过调用signal函数）终止进程，不做任何处理
signal.c
#include <stdio.h>
#include <unistd.h>
#include <signal.h> void timeout(int sig)
{
if (sig == SIGALRM)
puts("Time out!");
alarm(2);
}
void keycontrol(int sig)
{
if (sig == SIGINT)
puts("CTRL+C pressed");
} int main(int argc, char *argv[])
{
int i;
signal(SIGALRM, timeout);
signal(SIGINT, keycontrol);
alarm(2); for (i = 0; i < 3; i++)
{
puts("wait...");
sleep(100);
}
return 0;
}
- 第5、11行：分别定义信号处理函数，这种类型的函数被称为信号处理器（Handler）
- 第9行：为了每隔两秒重复产生SIGALRM信号，在信号处理器中调用alarm函数
- 第20、21行：注册SIGALRM、SIGINT信号及相应处理器
- 第22行：预约两秒后产生SIGALRM信号
- 第27行：为了查看信号产生和信号处理器的执行并提供每次100秒、共三次的等待时间，在循环中调用sleep函数。也就是说，再过300秒、约5分钟后终止程序，这还少相当长的一段时间，但实际执行时只需不到10秒，其原因后面解释
编译signal.c并运行
# gcc signal.c -o signal
# ./signal
wait...
Time out!
wait...
Time out!
wait...
Time out!
上述是没有任何输入时的运行结果，下面在运行过程中输入CTRL+C，可以看到输出“CTRL+C pressed”字符串。在下面的输出中，在打印第一次和第二次打印“wait”后输入CTRL+C，就会出现“CTRL+C pressed”字符串
# ./signal
wait...
^CCTRL+C pressed
wait...
^CCTRL+C pressed
wait...
Time out!
有一点必须说明：发生信号时将唤醒由调用sleep函数而进入阻塞状态的进程。调用函数的主题的确是操作系统，但进程处于睡眠状态时无法调用函数。因此，产生信号时，为了调用信号处理器，将唤醒由调用sleep函数而进入阻塞状态的进程。而且，进程一旦被唤醒，就不会再进入睡眠状态，即便还未到sleep函数中规定的时间也是如此。所以上述的示例不到10秒就结束，连续输入CTRL+C则有可能连5秒都不到
利用signal函数进行信号处理
前面所学的内容足以用来编写防止僵尸进程的代码，但这里还要再介绍一个sigaction函数，它类似于signal函数，而且完全可以替代signal函数，也更稳定。因为signal函数在Unix系列的不同操作系统中可能存在区别，但sigaction函数完全相同
#include <signal.h>
int sigaction(int signo, const struct sigaction *act, struct sigaction *oldact);//成功时返回0，失败时返回-1
- signo：与signal函数相同，传递信号信息
- act：对应于第一个参数的信号处理函数（信号处理器）信息
- oldact：通过此参数获取之前注册的信号处理函数指针，若不需要则传递0
声明并初始化sigaction结构体变量以调用上述函数，该结构体定义如下：
struct sigaction
{
void (*sa_handler)(int);
sigset_t sa_mask;
int sa_flags;
}
此结构体的sa_handler成员保存信号处理函数的指针值（地址值），sa_mask和sa_flags的所有位均初始化为0即可。这两个成员用于指定信号相关的选项和特性，而我们的目的主要是防止僵尸进程，故省略
下面给出sigaction函数的示例
sigaction.c
#include <stdio.h>
#include <unistd.h>
#include <signal.h> void timeout(int sig)
{
if (sig == SIGALRM)
puts("Time out!");
alarm(2);
} int main(int argc, char *argv[])
{
int i;
struct sigaction act;
act.sa_handler = timeout;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGALRM, &act, 0); alarm(2); for (i = 0; i < 3; i++)
{
puts("wait...");
sleep(100);
}
return 0;
}
- 第15、16行：为了注册信号处理函数，声明sigaction结构体变量并在sa_handler成员中保存函数指针值
- 第17行：调用sigemptyset函数将sa_mask成员的所有位初始化为0
- 第18行：sa_flags成员同样初始化为0
- 第19、21行：注册SIGALRM信号的处理器，调用alarm函数预约两秒后发送SIGALRM信号
编译sigaction.c并运行
# gcc sigaction.c -o sigaction
# ./sigaction
wait...
Time out!
wait...
Time out!
wait...
Time out!
这就是信号处理相关理论，以此为基础讨论僵尸进程销毁的方法
利用信号机制消灭僵尸进程
当子进程终止时将产生SIGCHLD信号，知道这一点，我们就很容易通过信号机制来消灭僵尸进程
remove_zombie.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h> void read_childproc(int sig)
{
int status;
pid_t id = waitpid(-1, &status, WNOHANG);
if (WIFEXITED(status))
{
printf("Removed proc id: %d \n", id);
printf("Child send: %d \n", WEXITSTATUS(status));
}
} int main(int argc, char *argv[])
{
pid_t pid;
struct sigaction act;
act.sa_handler = read_childproc;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGCHLD, &act, 0); pid = fork();
if (pid == 0)
{
puts("Hi! I'm child process");
sleep(10);
return 12;
}
else
{
printf("Child proc id: %d \n", pid);
pid = fork();
if (pid == 0)
{
puts("Hi! I'm child process");
sleep(10);
exit(24);
}
else
{
int i;
printf("Child proc id: %d \n", pid);
for (i = 0; i < 5; i++)
{
puts("wait...");
sleep(5);
}
}
}
return 0;
}
- 第21~25行：注册SIGCHLD信号对应的处理器，若子进程终止，则调用第7行中定义的函数。处理函数中调用了waitpid函数，所以子进程将正常终止，不会成为僵尸进程
- 第27、37行：父进程共创建两个子进程
- 第48、51行：为了等待发生SIGCHLD信号，使父进程共暂停5次，每次间隔5秒，发送信号时，父进程将被唤醒，因此实际暂停时间不到25秒
编译remove_zombie.c并运行
# gcc remove_zombie.c -o remove_zombie
# ./remove_zombie
Child proc id: 7678
Hi! I'm child process
Child proc id: 7679
wait...
Hi! I'm child process
wait...
Removed proc id: 7678
Child send: 12
wait...
Removed proc id: 7679
Child send: 24
wait...
wait...
可以看出，子进程并未编程僵尸进程，而是正常终止，接下来利用进程相关知识编写服务器端
基于多任务的并发服务器
之前的回声服务端每次只能向一个客户端提供服务，现在，我们将扩展回声服务端，使其可以同时向多个客户端提供服务。图1-2给出了基于多进程的并发回声服务端的实现模型
图1-2 并发服务端模型
从图1-2可以看出，每当客户端请求时，回声服务端都创建子进程以提供服务，请求服务的客户端若有五个，则将创建五个子进程提供服务。为了完成这个任务，需要经过如下过程：
- 第一阶段：回声服务端（父进程）通过调用accept函数受理连接请求
- 第二阶段：此时获取的套接字文件描述符创建并传递给子进程
- 第三阶段：子进程利用传递来的文件描述符提供服务
此处容易引起困惑的是向子进程传递套接字文件描述符的方法，其实没什么大不了的，子进程会复制父进程拥有的所有资源，实际上根本不用另外经过传递文件描述符的过程
echo_mpserv.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <sys/socket.h> #define BUF_SIZE 30
void error_handling(char *message);
void read_childproc(int sig); int main(int argc, char *argv[])
{
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr; pid_t pid;
struct sigaction act;
socklen_t adr_sz;
int str_len, state;
char buf[BUF_SIZE];
if (argc != 2) {
printf("Usage : %s <port>\n", argv[0]);
exit(1);
} act.sa_handler = read_childproc;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
state = sigaction(SIGCHLD, &act, 0);
serv_sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
serv_adr.sin_port = htons(atoi(argv[1])); if (bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
error_handling("bind() error");
if (listen(serv_sock, 5) == -1)
error_handling("listen() error"); while (1)
{
adr_sz = sizeof(clnt_adr);
clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &adr_sz);
if (clnt_sock == -1)
continue;
else
puts("new client connected...");
pid = fork();
if (pid == -1)
{
close(clnt_sock);
continue;
}
if (pid == 0)
{
close(serv_sock);
while ((str_len = read(clnt_sock, buf, BUF_SIZE)) != 0)
write(clnt_sock, buf, str_len); close(clnt_sock);
puts("client disconnected...");
return 0;
}
else
close(clnt_sock);
}
close(serv_sock);
return 0;
} void read_childproc(int sig)
{
pid_t pid;
int status;
pid = waitpid(-1, &status, WNOHANG);
printf("removed proc id: %d \n", pid);
}
void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
- 第29~32行：为防止产生僵尸进程而编写的代码
- 第47、52行：第47行调用accept函数后，在第52行调用fork函数。因此，父子进程分别带有一个第47行生成的套接字（受理客户端连接请求时创建的）文件描述符
- 第58~66行：子进程运行的区域，此部分向客户端提供回声服务，第60行关闭第33行创建的服务端套接字，这是因为服务端套接字文件描述符同样也传递到子进程，这一点稍后单独讨论
- 第69行：第47行中通过accept函数创建的套接字文件描述符已复制给子进程，因此服务端需要销毁自己拥有的文件描述符，这一点稍后单独说明
编译echo_mpserv.c并运行
# gcc echo_mpserv.c -o echo_mpserv
# ./echo_mpserv 8500
new client connected...
new client connected...
client disconnected...
removed proc id: 7825
client disconnected...
removed proc id: 7823
通过echo_client程序连接服务端例1
# ./echo_client 127.0.0.1 8500
Connected..........
Input message(Q to quit):Hello world!
Message from server:Hello world!
Input message(Q to quit):Hello Amy!
Message from server:Hello Amy!
Input message(Q to quit):Hello Tom!
Message from server:Hello Tom!
Input message(Q to quit):q
通过echo_client程序连接服务端例2
# ./echo_client 127.0.0.1 8500
Connected..........
Input message(Q to quit):Hello Java!
Message from server:Hello Java!
Input message(Q to quit):Hello Python!
Message from server:Hello Python!
Input message(Q to quit):Hello Golang!
Message from server:Hello Golang!
Input message(Q to quit):q
启动服务端后，要创建多个客户端连接，可以验证通过服务端同时向大多数客户端提供服务
通过fork函数复制文件描述符
示例echo_mpserv.c中给出了通过fork函数复制文件描述符的过程，父进程将两个套接字（一个是服务端套接字，另一个是与客户端连接的套接字）文件描述符复制给子进程。文件描述符的实际复制多少有些难以理解，调用fork函数时复制父进程的所有资源，有些人可能认为也会同时复制套接字，但套接字并非进程所有，从严格意义上来说，套接字属于操作系统资源，只是进程拥有代表相应套接字的文件描述符。
示例echo_mpserv.c中的fork函数调用过程如图1-3所示，调用fork函数后，两个文件描述符指向同一套接字
图1-3 调用fork函数并复制文件描述符
图1-3所示，一个套接字中存在两个文件描述符，只有两个文件描述符都销毁后，才能销毁套接字。如果维持图中的连接状态，即使子进程销毁了与客户端连接的套接字文件描述符，也无法完全销毁套接字（服务端套接字同理）。因此，调用fork函数后，要将无关紧要的套接字文件描述符关掉，如图1-4所示
图1-4 整理复制的文件描述符
分割I/O程序的优点
我们已经实现的回声客户端的数据回声方式为：向服务端传输数据，并等待服务端回复。无条件等待，直到接收完服务端的回声数据后，才能传输下一批数据。传输数据后需要等待服务端返回的数据，因为程序中重复调用了read和write函数，只能这么写的原因之一是：程序在一个进程运行，但现在可以创建多个进程，因此可以分割数据收发过程，默认分割模型如图1-5所示：
图1-5 回声客户端I/O分割模型
从1-5可以看出，客户端的父进程负责接收数据，额外创建的子进程负责发送数据。分割后，不同进程分别负责输入和输出，这样，无论客户端是否从服务端接收完数据都可以进程传输。选择这种实现方式的原因很多，但最重要的一点是，程序的实现更加简单，也许有人质疑：既然多产生一个进程，怎么能算简化程序呢？其实，按照这种实现方式，父进程只需编写接收数据的代码，子进程只需编写发送数据的代码，所以会简化。实际上，在一个进程内同时实现数据收发逻辑要考虑更多细节，程序会更复杂
分割I/O程序的另一个好处是，可以提高频繁交换数据的程序性能，如图1-6
图1-6 数据交换方法比较
图1-6左侧演示的是之前回声客户端数据交换方式，右侧演示的是分割I/O后的客户端数据传输方式。服务端相同，不同的是客户端区域。分割I/O后的客户端发送数据时不必考虑接收数据的情况，因此可以连续发送数据，由此提高同一时间内传输的数据量，这种差异在网速较慢时尤为明显
回声客户端的I/O程序分割
既然我们知道I/O程序分割的意义，接下来通过实际代码进行实现，分割的对象是回声客户端，下面回声客户端可以结合之前的回声服务端echo_mpserv.c运行
echo_mpclient.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h> #define BUF_SIZE 30
void error_handling(char *message);
void read_routine(int sock, char *buf);
void write_routine(int sock, char *buf); int main(int argc, char *argv[])
{
int sock;
pid_t pid;
char buf[BUF_SIZE];
struct sockaddr_in serv_adr;
if (argc != 3) {
printf("Usage : %s <IP> <port>\n", argv[0]);
exit(1);
} sock = socket(PF_INET, SOCK_STREAM, 0);
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family = AF_INET;
serv_adr.sin_addr.s_addr = inet_addr(argv[1]);
serv_adr.sin_port = htons(atoi(argv[2])); if (connect(sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
error_handling("connect() error!"); pid = fork();
if (pid == 0)
write_routine(sock, buf);
else
read_routine(sock, buf); close(sock);
return 0;
} void read_routine(int sock, char *buf)
{
while (1)
{
int str_len = read(sock, buf, BUF_SIZE);
if (str_len == 0)
return; buf[str_len] = 0;
printf("Message from server: %s", buf);
}
}
void write_routine(int sock, char *buf)
{
while (1)
{
fgets(buf, BUF_SIZE, stdin);
if (!strcmp(buf, "q\n") || !strcmp(buf, "Q\n"))
{
shutdown(sock, SHUT_WR);
return;
}
write(sock, buf, strlen(buf));
}
}
void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
- 第34~37行：第35行调用的write_routine函数中只有数据传输相关代码，第37行调用的read_routine函数中只有数据输入相关代码。像这样分割I/O并分别在不同函数中定义，将有利于代码实现
- 第62行：调用shutdown函数向服务端传输EOF，当然，执行第63行的return语句后，可以调用第39行的close函数传递EOF，但现在已通过第33行的fork函数调用复制了文件描述符，此时无法通过一次close函数调用传递EOF，因此需要通过shutdown函数调用另外传递
启动服务端
# ./echo_mpserv 8500
new client connected...
client disconnected...
removed proc id: 7941
编译echo_mpclient.c并运行
# gcc echo_client.c -o echo_client
# ./echo_mpclient 127.0.0.1 8500
Hello world!
Message from server: Hello world!
Hello Amy!
Message from server: Hello Amy!
Hello Tom!
Message from server: Hello Tom!
q
为了简化输出过程，与之前示例不同，不会输出提示字符串：“Input message(Q to quit):”。无论是否接收消息，每次通过键盘输入字符串都会输出前面的提示字符串，可能会造成输出混乱，所以上面示例就没在输出提示字符串