企业官网建设流程全解析

1. 这不是玩具项目，是理解网络本质的“手术刀”

你看到“C语言手写HTTPD网站服务器”这个标题，第一反应可能是：又一个教学Demo？跑个hello world就完事？我干这行十多年，从嵌入式驱动写到云原生网关，亲手撸过不下二十个不同层级的网络服务——从单线程阻塞式echo server，到支持epoll+多线程的轻量级反向代理，再到基于DPDK的用户态HTTP加速器。但每次带新人，我一定让他们先用纯C、不依赖任何框架、不调用libcurl或libevent，从socket()开始，一行行敲出一个能返回静态HTML、解析GET请求、处理404、设置Content-Type头的最小可运行HTTPD。为什么？因为只有亲手把TCP三次握手、HTTP状态行、报文边界、缓冲区管理、文件I/O阻塞点、信号处理这些“看不见的齿轮”全部暴露在代码里，你才真正明白浏览器地址栏敲下回车后，背后到底发生了什么。这不是炫技，而是建立底层直觉的必经之路。核心关键词——C语言、HTTPD、服务器、网络编程、套接字——每一个都不是孤立概念：C语言提供对内存和系统调用的绝对控制权；HTTPD是协议落地的具象载体；服务器是角色定位；网络编程是方法论；套接字（socket）则是操作系统留给应用层的唯一“网线接口”。它不抽象，就是一块内存缓冲区、一个文件描述符、一组内核状态机。我见过太多人学完《UNIX网络编程》前五章，却连一个能稳定处理并发连接的accept()循环都写不稳，问题不在书，而在没把理论压进指关节——而这个项目，就是那块磨刀石。适合谁？刚学完C指针和结构体、正在啃《APUE》或《UNP》的学生；想摆脱Python/Node.js黑盒、搞懂Nginx为何用epoll不用select的中级开发者；还有那些被K8s Operator、Service Mesh概念绕晕，需要回归TCP/IP栈找锚点的架构师。它不教你如何部署高可用集群，但它让你清楚知道，那个“集群”里的每一台机器，其最底层心跳，都始于一个bind()调用。

2. 整体设计思路：拒绝“伪简化”，直面真实约束

2.1 为什么必须用C，而不是Go/Python/Rust？

有人会问：Python几行就能起个HTTP服务，Node.js自带http模块，Rust有hyper，干嘛非得用C？答案很实在：控制粒度。Python的http.server模块内部封装了完整的线程池、缓冲区管理、超时机制，你调用serve_forever()时，根本看不到accept()失败后errno=EMFILE（打开文件数超限）该怎么优雅降级；Node.js的EventEmitter隐藏了epoll_wait()返回后如何批量处理就绪fd的细节；Rust的Tokio runtime更是把异步调度、waker唤醒、poll轮询全包圆了。而C语言，你写listen(sockfd, SOMAXCONN)，就得自己处理SOMAXCONN在不同内核版本下的实际生效值（Linux 5.4+默认128，旧版可能64）；你调用read(connfd, buf, sizeof(buf)-1)，就必须面对EAGAIN（非阻塞模式下无数据）、EINTR（被信号中断）、0（对端关闭）这三种截然不同的返回码，且每一种都要求不同的后续动作。这种“麻烦”，恰恰是理解网络服务健壮性根源的入口。我当年在做车载T-Box固件时，因忽略EINTR重试逻辑，导致车辆震动触发SIGALRM后HTTP请求永久挂起——这个坑，只在C里能踩得如此真切。

2.2 HTTPD功能范围：最小可行，但绝不偷工减料

本项目定义的“HTTPD”能力边界非常明确：

• 必须支持：HTTP/1.1 GET方法、标准状态码（200 OK / 404 Not Found / 400 Bad Request / 500 Internal Server Error）、MIME类型自动识别（基于文件后缀）、静态文件服务（读取磁盘HTML/CSS/JS/PNG等）、正确设置Content-Length和Content-Type响应头、处理URL编码（如%20转空格）、支持Connection: close（简化版，暂不实现keep-alive）。
• 明确不支持：POST/PUT/DELETE方法、HTTPS/SSL/TLS加密（这是另一个重量级项目）、动态内容生成（CGI/PHP）、目录列表、HTTP/2、WebSocket、认证授权。
  这个边界不是为了偷懒，而是为了聚焦。比如Content-Length，很多初学者直接write(connfd, "HTTP/1.1 200 OK\r\n...", n)，却忘了计算实际响应体长度。而真实场景中，若文件很大（如10MB视频），你不可能一次性读入内存再发，必须边读边发，此时Content-Length要么提前stat()获取文件大小（有竞态风险），要么用分块传输编码（Chunked Encoding）——后者复杂度陡增。我们选择前者，并在代码中加入stat()失败的fallback处理（返回500），这就是在教你怎么应对真实世界的不确定性。

2.3 架构选型：单线程阻塞式，但预留扩展接口

当前实现采用单线程阻塞式I/O模型，即主线程循环执行accept()→read()→parse()→serve_file()→write()→close()。这看似“落后”，实则极具教学价值：

• 它让整个请求生命周期完全线性可见，没有回调地狱，没有协程调度，没有事件循环混淆视线；
• 所有资源（socket fd、buffer内存）的申请与释放时机一目了然，便于调试内存泄漏；
• 它天然暴露性能瓶颈：当第2个客户端连接上来时，第1个请求还没处理完，新连接会被accept()阻塞住——这正是你理解listen()backlog参数、SO_REUSEADDR选项、以及为何需要多进程/多线程/IO复用的起点。
  我们在代码结构上已为未来升级埋下伏笔：所有网络I/O操作都封装在net_io.c中，HTTP解析逻辑独立于http_parser.c，文件服务逻辑在file_server.c。这意味着，当你某天想用fork()实现多进程模型，只需修改main.c中的循环，调用fork()创建子进程处理connfd，主进程继续accept()；想切到epoll，只需重写net_io.c中的wait_for_events()函数，其余模块完全不动。这种“解耦不是为炫技，而是为让每一次技术演进都成为一次可控的增量实验。

3. 核心细节解析：从socket()到HTTP响应头的每一步

3.1 套接字创建与绑定：不只是socket()和bind()

创建一个监听套接字，远不止两行代码。以下是关键细节及实操要点：

int sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) { perror("socket"); exit(EXIT_FAILURE); }

• AF_INET指定IPv4地址族，SOCK_STREAM表示TCP流式服务（非UDP的SOCK_DGRAM）。这里必须明确，不能写AF_UNSPEC——虽然更通用，但会增加getaddrinfo()调用复杂度，偏离本项目“直击核心”的目标。
• 第三个参数0代表使用默认协议（TCP），显式写成IPPROTO_TCP更清晰，但0是POSIX标准允许的简写。

绑定前的关键设置：

int optval = 1; setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)); // 必须在bind()之前调用！否则无效 struct sockaddr_in serv_addr = {0}; serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; // 监听所有网卡 serv_addr.sin_port = htons(8080); // 端口8080，需htons()转网络字节序 if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) { perror("bind"); close(sockfd); exit(EXIT_FAILURE); }

• SO_REUSEADDR是救命稻草。若上次程序崩溃未正常close()，端口会处于TIME_WAIT状态（默认2MSL，约4分钟），bind()会失败。此选项允许立即重用该端口。注意：它不解决Address already in use的根本原因（如端口被其他进程占用），只是绕过TIME_WAIT限制。
• INADDR_ANY（即0.0.0.0）表示监听本机所有IPv4地址。若只想监听localhost，应改为inet_addr("127.0.0.1")。
• htons()（host to network short）不可省略。x86是小端序，网络字节序是大端序，端口号12345在内存中存储为0x3039，但网络传输要求高位字节在前，htons()确保正确转换。我曾因忘记此调用，在ARM设备上调试半天才发现端口始终是错的。

3.2 listen()与backlog：理解连接队列的物理存在

if (listen(sockfd, SOMAXCONN) < 0) { perror("listen"); close(sockfd); exit(EXIT_FAILURE); }

• SOMAXCONN不是魔法数字，它是内核参数net.core.somaxconn的用户态别名（Linux默认128）。它定义了已完成连接队列（completed connection queue）的最大长度。当客户端完成三次握手，内核将该连接放入此队列，等待你的accept()取走。若队列满，后续SYN包会被内核丢弃（客户端收到RST），表现为连接超时。
• 实际有效值受/proc/sys/net/core/somaxconn限制。可通过sysctl -w net.core.somaxconn=1024临时提升。生产环境常设为1024或更高。
• 注意：还有一个未完成连接队列（incomplete connection queue），由net.ipv4.tcp_max_syn_backlog控制，存放半连接（SYN_RCVD状态）。两者共同构成TCP连接接纳能力。本项目虽不深挖，但必须知道listen()的第二个参数只管“已完成”队列。

3.3 accept()的阻塞与信号安全：一个常被忽视的陷阱

while (1) { struct sockaddr_in cli_addr = {0}; socklen_t cli_len = sizeof(cli_addr); int connfd = accept(sockfd, (struct sockaddr*)&cli_addr, &cli_len); if (connfd < 0) { if (errno == EINTR) { // 被信号中断，重新accept continue; } perror("accept"); break; } // 处理connfd... }

• accept()默认阻塞，直到有新连接到达。这是单线程模型的基础。
• EINTR错误码是重点。当进程收到信号（如SIGCHLD、SIGUSR1），accept()可能被中断并返回-1，errno=EINTR。若不检查，程序会直接退出循环，服务终止。必须循环重试。
• 更安全的做法是使用siginterrupt()禁用信号中断系统调用，但本项目选择显式处理EINTR，因为它强制你直面信号与I/O的交互本质——这正是C系统编程的核心挑战之一。

3.4 HTTP请求解析：手动拆解，拒绝正则

HTTP请求是文本协议，但绝非简单strstr()就能搞定。一个典型GET请求：

GET /index.html HTTP/1.1\r\n Host: localhost:8080\r\n User-Agent: curl/7.68.0\r\n Accept: */*\r\n \r\n

解析步骤必须严谨：

1. 读取一行：用readline()（自实现，避免fgets()依赖stdio缓冲）逐行读取，直到遇到\r\n\r\n（空行）标识头部结束。
2. 首行拆解：sscanf(request_line, "GET %[^ ] HTTP/%*d.%*d", path)提取路径。%[^ ]匹配非空格字符，%*d跳过数字（忽略HTTP版本号）。
3. URL解码：路径中%20需转为空格，%41转为A。需遍历字符串，遇%则取后两位十六进制字符，strtol(hex_str, NULL, 16)转换。
4. 安全校验：检查路径是否含../（路径遍历攻击）。标准做法是realpath()规范化路径，但本项目为简化，采用字符串扫描：若strstr(path, "..")且..不在路径开头（如/..），则拒绝。
5. MIME类型映射：建一个哈希表或数组，如.html→"text/html"，.css→"text/css"，.png→"image/png"。注意：.jpg和.jpeg需同时支持。

提示：不要用strtok()解析HTTP头！它会破坏原始字符串，且无法处理重复头字段（如多个Set-Cookie）。应使用strchr()定位冒号，strspn()跳过空白，strcspn()提取值。

3.5 文件服务与响应构造：Content-Length的精确计算

服务静态文件时，Content-Length必须精确。错误做法：write(connfd, "HTTP/1.1 200 OK\r\n...", 200)硬编码长度。正确流程：

struct stat st; if (stat(filepath, &st) < 0) { send_error_response(connfd, 404); return; } off_t file_size = st.st_size; char header[1024]; snprintf(header, sizeof(header), "HTTP/1.1 200 OK\r\n" "Content-Type: %s\r\n" "Content-Length: %ld\r\n" "Connection: close\r\n" "\r\n", mime_type, (long)file_size); write(connfd, header, strlen(header)); // 边读边发，避免大文件占满内存 int fd = open(filepath, O_RDONLY); if (fd < 0) { send_error_response(connfd, 500); return; } char buf[8192]; ssize_t n; while ((n = read(fd, buf, sizeof(buf))) > 0) { write(connfd, buf, n); } close(fd);

• stat()获取文件大小，用于Content-Length。若文件被并发修改（size变小），read()可能返回少于n字节，但HTTP协议允许Content-Length与实际发送字节数不一致（客户端以\r\n\r\n后字节为准），故此处安全。
• snprintf()比sprintf()安全，防止缓冲区溢出。sizeof(header)确保不越界。
• O_RDONLY标志明确，比open()默认模式更清晰。
• 使用固定大小缓冲区（8KB）读取，平衡I/O效率与内存占用。实测8KB在大多数SSD上达到最佳吞吐。

4. 实操过程：从零开始构建可运行的HTTPD

4.1 环境准备与编译脚本

本项目在Linux（Ubuntu 22.04 / CentOS 7）下开发，需基础工具链：

• gcc（>=7.5，支持C11标准）
• make
• curl（测试用）
• netstat或ss（查看端口）

项目目录结构：

httpd/ ├── src/ │ ├── main.c # 主循环 │ ├── net_io.c # socket创建、accept、read/write封装 │ ├── http_parser.c # 请求解析、URL解码、路径校验 │ ├── file_server.c # MIME映射、文件读取、响应构造 │ └── utils.c # 字符串工具、日志打印 ├── www/ # 静态文件根目录（放index.html） ├── Makefile └── README.md

Makefile内容（关键部分）：

CC = gcc CFLAGS = -std=c11 -Wall -Wextra -O2 -g LDFLAGS = -lcrypto # 后续扩展HTTPS时用，当前可注释 TARGET = httpd SRCS = $(wildcard src/*.c) OBJS = $(SRCS:.c=.o) $(TARGET): $(OBJS) $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) %.o: %.c $(CC) $(CFLAGS) -c -o $@ $< clean: rm -f $(TARGET) $(OBJS) .PHONY: clean

• -std=c11启用现代C标准，支持_Generic等特性（虽本项目未用，但为扩展留余地）。
• -Wall -Wextra开启全部警告，-O2优化性能，-g保留调试信息。
• $(wildcard src/*.c)自动收集源文件，避免手动维护SRCS列表。

4.2 核心文件详解：main.c与net_io.c

src/main.c是程序入口：

#include "net_io.h" #include "http_parser.h" #include "file_server.h" #define PORT 8080 #define WWW_ROOT "./www" int main(int argc, char *argv[]) { int listenfd = create_listen_socket(PORT); printf("HTTPD listening on port %d...\n", PORT); while (1) { int connfd = accept_connection(listenfd); if (connfd < 0) continue; // EINTR handled in accept_connection // 处理单个请求（阻塞式） handle_http_request(connfd, WWW_ROOT); close(connfd); // 关闭连接 } close(listenfd); return 0; }

• create_listen_socket()封装了socket()/setsockopt()/bind()/listen()全过程，隐藏细节，突出主逻辑。
• accept_connection()内部处理EINTR，返回connfd或-1。
• handle_http_request()是核心业务函数，调用解析、文件服务等模块。

src/net_io.c关键函数：

#include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <unistd.h> #include <errno.h> #include <stdio.h> int create_listen_socket(int port) { int sockfd = socket(AF_INET, SOCK_STREAM, 0); if (sockfd < 0) { perror("socket"); return -1; } int optval = 1; if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0) { perror("setsockopt SO_REUSEADDR"); close(sockfd); return -1; } struct sockaddr_in serv_addr = {0}; serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = INADDR_ANY; serv_addr.sin_port = htons(port); if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) { perror("bind"); close(sockfd); return -1; } if (listen(sockfd, SOMAXCONN) < 0) { perror("listen"); close(sockfd); return -1; } return sockfd; } int accept_connection(int listenfd) { struct sockaddr_in cli_addr = {0}; socklen_t cli_len = sizeof(cli_addr); int connfd; while (1) { connfd = accept(listenfd, (struct sockaddr*)&cli_addr, &cli_len); if (connfd >= 0) { return connfd; } if (errno != EINTR) { perror("accept"); return -1; } // EINTR: 被信号中断，重试 } }

• 每个错误分支都close(sockfd)，防止fd泄露。这是C网络编程铁律：任何socket()成功后的失败路径，都必须清理已分配资源。
• accept_connection()的while(1)循环确保EINTR被静默处理，上层无需关心。

4.3 HTTP解析实战：http_parser.c的健壮性设计

src/http_parser.c包含parse_http_request()函数：

#include <string.h> #include <stdlib.h> #include <stdio.h> #include "utils.h" #define MAX_HEADER_SIZE 4096 #define MAX_PATH_LEN 1024 typedef struct { char method[16]; char path[MAX_PATH_LEN]; char version[16]; char host[256]; } http_request_t; int parse_http_request(int connfd, http_request_t *req) { char buf[MAX_HEADER_SIZE] = {0}; ssize_t n = readline(connfd, buf, sizeof(buf)-1); if (n <= 0) return -1; // 连接关闭或错误 // 解析首行：GET /path HTTP/1.1 if (sscanf(buf, "%15s %1023s %15s", req->method, req->path, req->version) != 3) { return -1; // 格式错误 } // URL解码 url_decode(req->path); // 路径校验：禁止../遍历 if (strstr(req->path, "..") && (req->path[0] != '.' || req->path[1] != '.' || (req->path[2] != '/' && req->path[2] != '\0'))) { return -1; // 检测到危险路径 } // 读取剩余头部，直到空行 while (n > 0 && !(buf[0] == '\r' && buf[1] == '\n')) { n = readline(connfd, buf, sizeof(buf)-1); if (n <= 0) break; // 提取Host头（简化版，只取第一个） if (strncasecmp(buf, "Host:", 5) == 0) { char *p = buf + 5; while (*p == ' ' || *p == '\t') p++; size_t len = strcspn(p, "\r\n"); if (len < sizeof(req->host)-1) { strncpy(req->host, p, len); req->host[len] = '\0'; } } } return 0; }

• readline()是自实现函数，核心逻辑：

  ssize_t readline(int fd, char *buf, size_t maxlen) { ssize_t n, rc; char c; char *ptr = buf; for (n = 1; n < maxlen; n++) { if ((rc = read(fd, &c, 1)) == 1) { *ptr++ = c; if (c == '\n') break; } else if (rc == 0) { if (n == 1) return 0; // EOF break; // partial line } else { if (errno == EINTR) continue; return -1; // error } } *ptr = '\0'; return n; }

  它逐字节读取，直到遇到\n（或\r\n），确保准确分割HTTP行。read()返回1表示读到1字节，rc==0表示对端关闭连接。
• strncasecmp()用于不区分大小写的头字段匹配，比strcmp()更符合HTTP规范。
• url_decode()函数需处理%XX序列，strtol()转换十六进制，注意边界检查（XX必须是两位十六进制字符）。

4.4 文件服务与响应发送：file_server.c的工程实践

src/file_server.c实现serve_static_file()：

#include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <stdio.h> #include <string.h> #include "utils.h" const char* get_mime_type(const char *filename) { const char *ext = strrchr(filename, '.'); if (!ext) return "application/octet-stream"; if (strcasecmp(ext, ".html") == 0 || strcasecmp(ext, ".htm") == 0) return "text/html"; if (strcasecmp(ext, ".css") == 0) return "text/css"; if (strcasecmp(ext, ".js") == 0) return "application/javascript"; if (strcasecmp(ext, ".png") == 0) return "image/png"; if (strcasecmp(ext, ".jpg") == 0 || strcasecmp(ext, ".jpeg") == 0) return "image/jpeg"; if (strcasecmp(ext, ".gif") == 0) return "image/gif"; return "application/octet-stream"; } void serve_static_file(int connfd, const char *root_dir, const char *path) { char filepath[1024]; snprintf(filepath, sizeof(filepath), "%s%s", root_dir, path); struct stat st; if (stat(filepath, &st) < 0) { send_error_response(connfd, 404); return; } if (!S_ISREG(st.st_mode)) { send_error_response(connfd, 403); // 禁止目录访问 return; } const char *mime_type = get_mime_type(filepath); off_t file_size = st.st_size; // 构造响应头 char header[2048]; int header_len = snprintf(header, sizeof(header), "HTTP/1.1 200 OK\r\n" "Content-Type: %s\r\n" "Content-Length: %ld\r\n" "Connection: close\r\n" "\r\n", mime_type, (long)file_size); if (header_len < 0 || header_len >= (int)sizeof(header)) { send_error_response(connfd, 500); return; } // 发送响应头 if (write(connfd, header, header_len) != header_len) { perror("write header"); return; } // 发送文件内容 int fd = open(filepath, O_RDONLY); if (fd < 0) { send_error_response(connfd, 500); return; } char buf[8192]; ssize_t n; while ((n = read(fd, buf, sizeof(buf))) > 0) { if (write(connfd, buf, n) != n) { perror("write file"); break; } } close(fd); }

• S_ISREG()宏检查文件是否为普通文件，防止通过/etc/passwd等路径访问敏感文件。
• snprintf()返回值检查：若返回负值（编码错误）或超出缓冲区，立即返回500。
• write()返回值必须与n严格相等，否则说明网络异常（如客户端断开），应中断发送。
• open()使用O_RDONLY，明确意图，避免O_RDWR带来的权限问题。

4.5 测试与验证：用curl和浏览器双重确认

编译并启动：

make ./httpd

终端输出：HTTPD listening on port 8080...

准备测试文件：

mkdir -p www echo "<h1>Hello from C HTTPD!</h1>" > www/index.html echo "<p>Static file test.</p>" > www/test.html

用curl测试：

# 基本GET curl -v http://localhost:8080/ # 应返回200 OK及HTML内容 # 测试404 curl -v http://localhost:8080/missing.html # 应返回404 Not Found # 测试URL编码 curl -v "http://localhost:8080/test%20file.html" # 若www下有test file.html，则应返回内容 # 查看响应头 curl -I http://localhost:8080/ # 检查Content-Type和Content-Length

用浏览器访问http://localhost:8080/，应显示Hello from C HTTPD!。打开开发者工具（F12），切换到Network标签，点击请求，查看Headers和Preview，确认状态码、响应头、渲染效果。

注意：首次运行若提示bind: Address already in use，用sudo lsof -i :8080查进程，或改端口为8081。生产环境切勿用root运行，应sudo setcap 'cap_net_bind_service=+ep' ./httpd授予权限。

5. 常见问题与排查技巧实录：那些年踩过的坑

5.1 连接被拒绝（Connection refused）的三大元凶

独家心得：用strace是神技。strace -e trace=network ./httpd能实时看到所有socket系统调用及其返回值，比printf调试高效十倍。例如，看到accept(3, ..., ...) = -1 EAGAIN，立刻知道listen()backlog满了；看到read(4, "", 8192) = 0，确认客户端已关闭连接。

5.2 文件服务失效：路径、权限与编码的三重门

• 问题：访问/index.html返回404，但文件确实在www/目录下。
  排查：

  1. 检查snprintf(filepath, ...)拼接结果：printf("filepath: %s\n", filepath);
  2. 确认www/目录权限：ls -ld www应为drwxr-xr-x，www/index.html应为-rw-r--r--。
  3. 检查路径是否含多余/：/index.html拼接后为./www//index.html，stat()失败。解决方案：path[0]=='/' ? path+1 : path跳过首斜杠。

• 问题：中文文件名（如测试.html）返回404。
  原因：浏览器URL编码为%E6%B5%8B%E8%AF%95.html，但url_decode()未正确处理UTF-8多字节。
  方案：本项目不处理UTF-8文件名，要求静态文件名用ASCII。生产环境需用iconv()或mbstowcs()转换。

• 问题：大文件（>1MB）下载卡顿或不完整。
  原因：read()/write()未处理部分写（partial write）。write()可能只写入部分数据。
  修复：

  ssize_t write_all(int fd, const void *buf, size_t count) { size_t total = 0; ssize_t n; while (total < count) { n = write(fd, (const char*)buf + total, count - total); if (n < 0) { if (errno == EINTR) continue; return -1; } total += n; } return total; }

5.3 性能瓶颈与调试：从单线程到多路复用的跃迁

单线程HTTPD的瓶颈非常明显：

• CPU瓶颈：read()/write()是系统调用，频繁切换内核态/用户态。
• I/O瓶颈：read()大文件时阻塞，其他连接排队。
• 连接数瓶颈：SOMAXCONN=128，超过128个并发连接被丢弃。

实测数据（i5-8250U, SSD）：

• 1KB HTML文件：QPS ≈ 3500
• 1MB PNG文件：QPS ≈ 120（因read()阻塞）

升级路径：

1. 多进程：fork()后子进程处理connfd，主进程accept()。优点：简单，隔离性好；缺点：进程开销大，IPC复杂。
2. 多线程：pthread_create()，共享listenfd。优点：轻量；缺点：需线程安全（如errno是线程局部存储，