TCP/IP网络编程 -- （十）多进程服务器端
10.1进程概念及应用
为了提高客户端的平均满意度，通常会使用并发服务器的方法，并且网络程序中数据通信时间比 CPU 运算时间大，因此向多个客户端提供服务是一种有效利用 CPU 的方式
主要有三种方法：
多进程服务器：通过创建多个进程提供服务
多路复用服务器：通过捆绑并统一管理 I/O 对象提供服务
多线程服务器：通过生成与客户端等量的线程提供服务
理解进程
进程：占用内存空间的正在运行的程序
ps 命令可查看当前运行的所有进程（ps au）
通过调用 fork 函数创建进程
#include <unistd.h>
pid_t fork(void);
成功时返回进程ID，失败返回 -1
创建的为当前进程的副本，两个进程都将执行 fork 函数返回后的语句
但是因为是同一个进程复制相同的内存空间得到的新进程，所以之后的程序流程要根据 fork 的返回值加以区分
父进程：fork 返回子进程 ID
子进程：fork 返回 0
复制进程后 gval 与 lval 在两个进程后是独立的，只是共享同一份代码
10.2进程与僵尸进程
进程执行完 main 函数中的程序应该被销毁，但有时会变成僵尸进程，占用系统重要资源。
产生僵尸进程的原因
终止子进程只有通过下面两种方式
- 传递参数并调用 exit()
- main 函数中执行 return
exit 中的参数或 main 函数返回值都会传给操作系统，但是并不会销毁进程，直到把这些值传给父进程，这样的状态下的进程就是僵尸进程
但是操作系统不会自动将这些值传给父进程，而是在父进程主动发起函数调用时才会获取这些值（父母要负责收回自己的孩子，操作系统并不负责）
销毁僵尸进程1：利用 wait 函数
#include <sys/wait.h>
pid_t wait(int *statloc)
成功时返回终止的子进程 ID，失败返回 -1
子进程终止时传递的返回值将会保存在 statloc 所致的内存空间中，但是还包含了其他信息，需要通过下面的宏来分离
int *status;
wait(status);
if (WIFEXITED(status))//正常终止返回 true
{
puts("Normal termination");
printf("Child pass num: %d", WEXITSTATUS(status));// WEXISTTATUS 返回子进程的返回值
}
销毁僵尸进程2：使用 waitpid 函数
wait 函数会引起程序阻塞，如果当前没有子进程终止，父进程会阻塞在这里
#include <sys/wait.h>
pid_t waitpid(pid_t pid, int *statloc, int options)
成功时返回终止的子进程 ID，失败返回 -1
pid：等待终止目标子进程的 ID，若传递 -1，则和 wait 一样是等待任意子进程终止
statloc：保存返回值的指针，和 wait 函数相同
option：若传递常量 WNOHANG，则即使目标子进程没有终止，也不会阻塞等待，而是返回 0 并退出
10.3信号处理
父进程不能一直调用 waitpid 函数来等待子进程终止，但是操作系统知道子进程何时终止的，最好操作系统可以给父进程传递一个信号来告诉子进程终止了
流程为：
父进程告诉操作系统：如果创建的子进程终止，就帮我调用 zombie_handler 函数
操作系统回复：我可以帮你调用，但是你要先把 zombie_handler 函数编好
相当于父进程需要先注册信号，子进程结束后操作系统直接可以调用
#inlclude <signal.h>
void (*signal(int signo, void(*func)(int)))(int);
函数名：signal
参数：int signo, void(* func)(int)
返回类型：参数为 int，返回 void 型函数指针
alarm 函数
#include <unistd.h>
unsigned int alarm(unsigned int seconds);
若传递 t，表示 t 秒后将产生 SIGALRM 信号；传递 0，表示之前对 SIGALRM 的预约取消
信号常量：
SIGALRM：已到通过调用 alarm 函数注册的时间
SIGINT：输入了 ctrl + C
SIGCHLD：子进程终止
事例：
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
void timeout(int sig)
{
if (sig == SIGALRM)//其实是不用写 if 的，这里是一个类似 assert 的功能
puts("Time out");
alarm(2);
}
void keycontrol(int sig)
{
if (sig == SIGINT)
puts("CTRL + C pressed");
}
int main()
{
signal(SIGALRM, timeout);
signal(SIGINT, keycontrol);
alarm(2);
for (int i = 0; i < 3; i++)
{
puts("wait...");
sleep(100);
}
return 0;
}
利用 sigaction 函数进行信号处理
signal 在不同的 UNIX 系统中可能存在区别，但 sigactoin 函数完全相同
#include <signal.h>
int sigaction(int signo, const struct sigaction *act, struct sigaction *oldact);
成功返回 0，失败返回 -1
signo：与 signal 相同，传递信号信息
act：对应第一个参数信号的处理信息
oldact：获取之前的处理信息的指针，如果不需要则传递 0
struct sigaction
{
void (*sa_handler)(int);
sigset_t sa_mask; //一般情况用 sigemptyset(&act.sa_mask) 置0即可
int sa_flags;//一般情况置0
};
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
void timeout(int sig)
{
if (sig == SIGALRM)
puts("Time out");
alarm(2);
}
int main()
{
struct sigaction act;
act.sa_handler = timeout;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGALRM, &act, 0);
alarm(2);
for (int i = 0; i < 3; i++)
{
puts("wait...");
sleep(100);
}
return 0;
}
基于进程的并发服务器模型
每当有客户端请求服务时，服务器都创建一个子进程提供服务，分为三个阶段
- 服务器（父进程）通过调用 accept 函数受理连接请求
- 获取 socket 文件描述符，创建子进程，并把文件描述符传递给子进程
- 子进程利用传递来的文件描述符提供服务
其实不需要把文件描述符传递给子进程，因为子进程有和父进程一样的资源
多进程并发服务器
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <arpa/inet.h>
const int BUF_SIZE = 30;
void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}
void read_childproc(int sig)
{
pid_t pid;
int status;
pid = waitpid(-1, &status, WNOHANG);
printf("removed proc id: %d \n", pid);
}
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();
//进程创建失败，但不知道为什么continue，当前循环的clnt_sock不处理了吗
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;
}
注意在子进程运行开始执行了 close(serv_sock); 在创建子进程后也执行了 close(clnt_sock);
这是因为子进程复制 socket 后，同一个端口将对应多个 socket ，要关掉多余的 socket
其实上面的解释是有点问题的，因为 socket 不是进程的资源，而是操作系统的资源，并不会复制给子进程，但是会复制 socket 的文件描述符，这样就有两个文件描述符指向同一个 socket，只有当关闭所有的文件描述符才能关闭连接（类似于 shared_ptr）
要整理为
因为子进程是处理与客户端连接的，需要持有客户端连接 socket；父进程是第四章的那个”门卫“，只需要有服务器端的 socket 就可以了
10.5分割了 TCP 的 I/O 程序
客户端向服务器发送数据后要等待服务器的回复，才可以发送下一次数据
现在考虑多进程客户端，父进程只考虑读操作，子进程只考虑写操作，分离 I/O 可支持流水线写数据（暂时不太懂为什么）
