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的内容进行补充。

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

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