Linux网络编程 TCP---并发服务器：多进程架构与端口复用技术实战指南

知识点1【并发服务器—多进程版】

并发服务器：服务器可以同时服务多个客户端

首先复习一下服务器的创建过程（如下图）

1、监听套接字（套接字→绑定→监听（连接队列））

2、利用accept从连接队列的已连接区（完成三次握手）将客户端提取出来，此时产生 已连接套接字

现在我们结合多进程，完成的功能是父进程负责监听，而每个子进程都只负责管理一个客户端

因此，子父进程中 不能有已连接套接字，而子进程中不能有监听套接字。让我们先实现以下这个代码！

这里说一下，并发服务器就是这样的流程，如果暂时理解不了，请先背下来。

代码演示

#include <stdio.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <sys/socket.h>
#include <string.h>
#include <sys/types.h> //listen
#include <errno.h>
#include <signal.h> //signal
#include <sys/wait.h> //waitpid
#include <unistd.h>
#include <stdlib.h> //atoi

//主进程释放子进程空间函数声明
void my_waitpid(int signal);

//子进程中函数体的声明
void fun_subprocess(int fd_sock_accept);

int main(int argc, char const *argv[])
{
    //指令参数个数判断
    if(argc != 2)
    {
        printf("demo:./a.out num_of_port");
        return 0;
    }
    
    //创建（监听）套接字，非法判断
    int fd_sock_listen = socket(AF_INET,SOCK_STREAM,0);
    if(fd_sock_listen < 0)
    {
        printf("socket");
        _exit(-1);
    }

    //绑定并非法判断：先创建地址结构体，然后绑定套接字，这里我们设置端口号为8000.
    struct sockaddr_in addr_bind;
    addr_bind.sin_family = AF_INET;
    addr_bind.sin_port = htons(atoi(argv[1]));
    addr_bind.sin_addr.s_addr = htonl(INADDR_ANY);
    int ret_bind = bind(fd_sock_listen,(struct sockaddr *)&addr_bind,sizeof(addr_bind));
    if(ret_bind != 0)
    {
        perror("bind");
        _exit(-1);
    }

    //监听，将套接字设为监听套接字，并连接队列 的大小设置为10
    int ret_listen = listen(fd_sock_listen,10);
    if(ret_listen != 0)
    {
        perror("listen");
        _exit(-1);
    }

    //循环中 先accept，在创建子进程：先accpet可以让每个子进程都可以得到一个已连接套接字
    //又因为accept是带阻塞的，不必担心，子进程的多创建问题
    while(1)
    {
        //accept 从 已连接队列中提取已连接套接字：监听套接字
        //这里的地址结构体，是用来存储 客户端的地址信息
        struct sockaddr_in addr_accept;
        bzero(&addr_accept,sizeof(addr_accept));
        int len_accept = sizeof(addr_accept);
        int fd_sock_accpet = accept(fd_sock_listen,(struct sockaddr *)&addr_accept,&len_accept);
        if(fd_sock_accpet < 0)
        {
            if((errno == ECONNABORTED) || (errno == EINTR))
            {
                continue;
            }
            else
            {
                perror("accept");
                close(fd_sock_listen);
                _exit(-1);
            }
        }
        //这里客户端与服务器连接成功，遍历一条消息说明是 客户端的IP和端口号
        unsigned short port = ntohs(addr_accept.sin_port);
        char buf_IP[16] = "";
        inet_ntop(AF_INET,&addr_accept.sin_addr.s_addr,buf_IP,sizeof(buf_IP));

        //创建子进程，每个子进程中需要关闭
        int pid = fork();
        if(pid == 0)//子进程，关闭监听套接字-->执行任务体-->关闭已连接套接字-->退出子进程
        {
            //遍历处 客户端连接的子进程
            printf("客户端IP：%s，端口号：%hu已连接，为其分配的进程ID是：%d\\n",buf_IP,port,getpid());

            //执行监听套接字
            close(fd_sock_listen);

            //执行任务体，要实现1、数据的接收，并遍历在服务器的终端，2、将收到的数据返回客户端
            fun_subprocess(fd_sock_accpet);
            
            //关闭已连接套接字
            close(fd_sock_accpet);
            
            //退出子进程
            _exit(0);
        }
        else//父进程，关闭已连接套接字
        {
            close(fd_sock_accpet);

            //父进程，负责处理回收进程空间，这里回收空间我们采用 等待信号SIGCHLD的方式
            signal(SIGCHLD,my_waitpid);
        }
    }
    close(fd_sock_listen);
    return 0;
}

//主进程释放子进程空间函数实现
void my_waitpid(int signal)
{
    while(1)
    {
        int ret = waitpid(-1,NULL,WNOHANG);
        if(ret == 0 || ret == -1)
        {
            //子进程空间被释放退出
            break;
        }
        else if(ret > 0)
        {
            printf("子进程%d已经退出\\n",ret);
        }
        //注意这里一定不要等待全部进程退出，即只判断返回值是-1的情况，会循环堵塞的，应该是检测到一个释放就退出一次
        //因为这里我们是信号检测，一旦有子进程退出的信号就会进入这个函数一次
        //这是调试过程中发现的问题
    }
    return;
}

//子进程中函数体的实现,实现1、数据的接收，并遍历在服务器的终端，2、将收到的数据返回客户端
void fun_subprocess(int fd_sock_accept)
{
    while(1)
    {
        //1500最安全，因为以太网的最大传输单元（MTU）是1500Byte
        char buf_recv[1500] = "";
        int len = recv(fd_sock_accept,buf_recv,sizeof(buf_recv),0);
        printf("%s\\n",buf_recv);
        //TCP（传输控制协议），是当收到内容长度为0的时候，先输出内容，然后服务器会退出
        if(len == 0)
        {
            break;
        }
        send(fd_sock_accept,buf_recv,sizeof(buf_recv),0);
    }
}

代码运行结果

我们这个客户端设计的功能流畅度 是很完善的，并发服务器就是这样，套模板就可以，希望大家在理解的基础上记忆，备注很详细，如果仍有疑问可以私信或者评论留言，我看到了会回复讨论。

知识点2【端口复用】

这里我们演示一个现象，服务器主动断开后，会有一段时间服务器无法使用，是为什么呢？因为 端口仍与 上一个服务器的套接字 之间有联系（客户端的TIME_WAIT状态）。

此时的端口只能绑定一个套接字

1、问题现象演示

为了解决服务器重启后，地址被占用，导致客户端需要等待的问题，我们就要引入端口复用

2、端口复用的概述

端口复用：允许在一个应用程序 可以把n个套接字绑定在一个端口上而不出错

方法：利用setsockopt 函数与 SO_REUSEADDR 实现

这个函数在UDP的多播和广播中也有使用，后面我会对UDP的内容进行补充。

注意：置端口复用函数要在绑定之前调用，而且只要绑定在同一个端口的所有套接字都得设置复用

目的：能够保证服务器重启后，能够立马运行，其他客户端无需等待。

3、端口复用的实现

端口复用的模式是固定的，主要记忆，端口复用的实现方法，与端口复用的位置

实现方法：

    //端口复用的实现
    int opt = 1;
    setsockopt(fd_sock_listen,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));

位置：

在创建套接字之后，绑定套接字之前

代码演示

代码运行结果

可见服务器重启，无需等待。

建议

只要是服务器的创建都加上端口复用的功能

结束

代码重在练习！

代码重在练习！

代码重在练习！

今天的分享就到此结束了，希望对你有所帮助，如果你喜欢我的分享，请点赞收藏夹关注，谢谢大家！！！