TCP并发服务器(二)——预创建子进程，accept不上锁

TCP并发服务器(二)——预创建子进程，accept不上锁

1.说明

这是预创建进程中速度最快的。

适用于源自BSD的内核，但是accept是一个库函数的System V可能不允许这么做(因此需要accept上锁保护)。

2.优缺点

无需引入父进程执行fork的开销就能处理新的客户。缺点时必须在启动阶段猜测需要预创建多少子进程。

如果某个时刻客户数恰好等于子进程总数，新的客户将被忽略直到至少一个子进程重新可用。

在实际上客户没有被忽略，内核为每个新客户完成三路握手，直到listen调用的backlog数为止。然后accept在已连接队中取出描述符。

尽管connect可能立即返回，但是请求可能在一段时间以后才被服务器处理。

3.解决办法

可以监控闲置子进程数，动态增减子进程数。

4.代码

#include "unp.h"
#include <vector>
#include <sys/mman.h>        //for mmap()

using std::vector;

//共享内存首地址
static long *cptr;;
static int nchildren;
static vector<int> pids;

void sig_int(int signo)
{
for (int i = 0; i < nchildren; ++i) {
kill(pids[i], SIGTERM);
}
while (wait(NULL) > 0) {
;
}
if (errno != ECHILD) {
err_sys("wait error");
}

DPRINTF("The number of child process accept.");
for (int i = 0; i < nchildren; ++i) {
DPRINTF("%ld", cptr[i]);
}

void pr_cpu_time(void);
pr_cpu_time();

exit(0);
}

int main(int argc, char *argv[])
{
int listenfd;
socklen_t addrlen;
if (argc == 3) {
listenfd = Tcp_listen(NULL, argv[1], &addrlen);
} else if (argc == 4) {
listenfd = Tcp_listen(argv[1], argv[2], &addrlen);
} else {
err_quit("Usage: a.out [ <host> ] <port#> <#children>");
}

nchildren = atoi(argv[argc - 1]);
pids.resize(nchildren);
//查看连接在子进程的分布
//使用共享内存未每个子进程的连接计数
//fork之后父进程和子进程共享cptr
long *meter(int);
cptr = meter(atoi(argv[argc - 1]));
//cptr = (long*)Calloc(nchildren, sizeof(long));

//创建子进程
pid_t child_make(int i, int listenfd, int addrlen);
for (int i = 0; i < atoi(argv[argc - 1]); ++i) {
pids[i] = child_make(i, listenfd, addrlen);
}

//SIGCHLD处理函数
void sig_chld(int);
Signal(SIGCHLD, sig_chld);
Signal(SIGINT, sig_int);

for ( ; ;) {
;             //child does everything
} //end for(;;)

return 0;
}

void sig_chld(int)
{
static int cnt = 0;
pid_t pid;
int stat;
//param1: 想要等待的PID；-1: 等待第一个终止的子进程
//param2: 子进程的终止状态(整数)
//param3: 附加选项；WNOHANG：没有子进程终止时，不阻塞
while ((pid = waitpid(-1, &stat, WNOHANG)) > 0) {    //成功：返回进程ID > 0, 出错：0或-1
DPRINTF("Waitpid for %d child process\n", ++cnt);
;
}

return;
}

pid_t child_make(int i, int listenfd, int addrlen)
{
void child_main(int, int, int);
pid_t pid = Fork();
if (pid > 0) {        //parent
return pid;
}
child_main(i, listenfd, addrlen);
}

void child_main(int i, int listenfd, int addrlen)
{
DPRINTF("child %ld starting\n", (long)getpid());
void web_child(int);
for ( ; ; ) {
DPRINTF("Wait for a connection");
int connfd = Accept(listenfd, NULL, NULL);
//共享内存计数增加
++cptr[i];
DPRINTF("Accept a connection, total accept %ld connection", cptr[i]);

web_child(connfd);
Close(connfd);
}
}

long *meter(int nchildren)
{
#ifdef MAP_ANON            //匿名映射
long *ptr = (long*)Mmap(0, nchildren * sizeof(long), PROT_READ | PROT_WRITE,
MAP_ANON | MAP_SHARED, -1, 0);
#else
int fd = Open("/dev/zero", O_RDWR, 0);
long *ptr = (long*)Mmap(0, nchildren * sizeof(long), PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0);
//已完成文件到进程地址空间的映射，可以关闭原文件
Close(fd);
#endif

return ptr;
}

5.惊群

由于子进程阻塞在accept上，但是当一个连接到达时只会有一个子进程获得连接。但是所有的子进程都被唤醒了，这种现象就是惊群，会影响程序性能。

当子进程过多时惊群现象会更加严重。

我们可以不阻塞于accept，而是select上。

但是多个进程在引用同一个套接字描述符上调用select会发生select冲突。此时会增加CPU时间，因为增加了系统调用。

结论：如果多个进程阻塞在引用同一个实体(如：套接字或普通文件)的描述符上，最好直接阻塞于诸如accept之类的函数，而不是select。