server端进程池的实现（并发服务器）

什么是进程池
在这里引用另一个博主 青城山小和尚 的关于线程池的图，进程池与线程池类似。

假设一种情况，当多个客户端的请求同时到达服务器，如果采用单线程/进程的方式，服务端就会依次处理每个客户的请求，此时其他客户将进入等待状态，直到服务端响应完请求，才会接着处理下一个任务。这会导致客户端时间过长，性能低下。

考虑并发的情况，可以采用多进程/线程的方式解决上述问题。也就是说，服务端的主线程只是用来监听客户请求，fork出的子进程用来处理请求，多进程并发处理，使得效率更高。

静态进程池套接字实现
设置固定进程池大小，父进程设置监听socket，fork出的四个子进程不断accept来自客户端的请求。另外，accept本身就可以解决多进程竞争的问题（互斥访问）。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <time.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include "proto.h"

#define MAX_NODE_SIZE  128
#define IPSTRSIZE      40
#define BUFSIZE        1024
#define PROCNUM        4

static void server_job(int sd)
{
    int len;
    char buf[BUFSIZE];
    len = sprintf(buf, FMT_STAMP, (long long)time(NULL));
    
    if(send(sd, buf, len, 0) < 0)
    {
        perror("send()");
        exit(1);
    }
}

static void server_loop(int sd)
{
    int newsd;
    char rip_addr[IPSTRSIZE];
    struct sockaddr_in raddr;
    socklen_t raddr_len;
    raddr_len = sizeof(raddr);

    while(1)
    {
        newsd = accept(sd, (void *)&raddr, &raddr_len);
        if(newsd < 0)
        {
            perror("accept()");
            close(sd);
            exit(1);
        }
        inet_ntop(AF_INET, &raddr.sin_addr, rip_addr, IPSTRSIZE);
        printf("[%d]Client:%s:%d\n", getpid(), rip_addr, ntohs(raddr.sin_port));

        server_job(newsd);
        close(newsd);
    }    
}

int main()
{
    int sd;
    pid_t pid;
    struct sockaddr_in laddr;

    if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket()");
        exit(1);
    }

    laddr.sin_family = AF_INET;
    laddr.sin_port = htons(atoi(SERVERPORT));
    inet_pton(AF_INET, "0.0.0.0", &laddr.sin_addr);

    int val = 1;
    if(setsockopt(sd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) < 0)
    {
        perror("setsockopt()");
        exit(1);
    }

    if(bind(sd, (void *)&laddr, sizeof(laddr)) < 0)
    {
        perror("bind()");
        close(sd);
        exit(1);
    }

    if(listen(sd, MAX_NODE_SIZE) < 0)
    {
        perror("listen()");
        close(sd);
        exit(1);
    }

    for(int i = 0; i < PROCNUM; i++)
    {
        if((pid = fork()) < 0)
        {
            perror("fork()");
            exit(1);
        }
        else if(pid == 0)
        {
            server_loop(sd);
            exit(0);
        } 
    }

    for(int i = 0; i < PROCNUM; i++)
        wait(NULL);

    close(sd);

    exit(0);
}

动态进程池套接字实现
静态进程池太过僵硬，因为同一时间段的客户端访问量不一定是相同的。比如打王者荣耀，访问量的时间曲线大概是___/\__这样的，那么对于低访问量的时间段来说，服务端进程池中用于处理请求的进程数量就不需要那么多；对于高访问量的时间段，如果进程数量固定（太少），又会引发开头所述的问题。
因此，进程池中进程的数量最好的可变的、弹性的。
我们可以约定最多支持的客户端连接个数，同时定义最少空闲进程个数以及最多进程空闲个数，这样当新的客户端请求到来时，就可以使用空闲的进程处理请求（有备无患）。

#define MINSPARESERVER  5
#define MAXSPARESERVER  10
#define MAXCLIENTS      20

效果分析
为更好说明动态进程池的工作机制，这里先给出运行效果。

代码实现

#include "proto.h"
#include "apue.h"

#define MINSPARESERVER  5
#define MAXSPARESERVER  10
#define MAXCLIENTS      20
#define LINEBUFSIZE     128

#define SIG_NOTIFY      SIGUSR1

enum
{
    STATE_IDLE = 0,
    STATE_BUSY 
};

struct server_st
{
    pid_t pid;
    int state;
    // int reuse;
};

static int sd;
static struct server_st *serverpool;
static int idle_count = 0, busy_count = 0;

static void usr2_handler(int s)
{
    return ;
}

static void server_job(int pos)
{
    int client_sd, len;
    socklen_t raddr_len;
    long long stamp;
    char linebuf[LINEBUFSIZE];
    struct sockaddr_in raddr;

    pid_t ppid = getppid();
    while(1)
    {
        // 设置状态为空闲并接收客户端连接
        serverpool[pos].state = STATE_IDLE;
        kill(ppid, SIG_NOTIFY);
        raddr_len = sizeof(raddr);
        if((client_sd = accept(sd, (void *)&raddr, &raddr_len)) < 0)
        {
            if(errno != EINTR || errno != EAGAIN)
            {
                perror("accept()");
                exit(1);
            }
        }

        // 处理请求时设置BUSY状态
        serverpool[pos].state = STATE_BUSY;
        kill(ppid, SIG_NOTIFY);

//      inet_ntop(AF_INET, &raddr.sin_addr, ipstr, IPSTRSIZE;
//      printf("[%d]client:%s:%d\n", getpid(), raddr.sin_port));

        stamp = (long long)time(NULL);
        len = sprintf(linebuf, FMT_STAMP, stamp);
        send(client_sd, linebuf, len, 0);
        sleep(5);
        close(client_sd);
    }
}

static int add_1_server(void)
{
    pid_t pid;
    int index;
    if(idle_count + busy_count >= MAXCLIENTS)
        return -1;
    for(index = 0; index < MAXCLIENTS; index++)
    {
        if(serverpool[index].pid == -1)
            break;
    }
    serverpool[index].state = STATE_IDLE;
    if((pid = fork()) < 0)
    {
        perror("fork()");
        exit(1);
    }
    else if(pid == 0)
    {
        server_job(index);
        exit(0);
    }
    else
    {
        serverpool[index].pid = pid;
        idle_count ++;
    }
    return 0;
    
}

static int del_1_server(void)
{
    if(idle_count == 0)
        return -1;
    
    for(int i = 0; i < MAXCLIENTS; i++)
    {
        if(serverpool[i].pid != -1 && serverpool[i].state == STATE_IDLE)
        {
            kill(serverpool[i].pid, SIGTERM);
            serverpool[i].pid = -1;
            idle_count --;
            break;
        }
    }
    return 0;
}

static int scan_pool(void)
{
    int idle = 0, busy = 0;
    for(int i = 0; i < MAXCLIENTS; i++)
    {
        if(serverpool[i].pid == -1)
            continue;
        if(kill(serverpool[i].pid, 0))
        {
            serverpool[i].pid = -1;
            continue;
        }
        if(serverpool[i].state == STATE_IDLE)
            idle ++;
        else if(serverpool[i].state = STATE_BUSY)
            busy ++;
        else
        {
            fprintf(stderr, "Unknown state.\n");
            _exit(1);
        }
        
    }
    idle_count = idle;
    busy_count = busy;
    return 0;
}

int main()
{
    int val = 1;
    sigset_t set, oset;
    struct sigaction sa, osa;
    struct sockaddr_in laddr;

    // 含一个参数的handler，因为设置子进程自行消亡(不去wait)，因此无需父进程向wait子进程，所以ignore
    sa.sa_handler = SIG_IGN;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_NOCLDWAIT;

    sigaction(SIGCHLD, &sa, &osa);

    sa.sa_handler = usr2_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;

    sigaction(SIG_NOTIFY, &sa, &osa);

    sigemptyset(&set);
    sigaddset(&set, SIG_NOTIFY);
    sigprocmask(SIG_BLOCK, &set, &oset);

    serverpool = mmap(NULL, sizeof(struct server_st) * MAXCLIENTS, PROT_WRITE,
                         MAP_SHARED|MAP_ANONYMOUS, -1, 0);
    if(serverpool == MAP_FAILED)
    {
        perror("mmap()");
        exit(1);
    }

    for(int i = 0; i < MAXCLIENTS; i++)
        serverpool[i].pid = -1;

    if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket()");
        exit(1);
    }
    
    if(setsockopt(sd, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val)) < 0)
    {
        perror("setsockopt()");
        exit(1);
    }

    inet_pton(AF_INET, "0.0.0.0", &laddr.sin_addr);
    laddr.sin_port = htons(atoi(SERVERPORT));
    laddr.sin_family = AF_INET;

    if(bind(sd, (void *)&laddr, sizeof(laddr)) < 0)
    {
        perror("bind()");
        exit(1);
    }

    if(listen(sd, 100) < 0)
    {
        perror("listen()");
        exit(1);
    }

    for(int i = 0; i < MINSPARESERVER; i++)
    {
        add_1_server();
    }

    while(1)
    {
        sigsuspend(&oset);
        /*scan_pool()--->contrl the pool*/
        scan_pool();
        if(idle_count > MAXSPARESERVER)
        {
            for(int i = 0; i < (idle_count - MAXSPARESERVER); i++)
            {
                del_1_server();
            }
        }
        else if(idle_count < MINSPARESERVER)
        {
            for(int i = 0; i < (MINSPARESERVER - idle_count); i++)
            {
                add_1_server();
            }
        }
        // 输出当前池的状态
        for(int i = 0; i < MAXCLIENTS; i++)
        {
            if(serverpool[i].pid == -1)
                printf(" ");
            else if(serverpool[i].state == STATE_IDLE)
                printf(".");
            else
                printf("x");
            
        }
        putchar('\n');
    }

    sigprocmask(SIG_SETMASK, &oset, NULL);

    exit(0);
}