TCP/IP网络编程 学习笔记_11 --多进程服务器端

并发服务器

首先，我们来假设有下面这样两种类型的服务器：第一种，第一个连接请求的受理时间为1s，第50个连接请求的受理时间为50s，第100个连接请求的受理时间为100s。即同时很多客服端连接，需要依次排队受理，但只要受理了，他们的服务时间平均只需1s。第二种，所有连接请求的受理时间不超过1s，但平均服务时间要2~3s。
即使有可能延长服务时间，我们实际网络编程中也一般选择第二种方式，使其可以同时向所有发起请求的客服端提供服务，以提高平均满意度。而且，网络程序中数据通信时间比CPU运算时间占比更大，因此，我们更应该选择第二种方式的服务器–并发服务器，充分利用CUP。
下面我们来看看具有代表性的并发服务器端的实现模型和方法：

• 多进程服务器：通过创建多个进程来同时提供服务
• 多路复用服务器：通过捆绑并统一管理I/O对象提供服务
• 多线程服务器：通过生成与客服端等量的线程提供服务

本章先来讲讲第一种：多进程服务器。这种方法Windows不支持，因此将重点放在Linux平台…

多进程理论基础

• 什么是进程：
  我们可以这么理解进程：就是占用内存空间的正在运行的程序。如：我们网上下载了一个游戏并安装到了硬盘，此时的游戏并非进程，而是程序。因为游戏并未进入运行状态。下面开始运行程序，此时游戏被加载到内存并进入运行状态，这时才可称为进程。如果同时多开这个游戏，则会生成相应数量的进程，也会占用相应进程数的内存空间，它们之间是独立的内存结构，互不影响。
  还有一种就是一个程序运行过程中也可以产生多个进程，本章要讲的多进程服务器就是这种的代表。
  补充：拥有2个运算设备的CPU称作双核CPU，拥有4个运算器的CPU称作4核。核的个数与可同时运行的进程数相同。相反，若进程数超过核数，进程将分时使用CPU资源。只是因为CPU运行速度极快，我们会感觉所有进程同时运行而已。当然，核数越多，这种感觉越明显。

• 进程ID
  所有进程在创建时，操作系统都会为其分配一个ID号，其值是大于2的整数，ID=1的进程是操作系统启动后(用于协助操作系统)的首个进程，这个进程用户无法得到。下面来看下Linux上查看当前运行进程的命令：ps(查看详细信息:ps au)
  

• 通过调用fork函数创建进程

  pid_t fork(void);
  成功返回进程ID，失败时返回-1。

  fork函数是复制正在运行的，调用fork函数的进程。这两个进程都将执行fork函数调用后的语句。所以之后的语句执行流程要区分父进程与子进程，我们可以通过fork函数的返回值来做区分，即父进程：fork函数返回子进程ID，子进程：fork函数返回0。

pid_t pid;
pid = fork();
if(pid == 0)
{
    //子进程
}
else
{
    //父进程
}

• 僵尸进程
  僵尸进程就是指完成任务的进程本应销毁释放所占内存空间的，但它没有销毁，常驻内存，此时这个进程就称作僵尸进程。
  那么僵尸进程是怎么产生的呢？首先，进程的回收是操作系统控制的，系统回收时机一般是这样两种情况：1，传递参数并调用exit函数。2，main函数中执行retrun语句并返回值。但对于子进程，这两种情况操作系统不会直接销毁子进程，子进程的销毁只有通过它的父进程间接传递给操作系统来回收。此后，子进程就成了僵尸进程。最终只有随父进程一起销毁。

• 销毁子进程
  上面讲了子进程直接调用exit或retrun结束会成为僵尸进程，那么应该如何销毁子进程了？前面说了，子进程的销毁需要其父进程把销毁消息间接的传递给操作系统，做法有两种：
  销毁子进程方式1：利用wait函数

int status;
pid_t pid = fork();
if(pid == 0)
{
    exit(1);  //或者return 0;
}
else
{
    wait(&status); //成功时返回终止的子进程ID，失败时返回-1
    if(WIFEXITED(status))//宏，子进程正常终止返回真
        printf("Child return: %d \n", WEXITSTATUS(status)); //宏，返回子进程的返回值
}

这就是用wait函数销毁子进程，但是要注意一点，wait函数是一个阻塞函数，如果没有已终止的子进程，那么程序将阻塞直到有子进程终止，因此要谨慎使用该函数。

销毁子进程方式2：使用waitpid函数
wait函数会引起程序阻塞，我们还可以使用waitpid函数，它可以不阻塞。

int status;
pid_t pid = fork();
if(pid == 0)
{
    sleep(15);
    return 24;
}
else
{
    //没有终止子进程返回0，有则返回终止子进程ID，失败时返回-1
    while(!waitpid(-1, &status, WNOHANG))//不会阻塞
    {
        sleep（3);
        puts("sleep 3s");
    }
    if(WIFEXITED(status))
        printf("Child return %d \n", WEXITSTATUS(status));
}

• 信号处理(事件驱动)
  前面我们知道了怎么去销毁子进程，避免僵尸进程产生。但还一个问题，就是我们究竟何时终止子进程呢？我们肯定不能像上面写的事例那样，在父进程中一直循环检测。所以，这小节我们将讨论另一种高效的方式：信号处理，即事件驱动(就是注册某个事件，只要这个事件任何时候产生了，就会自动回调通知注册的函数)。这样我们就不需要再关心何时终止子进程的问题了。
  1，先来看看Linux上旧版的注册函数

  void (*signal(int signo, void (*func)(int) ))(int);

  返回值：void (*signal)(int)
  函数名：signal
  参数：int signo, void (*func)(int)

  说明：int signo参数是注册的事件类型，一般有：SIGALRM(到了alarm注册的时间),SIGINT(输入CTRL+C)，SIGCHLD(子进程终止)。void (*func)(int)参数只一个函数指针，是参数1事件响应后要执行的回调函数。
  实例如下：

//时间响应回调函数
void timeout(int sig)
{
    if(sig == SIGALRM)
        puts("Time out!");
}

int main()
{
    signal(SIGALRM, timeout);//注册事件
    alarm(2);//2s后产生SIGALRM类型事件
    sleep(100);
    return 0;
}

2，实际中使用更多的注册函数(signal函数在UNIX系列的不同操作系统中可能存在区别，但sigaction函数则完全相同)

int sigaction(int signo, const struct sigaction act, struct sigaction oldact);
成功时返回0，失败返回-1

struct sigaction
{
void (*sa_handler)(int); //回调函数
sigset_t sa_mask; //一般全初始化为0
int sa_flags; //初始化为0
}

实例如下：

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

int main()
{
    //初始化结构体
    struct sigaction act;
    act.sa_handler = timeout;
    sigemptyset(&act.sa_mask); //设置sa_mask成员的所有位为0
    act.sa_flags = 0;

    sigaction(SIGALRM, &act, 0);//注册事件
    alarm(2);
    sleep(100);
    return 0;
}

好，以上就是我们所有的理论知识了，下面我们就可以实际运用中使用这些知识编写基于进程的并发服务器了。

基于多进程的并发服务器

• 服务端

//
//  main.cpp
//  hello_server
//
//  Created by app05 on 15-8-18.
//  Copyright (c) 2015年 app05. All rights reserved.
//
//每连一个客服端就对应开一个进程，即服务端子进程数与客服端连接数对应

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <signal.h>

#define BUF_SIZE 1024
void error_handling(char *message);
void read_childproc(int sig); //子进程销毁回调

int main(int argc, const 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) //子进程运行模块
        {
            /*子进程复制了父进程中的serv_sock句柄，它们都指
            向同一套接字， 只有两个都close后，这个套接字才会
            销毁。所以要注意一一对应close关闭。
            */
            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 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);
}

• 客服端

//
//  main.cpp
//  hello_client
//
//  Created by app05 on 15-8-18.
//  Copyright (c) 2015年 app05. All rights reserved.
//
//客服端I/O分割，父进程负责接收数据，子进程负责发送数据，分开处理

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

#define BUF_SIZE 1024
void error_handling(char *message);
void read_routime(int sock, char *buf);  //接收数据
void write_routine(int sock, char *buf);  //发送数据

int main(int argc, const 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);
    if(sock == -1)
        error_handling("socket() error");

    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");

    /*客服端I/O分割，父进程负责接收数据，子进程负责发送数据。
     这样分开可以提高频繁交换数据的程序性能，而不用像以前一样，
     只有完全接收上一条数据后才能发送下一条。*/
    pid = fork();
    if(pid == 0)
        write_routine(sock, buf);
    else
        read_routime(sock, buf);

    close(sock);
    return 0;
}


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

void read_routime(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);
        }
        write(sock, buf, strlen(buf));
    }
}