【网络编程小结（三）】利用多进程与多线程

在第一节的例子中，服务器是一个时间获取程序，只要一次write调用就能立刻完成客户端的任务，但是我们要想的是，服务端不一定每次都会这么快的完成任务，所以，要想办法加快服务端的处理速度。

首先可以想到的是并行处理，c++有两种方式，一个是多进程，一个是多线程。下面描述这两种办法。

 

 

一、压力测试

我们的客户端应当有能力判断服务端处理的快慢，所以我们要写一个压力测试函数：

void request_to_server(int id,const char* ip,const uint16_t port){
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    const char *id_str=std::to_string(id).c_str();
    sockaddr_in addr;
    bzero(&addr,sizeof(addr));
    addr.sin_family=AF_INET;
    addr.sin_port=htons(port);
    inet_pton(AF_INET,ip,&addr.sin_addr);
    connect(sockfd,(const sockaddr*)&addr,sizeof(addr));
    const int buffersize=1024;
    char buf[buffersize];
    write(sockfd,id_str,strlen(id_str));
    cout<<"has sended id="<<id<<endl;
    auto n=read(sockfd,buf,buffersize);
    buf[n]='\0';
    cout<<"answer message("<<id<<"):"<<buf<<endl;

}
void task(int times,int id,const char* ip,const uint16_t port){
    
    for(int i=0;i<times;++i){
        request_to_server(id,ip,port);
    }
    
}
void pressure_test(int clinet_n,int request_per_client,const char* ip="127.0.0.1",const uint16_t port=9000){
   vector<thread> threads;
    for(int i=0;i<clinet_n;++i){
        threads.push_back(thread(task,request_per_client,i+1,ip,port));
    }
    auto t1=clock();
    for(auto& t:threads){
        t.join();
    }
    auto t2=clock();
    cout<<"all task finish. used time="<<((t2-t1)*1000/(double)CLOCKS_PER_SEC)<<" ms"<<endl;
}

压力测试函数利用多线程，指定用户数和每个用户发起的请求数，可以计算出总的处理时间。

对于我们前面的时间服务器程序——一个迭代处理方式（也就是最慢的那种），我们用100个用户发起10次请求/人。

输出：

answer message(89):Sun Jan 12 19:25:44 2020

answer message(96):Sun Jan 12 19:25:44 2020

answer message(41):Sun Jan 12 19:25:44 2020

all task finish. used time=430 ms

上面是返回数据的一部分，下面是计算得到的总时间是430ms。

 

二、慢服务器

1、迭代做法

void slow_handle_function(int id=0){
    cout<<"start processing...  -"<<id<<endl;
    sleep(3);
    cout<<"ok,finish task.  -"<<id<<endl;
    
}

首先我们有这么一个很慢的函数，要花费3秒才能完成。

 

 

void server1(){
    const uint16_t listened_port=9000;
    const char* localhost="127.0.0.1";
    const int listening_queue_length=1024;
    const int buffersize=1024;

    int listen_fd=socket(AF_INET,SOCK_STREAM,0);
    sockaddr_in server_addr;

    bzero(&server_addr,sizeof(server_addr));
    server_addr.sin_family=AF_INET;
    in_addr temp;
    inet_pton(AF_INET,localhost,&server_addr.sin_addr);
    //server_addr.sin_addr.s_addr=htonl(temp.s_addr);
    server_addr.sin_port=htons(listened_port);

    bind(listen_fd,(const sockaddr*)&server_addr,sizeof(server_addr));
    listen(listen_fd,listening_queue_length);
    char buffer[buffersize];
    while(1){
        sockaddr_in client_addr;
        socklen_t len=sizeof(client_addr);
        cout<<"wating for a connection..."<<endl;
        int connect_fd=accept(listen_fd,(sockaddr*)&client_addr,&len);
        cout<<"server get a client connect ;ip="<<inet_ntop(AF_INET,&client_addr.sin_addr,buffer,sizeof(buffer))
            <<" port="<<ntohs(client_addr.sin_port)<<endl;
        auto n=read(connect_fd,buffer,buffersize);
        buffer[n]='\0';
        cout<<"get id="<<buffer<<endl;
        slow_handle_function(std::stoi(buffer));
        write(connect_fd,buffer,strlen(buffer));
    }
}

服务器1是迭代的顺序处理函数，把id回射给客户端。

运行10个客户，每个发起5次请求，结果是：

pressure_test(10,5);

answer message(4):4
answer message(8):8
all task finish. used time=150.025 s

足足花了150s，其实挺好理解，每个处理花3s，一共3*10*5=150s;

 

2、以多进程为基础的服务器

void server2(){
    const uint16_t listened_port=9000;
    const char* localhost="127.0.0.1";
    const int listening_queue_length=1024;
    const int buffersize=1024;

    int listen_fd=socket(AF_INET,SOCK_STREAM,0);
    sockaddr_in server_addr;

    bzero(&server_addr,sizeof(server_addr));
    server_addr.sin_family=AF_INET;
    in_addr temp;
    inet_pton(AF_INET,localhost,&server_addr.sin_addr);
    //server_addr.sin_addr.s_addr=htonl(temp.s_addr);
    server_addr.sin_port=htons(listened_port);

    bind(listen_fd,(const sockaddr*)&server_addr,sizeof(server_addr));
    listen(listen_fd,listening_queue_length);
    char buffer[buffersize];

    pid_t pid;
    while(1){
        sockaddr_in client_addr;
        socklen_t len=sizeof(client_addr);
        cout<<"wating for a connection..."<<endl;
        int connect_fd=accept(listen_fd,(sockaddr*)&client_addr,&len);
        if((pid=fork())==0){
            close(listen_fd);
            auto n=read(connect_fd,buffer,buffersize);
            buffer[n]='\0';
            cout<<"get id="<<buffer<<endl;
            slow_handle_function(std::stoi(buffer));
            write(connect_fd,buffer,strlen(buffer));
            exit(0);
        }
        close(connect_fd);
    }
}

利用fork函数可以新建一个进程，fork的特点是调用一次返回2次，在父进程中返回新建的子进程pid，在子进程中返回0；

因此这个if里面的内容都是针对子进程的。

首先关闭listend_fd，是因为只需要主进程监听这个描述符就可以了，不需要子进程，但是由于子进程完全复制父进程的数据，所以，此时子进程首先就要关闭它，处理完后调用exit直接退出，在循环内，把刚才的connect_fd关闭，这个是针对父进程的，因为这个描述符不需要父进程来处理。

同样和上面一样的压力测试：

answer message(10):10
answer message(6):6
answer message(5):5
all task finish. used time=15.0138 s

结果只有15s，快了10倍！

 

三、使用线程

学过操作系统的人都知道，进程的创建/销毁代价很大，可能会严重影响性能。所以在现代的服务器中使用的都是“多线程”而不是“多进程”。

c++11标准可以使用thread类来构造一个线程处理每一个请求。

void task_handle(int fd){
    const int buffersize=1024;
    char buffer[buffersize];
    auto n=read(fd,buffer,buffersize);
    buffer[n]='\0';
    cout<<"get id="<<buffer<<endl;

    slow_handle_function(std::stoi(buffer));
    write(fd,buffer,strlen(buffer));
    close(fd);
}
void server3(){
    const uint16_t listened_port=9000;
    const char* localhost="127.0.0.1";
    const int listening_queue_length=1024;
    const int buffersize=1024;

    int listen_fd=socket(AF_INET,SOCK_STREAM,0);
    sockaddr_in server_addr;

    bzero(&server_addr,sizeof(server_addr));
    server_addr.sin_family=AF_INET;
    in_addr temp;
    inet_pton(AF_INET,localhost,&server_addr.sin_addr);
    //server_addr.sin_addr.s_addr=htonl(temp.s_addr);
    server_addr.sin_port=htons(listened_port);

    bind(listen_fd,(const sockaddr*)&server_addr,sizeof(server_addr));
    listen(listen_fd,listening_queue_length);

    while(1){
        sockaddr_in client_addr;
        socklen_t len=sizeof(client_addr);
        cout<<"wating for a connection..."<<endl;
        int connect_fd=accept(listen_fd,(sockaddr*)&client_addr,&len);
        thread t(task_handle,connect_fd);
        t.detach();

    }
}

这里面使用了thread类的里面的detach方法，可以在后台用线程处理任务。

任务封装到一个函数里面，并且这次由子线程关闭描述符，测试结果如下：

answer message(10):10
answer message(9):9
answer message(8):8
all task finish. used time=15.0064 s

如果说15s之外的时间是计算机处理线程或者进程的时间，那么，虽然不是很明显，但的确可以看见多线程快于多进程！