TCP/IP网络编程之多进程服务端(二)

信号处理

本章接上一章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函数的调用语句,分别完成如下两个请求:

  1. 已经通过alarm函数注册的时间,请调用timeout函数
  2. 输入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给出了基于多进程的并发回声服务端的实现模型

TCP/IP网络编程之多进程服务端(二)

图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函数后,两个文件描述符指向同一套接字

TCP/IP网络编程之多进程服务端(二)

图1-3   调用fork函数并复制文件描述符

图1-3所示,一个套接字中存在两个文件描述符,只有两个文件描述符都销毁后,才能销毁套接字。如果维持图中的连接状态,即使子进程销毁了与客户端连接的套接字文件描述符,也无法完全销毁套接字(服务端套接字同理)。因此,调用fork函数后,要将无关紧要的套接字文件描述符关掉,如图1-4所示

TCP/IP网络编程之多进程服务端(二)

图1-4   整理复制的文件描述符

分割I/O程序的优点

我们已经实现的回声客户端的数据回声方式为:向服务端传输数据,并等待服务端回复。无条件等待,直到接收完服务端的回声数据后,才能传输下一批数据。传输数据后需要等待服务端返回的数据,因为程序中重复调用了read和write函数,只能这么写的原因之一是:程序在一个进程运行,但现在可以创建多个进程,因此可以分割数据收发过程,默认分割模型如图1-5所示:

TCP/IP网络编程之多进程服务端(二)

图1-5   回声客户端I/O分割模型

从1-5可以看出,客户端的父进程负责接收数据,额外创建的子进程负责发送数据。分割后,不同进程分别负责输入和输出,这样,无论客户端是否从服务端接收完数据都可以进程传输。选择这种实现方式的原因很多,但最重要的一点是,程序的实现更加简单,也许有人质疑:既然多产生一个进程,怎么能算简化程序呢?其实,按照这种实现方式,父进程只需编写接收数据的代码,子进程只需编写发送数据的代码,所以会简化。实际上,在一个进程内同时实现数据收发逻辑要考虑更多细节,程序会更复杂

分割I/O程序的另一个好处是,可以提高频繁交换数据的程序性能,如图1-6

TCP/IP网络编程之多进程服务端(二)

图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):”。无论是否接收消息,每次通过键盘输入字符串都会输出前面的提示字符串,可能会造成输出混乱,所以上面示例就没在输出提示字符串

  

上一篇:转】mysql数据库delete数据时不支持表别名


下一篇:javascript Array类