【网络编程】服务器模型（二）：并发服务器模型（多线程）和 I/O 复用服务器（select / epoll）

一、多线程并发服务器

在 高并发的 TCP 服务器 中，单线程或 fork() 多进程 方式会导致 资源浪费和性能瓶颈。因此，我们可以使用 多线程 来高效处理多个客户端的连接。

承接上文中的多进程并发服务器，代码优化目标：

1.使用 pthread 实现多线程服务器
2.每个客户端连接后，服务器创建一个独立线程进行处理
3.回显（Echo）客户端发送的消息
4.支持多个客户端同时连接
5.主线程负责监听连接，子线程负责处理客户端请求

完整代码：

#include <stdio.h> // 标准输入输出
#include <stdlib.h> // exit()、malloc()、free()
#include <string.h> // 字符串操作
#include <unistd.h> // read(), write(), close()
#include <arpa/inet.h> // sockaddr_in, inet_addr()
#include <sys/socket.h> // 套接字 API
#include <netinet/in.h> // sockaddr_in 结构体
#include <pthread.h> // 线程 API

#define PORT 8080 // 服务器监听端口
#define BUFFER_SIZE 1024 // 缓冲区大小
#define MAX_CLIENTS 100 // 最大客户端连接数

// **线程处理客户端请求**
void *handle_client(void *arg) {
int client_fd = *((int *)arg);
free(arg); // 释放动态分配的内存
char buffer[BUFFER_SIZE];
int bytes_read;

printf("✅ 客户端线程启动，处理客户端 %d\\n", client_fd);

while (1) {
memset(buffer, 0, BUFFER_SIZE); // 清空缓冲区
bytes_read = read(client_fd, buffer, BUFFER_SIZE);
if (bytes_read <= 0) {
printf("❌ 客户端 %d 断开连接\\n", client_fd);
break; // 退出循环，关闭连接
}

printf("📩 收到客户端 %d 消息: %s\\n", client_fd, buffer);

// **发送回显消息**
write(client_fd, buffer, bytes_read);
}

// **关闭客户端连接**
close(client_fd);
printf("关闭客户端 %d 连接\\n", client_fd);
return NULL;
}

int main() {
int server_fd, client_fd;
struct sockaddr_in server_addr, client_addr;
socklen_t addr_len = sizeof(client_addr);
pthread_t thread_id;

// 1️⃣ 创建服务器套接字
server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server_fd == –1) {
perror("❌ Socket 创建失败");
exit(EXIT_FAILURE);
}

// 2️⃣ 绑定服务器地址和端口
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(PORT);

if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("❌ 绑定失败");
close(server_fd);
exit(EXIT_FAILURE);
}

// 3️⃣ 监听客户端连接
if (listen(server_fd, MAX_CLIENTS) < 0) {
perror("❌ 监听失败");
close(server_fd);
exit(EXIT_FAILURE);
}

printf("⚡ 多线程 TCP 服务器已启动，监听端口 %d…\\n", PORT);

while (1) {
printf("\\n等待客户端连接…\\n");

// 4️⃣ 接受客户端连接
client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &addr_len);
if (client_fd < 0) {
perror("❌ 接受客户端连接失败");
continue; // 继续等待下一个客户端
}

printf("✅ 客户端连接成功！IP: %s, 端口: %d\\n",
inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

// 5️⃣ 创建线程处理客户端
int *new_sock = malloc(sizeof(int)); // 动态分配内存，避免线程冲突
*new_sock = client_fd;
if (pthread_create(&thread_id, NULL, handle_client, (void *)new_sock) != 0) {
perror("❌ 线程创建失败");
close(client_fd);
free(new_sock);
} else {
pthread_detach(thread_id); // 让线程自动回收
}
}

// 6️⃣ 关闭服务器（通常不会执行到这里）
close(server_fd);
return 0;
}

✅ 代码运行步骤

gcc tcp_server_threads.c -o tcp_server_threads -pthread

./tcp_server_threads

输出示例：

多线程 TCP 服务器已启动，监听端口 8080...
等待客户端连接...

✅ 连接测试

方式 1：使用 telnet

telnet 127.0.0.1 8080
# 输入消息后按 Enter，服务器会返回相同的消息。

方式 2：使用 nc（Netcat）

🔹 启动多个客户端

nc 127.0.0.1 8080

输入内容，服务器会回显，如：

Hello Server
Hello Server # 服务器返回相同内容

详细步骤流程：
1. 创建 TCP 套接字 — socket() — 创建服务器 socket
2. 绑定 IP 和端口 — bind() — 监听 8080 端口
3. 监听连接 — listen() — 允许最多 MAX_CLIENTS 个客户端排队
4. 等待客户端连接 — accept() — 接受一个客户端连接
5. 创建线程 — pthread_create() — 让每个客户端由一个线程处理
6. 处理客户端请求 — read() — 读取客户端发送的数据
7. 发送回显数据 — write() — 把数据发回客户端
8. 关闭连接 — close() — 释放资源

该代码是一个基本的 TCP 多线程并发服务器，适用于 中等并发负载， 相比 fork()，使用 pthread 可以减少资源消耗，提升并发性能。

后续代码可优化

1.使用线程池
线程池可以复用线程，避免 pthread_create() 过多消耗资源。
参考 pthread pool 机制，预创建固定数量线程，避免频繁创建销毁。
2.使用 epoll 结合线程池
结合 epoll 监听 accept()，减少 CPU 负担。
3.日志管理
服务器可以使用 syslog() 或文件写入方式记录 客户端连接信息。
4.超时处理
服务器可以设置 setsockopt() 限制客户端连接时间：

struct timeval timeout = {5, 0}; // 5 秒超时
setsockopt(client_fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));

二、I/O 复用服务器（select / poll）

在 UNIX/Linux 下主要有4种 I/O 模型：

阻塞I/O： 最常用、最简单、效率最低
非阻塞I/O：可防止进程阻塞在I/O操作上，需要轮询
I/O 多路复用：允许同时对多个I/O进行控制
信号驱动I/O: 一种异步通信模型

阻塞I/O 模式是最普遍使用的 I/O 模式，大部分程序使用的都是阻塞模式的 I/O ；缺省情况下，套接字建立后所处于的模式就是阻塞 I/O 模式。很多读写函数在调用过程中会发生阻塞，例如：读操作中的 read、recv、recvfrom，写操作中的 write、send，其他操作：accept、connect。

读阻塞：以 read 函数为例： 进程调用 read 函数从套接字上读取数据，当套接字的接收缓冲区中还没有数据可读，函数 read 将发生阻塞。它会一直阻塞下去，等待套接字的接收缓冲区中有数据可读。经过一段时间后，缓冲区内接收到数据，于是内核便去唤醒该进程，通过 read 访问这些数据。但如果在进程阻塞过程中，对方发生故障，那这个进程将永远阻塞下去。

写阻塞： 在写操作时发生阻塞的情况要比读操作少。主要发生在要写入的缓冲区的大小小于要写入的数据量的情况下。这时，写操作不进行任何拷贝工作，将发生阻塞。一旦发送缓冲区内有足够的空间，内核将唤醒进程，将数据从用户缓冲区中拷贝到相应的发送数据缓冲区。UDP不用等待确认，没有实际的发送缓冲区，所以UDP协议中不存在发送缓冲区满的情况，在UDP套接字上执行的写操作永远都不会阻塞。

非阻塞模式I/O： 当我们将一个套接字设置为非阻塞模式，我们相当于告诉了系统内核：“当我请求的I/O 操作不能够马上完成，你想让我的进程进行休眠等待的时候，不要这么做，请马上返回一个错误给我。”

当一个应用程序使用了非阻塞模式的套接字，它需要使用一个循环来不停地测试是否一个文件描述符有数据可读（称做polling）。 应用程序不停的 polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU 资源的操作。也正因如此，这种模式在使用中不普遍，太浪费资源了。

fcntl()函数
一开始建立一个套接字描述符的时候，系统内核将其设置为阻塞IO模式。
可以使用函数fcntl()设置一个套接字的标志为O_NONBLOCK 来实现非阻塞。
int fcntl(int fd, int cmd, long arg);
int flag；
flag = fcntl(sockfd, F_GETFL, 0);
flag |= O_NONBLOCK;
fcntl(sockfd, F_SETFL, flag);

多路复用I/O 应用程序中同时处理多路输入输出流，若采用阻塞模式，将得不到预期的目的。可是，若采用非阻塞模式，对多个输入进行轮询，但又太浪费CPU时间；若设置多个进程，分别处理一条数据通路，将新产生进程间的同步与通信问题，使程序变得更加复杂；比较好的方法是使用I/O多路复用。其基本思想是：

先构造一张有关描述符的表，然后调用一个函数。当这些文件描述符中的一个或多个已准备好进行 I/O时函数才返回。 函数返回时告诉进程那个描述符已就绪，可以进行I/O操作。

在 高并发的 TCP 服务器 中，传统的 fork() 多进程 或 pthread 多线程 方式容易导致 资源浪费和性能瓶颈。因此，我们才使用 I/O 复用技术（select / poll / epoll），使 单线程 就能监听 多个客户端连接，从而提高并发性能。

多路复用select/poll
/* According to POSIX.1-2001, POSIX.1-2008 */
#include <sys/select.h>

/* According to earlier standards */
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>

int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
/**********************************************************************
@brief: 多路复用，将所需要使用的或者需要关注的文件描述符放在一个集合中，当集合中的文件描述符
被触发了会去执行相应的任务

@nfds： 最大文件描述符 + 1

@readfds： 所有要读的文件文件描述符的集合

@writefds: 所有要的写文件文件描述符的集合

@exceptfds：其他要向我们通知的文件描述符

@timeout： 超时设置.
NULL：一直阻塞，直到有文件描述符就绪或出错
时间值为0：仅仅检测文件描述符集的状态，然后立即返回
时间值不为0：在指定时间内，如果没有事件发生，则超时返回。

struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};

@retval: 成功：返回就绪的文件描述符的个数
失败：返回-1，并且设置全局错误码

为了设置文件描述符我们要使用几个宏：
宏的形式:
void FD_ZERO(fd_set *fdset) //从fdset中清除所有的文件描述符
void FD_SET(int fd,fd_set *fdset) //将fd加入到fdset
void FD_CLR(int fd,fd_set *fdset) //将fd从fdset里面清除
int FD_ISSET(int fd,fd_set *fdset) //判断fd是否在fdset集合中
**********************************************************************/

#include <poll.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout);
/**********************************************************************
@brief: 多路复用，监管文件描述符

@fds： 要监管的文件描述符的结构体指针

struct pollfd {
int fd; /* file descriptor 希望被触发的文件描述符 用户赋值*/
short events; /* requested events 希望被触发的事件POLLIN 用户赋值*/
short revents; /* returned events 希望被触发的事件发生与否POLLIN 系统赋值*/
};

The bits that may be set/returned in events and revents are defined in <poll.h>:
//可在man手册中查询别的events和revents的选值
POLLIN There is data to read.

POLLPRI
There is some exceptional condition on the file descriptor. Possibilities
include:

* There is out-of-band data on a TCP socket (see tcp(7)).

* A pseudoterminal master in packet mode has seen a state change on the
slave (see ioctl_tty(2)).

* A cgroup.events file has been modified (see cgroups(7)).

POLLOUT
Writing is now possible, though a write larger that the available space in a
socket or pipe will still block (unless O_NONBLOCK is set).

/**
@nfds： 最大文件描述符 + 1

@timeout: >0:阻塞对应的时间(毫秒级)
=0：不阻塞
<0:一直阻塞

@retval: >0：集合中已就绪的文件描述符个数
=0：集合中没有已就绪的文件描述符
-1：poll调用失败，并且设置全局错误码
**********************************************************************/

📌 I/O 复用的三种方式

select() 多路复用服务器

代码实现：

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

#define PORT 8080
#define MAX_CLIENTS 100
#define BUFFER_SIZE 1024

int main() {
int server_fd, client_fd, max_fd, activity, i;
struct sockaddr_in server_addr, client_addr;
socklen_t addr_len = sizeof(client_addr);
char buffer[BUFFER_SIZE];
fd_set read_fds, master_fds;

// 1️⃣ 创建 TCP 套接字
server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server_fd == –1) {
perror("❌ Socket 创建失败");
exit(EXIT_FAILURE);
}

// 2️⃣ 绑定服务器地址和端口
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(PORT);
if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("❌ 绑定失败");
close(server_fd);
exit(EXIT_FAILURE);
}

// 3️⃣ 监听客户端连接
if (listen(server_fd, MAX_CLIENTS) < 0) {
perror("❌ 监听失败");
close(server_fd);
exit(EXIT_FAILURE);
}

printf("`select()` 多路复用服务器已启动，监听端口 %d…\\n", PORT);

// 4️⃣ 初始化 `select` 的文件描述符集合
FD_ZERO(&master_fds);
FD_SET(server_fd, &master_fds);
max_fd = server_fd;

while (1) {
read_fds = master_fds; // 每次循环都复制 `master_fds`

// 5️⃣ 监听多个文件描述符 `select`
activity = select(max_fd + 1, &read_fds, NULL, NULL, NULL);
if (activity < 0) {
perror("❌ `select` 调用失败");
continue;
}

// 6️⃣ 处理新客户端连接
if (FD_ISSET(server_fd, &read_fds)) {
client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &addr_len);
if (client_fd < 0) {
perror("❌ 客户端连接失败");
continue;
}

printf("新客户端连接：%s:%d\\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

FD_SET(client_fd, &master_fds);
if (client_fd > max_fd) {
max_fd = client_fd;
}
}

// 7️⃣ 处理已连接的客户端数据
for (i = server_fd + 1; i <= max_fd; i++) {
if (FD_ISSET(i, &read_fds)) {
memset(buffer, 0, BUFFER_SIZE);
int bytes_read = read(i, buffer, BUFFER_SIZE);
if (bytes_read <= 0) {
printf("❌ 客户端断开连接\\n");
close(i);
FD_CLR(i, &master_fds);
} else {
printf("📩 客户端消息: %s\\n", buffer);
write(i, buffer, bytes_read); // 回显
}
}
}
}

close(server_fd);
return 0;
}

poll() 多路复用服务器

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

#define PORT 8080
#define MAX_CLIENTS 100
#define BUFFER_SIZE 1024

int main() {
int server_fd, client_fd, i;
struct sockaddr_in server_addr, client_addr;
socklen_t addr_len = sizeof(client_addr);
char buffer[BUFFER_SIZE];

struct pollfd fds[MAX_CLIENTS];
int nfds = 1;

// 1️⃣ 创建 TCP 套接字
server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server_fd == –1) {
perror("❌ Socket 创建失败");
exit(EXIT_FAILURE);
}

// 2️⃣ 绑定服务器地址和端口
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(PORT);
if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("❌ 绑定失败");
close(server_fd);
exit(EXIT_FAILURE);
}

// 3️⃣ 监听客户端连接
if (listen(server_fd, MAX_CLIENTS) < 0) {
perror("❌ 监听失败");
close(server_fd);
exit(EXIT_FAILURE);
}

printf("`poll()` 多路复用服务器已启动，监听端口 %d…\\n", PORT);

fds[0].fd = server_fd;
fds[0].events = POLLIN;

while (1) {
// 4️⃣ 监听多个文件描述符 `poll`
int activity = poll(fds, nfds, –1);
if (activity < 0) {
perror("❌ `poll` 调用失败");
continue;
}

// 5️⃣ 处理新客户端连接
if (fds[0].revents & POLLIN) {
client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &addr_len);
if (client_fd < 0) {
perror("❌ 客户端连接失败");
continue;
}
printf("新客户端连接：%s:%d\\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

fds[nfds].fd = client_fd;
fds[nfds].events = POLLIN;
nfds++;
}

// 6️⃣ 处理已连接的客户端数据
for (i = 1; i < nfds; i++) {
if (fds[i].revents & POLLIN) {
memset(buffer, 0, BUFFER_SIZE);
int bytes_read = read(fds[i].fd, buffer, BUFFER_SIZE);
if (bytes_read <= 0) {
printf("❌ 客户端断开连接\\n");
close(fds[i].fd);
fds[i] = fds[nfds – 1]; // 移除断开的客户端
nfds—;
} else {
printf("📩 客户端消息: %s\\n", buffer);
write(fds[i].fd, buffer, bytes_read); // 回显
}
}
}
}

close(server_fd);
return 0;
}

使用 epoll 的高并发服务器（C 语言）

select() 和 poll() 适用于 1000 以内的连接，但随着连接数增加，性能下降。对于高并发服务器，建议使用 epoll()（Linux） 或 kqueue()（BSD/macOS）。

epoll 是 Linux 下 高效的 I/O 复用方式，相比 select() 和 poll()，它支持：

• O(1) 事件触发：只处理活跃的文件描述符，不用遍历整个 fd_set。
• 支持大规模并发：适用于 上万级别的连接，比 select() / poll() 性能高很多。
• Edge Trigger (ET) & Level Trigger (LT)：支持 边缘触发 和 水平触发，进一步优化性能。

epoll 关键 API

函数功能
epoll_create1(0)创建 epoll 实例，返回 epoll_fd
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &event)添加监听的 fd
epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fd, &event)修改监听的 fd
epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, &event)删除监听的 fd
epoll_wait(epoll_fd, events, MAX_EVENTS, timeout)等待事件触发

epoll 多路复用服务器（代码实现）（重点）

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

#define PORT 8080 // 服务器监听端口
#define MAX_EVENTS 1000 // epoll 最大监听事件数
#define BUFFER_SIZE 1024 // 缓冲区大小

// **🔹 设置 fd 为非阻塞模式**
void set_nonblocking(int fd) {
int flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);
}

int main() {
int server_fd, client_fd, epoll_fd, event_count, i;
struct sockaddr_in server_addr, client_addr;
socklen_t addr_len = sizeof(client_addr);
struct epoll_event event, events[MAX_EVENTS];
char buffer[BUFFER_SIZE];

// 1️⃣ 创建 TCP 套接字
server_fd = socket(AF_INET, SOCK_STREAM, 0);
if (server_fd == –1) {
perror("❌ Socket 创建失败");
exit(EXIT_FAILURE);
}

// 2️⃣ 绑定服务器地址和端口
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(PORT);
if (bind(server_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
perror("❌ 绑定失败");
close(server_fd);
exit(EXIT_FAILURE);
}

// 3️⃣ 开始监听
if (listen(server_fd, MAX_EVENTS) < 0) {
perror("❌ 监听失败");
close(server_fd);
exit(EXIT_FAILURE);
}
printf("⚡ `epoll` 服务器启动，监听端口 %d…\\n", PORT);

// 4️⃣ 创建 epoll 实例
epoll_fd = epoll_create1(0);
if (epoll_fd == –1) {
perror("❌ epoll_create1 失败");
close(server_fd);
exit(EXIT_FAILURE);
}

// 5️⃣ 设置 server_fd 为非阻塞模式，并添加到 epoll 监听
set_nonblocking(server_fd);
event.events = EPOLLIN; // 监听可读事件（LT 模式）
event.data.fd = server_fd;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &event);

while (1) {
// 6️⃣ 等待事件触发
event_count = epoll_wait(epoll_fd, events, MAX_EVENTS, –1);
for (i = 0; i < event_count; i++) {
if (events[i].data.fd == server_fd) {
// 7️⃣ 处理新客户端连接
client_fd = accept(server_fd, (struct sockaddr *)&client_addr, &addr_len);
if (client_fd < 0) {
perror("❌ 接受客户端连接失败");
continue;
}
printf("✅ 新客户端连接：%s:%d\\n", inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

set_nonblocking(client_fd); // 设置非阻塞模式
event.events = EPOLLIN | EPOLLET; // 监听可读事件，ET 模式
event.data.fd = client_fd;
epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event);
} else {
// 8️⃣ 处理客户端数据
int client_fd = events[i].data.fd;
memset(buffer, 0, BUFFER_SIZE);
int bytes_read = read(client_fd, buffer, BUFFER_SIZE);
if (bytes_read <= 0) {
printf("❌ 客户端断开连接\\n");
epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, NULL);
close(client_fd);
} else {
printf("📩 客户端消息: %s\\n", buffer);
write(client_fd, buffer, bytes_read); // 回显
}
}
}
}

close(server_fd);
close(epoll_fd);
return 0;
}

✅ 代码运行步骤

gcc epoll_server.c -o epoll_server

./epoll_server

输出示例：

`epoll` 服务器启动，监听端口 8080...

✅ 连接测试

📌 使用 nc（Netcat）

nc 127.0.0.1 8080

输入内容，服务器会回显，如：

Hello Server
Hello Server # 服务器返回相同内容

epoll 工作模式

🔹 水平触发（LT，Level Trigger）

• 默认模式，事件未处理时会 持续触发。
• 适用于阻塞 I/O，确保数据不会丢失。

🔹 边缘触发（ET，Edge Trigger）

• 仅在状态变化时触发，不会重复触发。
• 必须使用非阻塞 I/O，否则可能丢失数据。

✅ epoll vs select / poll

代码可优化

使用线程池
epoll_wait() 只负责监听，线程池 处理数据，提高吞吐量。
使用 EPOLLET（边缘触发）
结合 非阻塞 read()，减少 epoll_wait() 触发次数，提高效率。
TCP SO_REUSEADDR
避免服务器重启时 bind() 失败：

int opt = 1;
setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

该代码是一个高效的 TCP 并发服务器，使用 epoll 事件驱动，适用于大规模连接。 相比 select()，epoll 在高并发情况下性能更好，是 Linux 服务器的首选方案！ 🎯

以上。仅供学习与分享交流，请勿用于商业用途！转载需提前说明。

我是一个十分热爱技术的程序员，希望这篇文章能够对您有帮助，也希望认识更多热爱程序开发的小伙伴。 感谢！