TCP IP网络编程：第10章 多进程服务器端

1. 并发服务器端的实现方法

    （1）多进程服务器：通过创建多个进程提供服务

    （2）多路复用服务器：通过捆绑并统一管理I/O对象提供服务器

    （3）多线程服务器：通过生成与客户端等量的线程提供服务

 

2. 通过调用fork函数创建进程

#include <unistd.h>

pid_t fork(void);   

// 成功返回进程ID，失败返回-1

父进程：fork函数返回子进程ID

子进程：fork函数返回0

程序中通过fork函数的返回值来区分父进程和子进程

// fork.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int gval = 10;
int main(int argc, char* argv[])
{
    int ival = 20;

    pid_t pid = fork();         // 创建子进程
    if( pid == 0)
        gval+=2, ival +=2;      // 子进程执行
    else
        gval-=2, ival -=2;      // 父进程执行
    
    if( pid ==0 )
        printf("Child Proc:[%d, %d] \n", gval, ival);   // 子进程执行
    else
        printf("Parent Proc:[%d, %d] \n", gval, ival);  // 父进程执行

    return 0;
}

运行结果：

通过运行结果可以看出，父子进程拥有完全独立的内存结构。

 

3. 销毁僵尸进程

（1）父进程中调用wait进入阻塞，等待子进程结束

 

（2）非阻塞的waitpid函数

 

4. 信号处理

因为父进程也有自己的事情要做，所以通过父进程调用wait或waitpid销毁子进程的方法在有时会影响效率，

我们可以使用信号让操作系统协助我们的工作。

#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函数的程序示例：

#include <stdio.h>
#include <unistd.h>
#include <signal.h>

void timeout(int sig)
{
    if(sig == SIGALRM)
        puts("Time out!");
    alarm(2);
}


int main()
{
    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;
}

运行结果：

 

5. 多进程服务器端

之前的回声服务器每次只能向1个客户端提供服务，我们使用基于多进程的并发回声服务器实现模型，

使其可以同时服务多个客户端。

从上图可以看出，每当有客户端请求服务（连接请求）时，回声服务器端都创建子进程以提供服务。请求服务的客户端

若有5个，则创建5个子进程提供服务。为了完成这些任务，需要经过如下过程：

（1）服务器端（父进程）通过调用accept函数受理连接请求。

（2）创建子进程

（3）子进程利用创建时从父进程复制来的文件描述符提供服务

下面给出服务器端代码，可结合第4章的回声客户端运行：

#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>
#include <sys/types.h>

#define BUF_SIZE 30
void err_sys(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)
        err_sys("bind() error");
    if(listen(serv_sock, 5) == -1)
        err_sys("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("remove proc id: %d \n", pid);
}

void err_sys(char* message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

运行结果：

我们可以看到服务端可以同时为三个客户端提供服务，三个服务端之间也不会互相影响。

终端里执行ps -au，可以看到多个server有多个进程存在