Socket 入门:一条 TCP 连接是怎样建立和使用的
系列入口:分布式阅读路径。前置:RPC 入门。下一篇:select、poll 与 epoll。
笔记本想知道文件服务上的 report.txt 有多大。在 RPC 的视角里,这是一次函数调用;往下看,客户端需要把请求送过去,服务端需要把结果送回来。
可是,程序怎样找到服务?epoll 示例里随手出现的 fdA、fdB 是从哪里来的?连接建立以后,究竟是谁把数据放进 buffer?如果这些地方还没有连起来,直接读 epoll 很容易变成记接口。
这一讲先只接待一个客户端。我们沿着一条 TCP 连接走完建立、收发和关闭,再看一个线程照看多个连接时,多出来的问题是什么。
范围与代码约定
这是 Linux / Unix 网络编程的基础,使用 C++17 和 POSIX socket 接口;正文涉及的基本接口也可用于 macOS。epoll 留到下一讲。
正文代码是分组教学片段,不是可直接拼接编译的完整程序;能编译运行的完整版本放在“把一次成功的查询连起来”一节末尾。片段用到的头文件是 <sys/socket.h>、<netinet/in.h>、<arpa/inet.h>、<unistd.h>、<fcntl.h> 和 <cerrno>。先跟踪正常路径,再解释返回值;实际程序必须检查系统调用失败。读者只需认识变量、函数、循环和字符串,不要求先掌握 TCP 报文、路由或网络框架。
两个进程怎样交换一次查询
客户端进程中的函数,不能直接读取服务端进程的局部变量。即使两个进程都在本机,它们也有各自的地址空间;在客户端声明一个 buffer,不会自动让服务端获得它。
因此,我们需要把查询表示为字节,让操作系统把字节送到另一端,再由另一端的程序解释。这里采用 TCP:它向应用提供有序、可靠的字节流。所谓可靠,是指协议处理丢包重传、按序交付等传输问题;网络故障仍可能让连接失败,它不保证一次业务请求必然成功。
TCP 是通信协议,socket 是应用使用操作系统通信能力的接口和端点。 socket 也可以使用 UDP 等其他协议,本文只讨论 TCP socket。后面每次说“连接”,都是指 TCP 连接。
在这个例子里,职责可以先分清:
| 谁 | 负责什么 |
|---|---|
| 客户端应用 | 表达“查询文件大小”,解释结果 |
| 两端操作系统的 TCP 实现 | 建立连接,传递有序的字节流 |
| 服务端应用 | 解释查询,访问本地文件,产生结果 |
接下来先解决一个问题:客户端该把连接请求发到哪里?
先让两个程序有一个见面的地址
继续使用文件大小查询。为了排除部署问题,先把客户端和文件服务作为两个进程运行在同一台机器上。文件由服务端进程访问;客户端通过网络接口问它,不自己打开文件。
约定文件服务在 127.0.0.1:9090 等待连接。127.0.0.1 是回环地址,指向本机;9090 是我们为服务选择的端口。以后换成另一台机器,客户端改用那台机器的地址即可;服务端也要改绑定的地址(见下文“为什么先用回环地址?”),并且网络要可达。
socket 是操作系统提供的通信端点。内核维护它的状态、收发缓冲区等信息,应用通过接口操作它。
fd(file descriptor,文件描述符)则是进程使用的一个整数编号。可以把它理解为进程交给内核的“索引”:recv(7, ...) 的意思是操作当前进程描述符表中编号为 7 的对象。它属于“句柄”这一类间接引用资源的方式。
因此,客户端的 7 和服务端的 7 可以表示不同对象。把变量赋值为 7 也不会创建 socket;要先让系统创建资源并返回 fd。后文的 3、4、7 都是便于追踪的假定值,真实值由系统分配。
服务先准备好接待入口
服务端要先获得一个 socket,再指定地址,最后开始监听。这三个操作改变的是同一个 socket 的状态。
这些函数是应用调用操作系统能力的入口,通常称为系统调用接口。调用返回以后,应用继续执行下一行;有些调用需要等待条件满足才能返回,这叫阻塞。阻塞的是执行调用的线程,不是整台机器:其他线程、其他进程以及内核处理网络的工作仍然可以推进。
先准备地址。AF_INET 表示使用 IPv4,地址需要按系统接口要求写进一个结构体:
sockaddr_in address{};
address.sin_family = AF_INET;
address.sin_port = htons(9090);
inet_pton(AF_INET, "127.0.0.1", &address.sin_addr);
sockaddr_in 表示 IPv4 地址,{} 先把结构体初始化为零。htons 把端口转换成网络使用的字节顺序;inet_pton 把人能读的 IP 文本转换成地址字段,成功返回 1。它们都没有发起连接。
bind 接口接受通用的 sockaddr*,所以调用处将具体的 IPv4 地址指针转换成这个类型,同时传入结构体大小。
socket(AF_INET, SOCK_STREAM, 0) 创建 IPv4 流式 socket,在这里使用 TCP。成功返回一个非负 fd,失败返回 -1。刚创建的 socket 还没有连接到任何客户端。
bind 为它指定本地地址;listen 把它变成监听 socket,用来接待连接。两者成功返回 0,失败返回 -1。只有前一步成功,才能沿这条正常路径继续。例如,端口已被占用时,bind 可能失败,后面的等待就没有意义。
刚停掉服务,重启时 bind 失败?
后文的安排是服务端回复后先 close(connFd)。主动关闭的一方,连接会在 TIME_WAIT 状态停留一段时间(Linux 上约 60 秒),期间仍占着 9090 这个本地端口。这时重启服务,bind 常会失败,errno 为 EADDRINUSE。
所以服务端通常在 bind 之前打开 SO_REUSEADDR:
int on = 1;
setsockopt(listenFd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on);
它允许在旧连接仍处于 TIME_WAIT 时重新绑定监听地址;如果另一个进程正在监听同一端口,bind 仍会失败。细节见 socket(7)。
监听队列不是客户端总数
listen(..., 16) 中的 16 是等待应用接收的连接队列长度参数,实际还受系统限制;它不是“整个服务最多只能有 16 个客户端”,也不会创建 16 个线程。Linux 对该队列的具体定义见 listen(2)。
为什么先用回环地址?
绑定 127.0.0.1 的服务只接受本机通过回环地址访问。若要接待其他机器,需要绑定合适的本机地址;0.0.0.0 可表示监听所有本地 IPv4 接口,但客户端连接时应填写服务器的实际地址。这里先不引入防火墙、路由和部署配置。
客户端连接,服务端接收连接
客户端同样先创建自己的 socket。它要连接的目标地址,恰好就是上面约定的服务地址。
在默认的阻塞模式下,connect 等待连接建立成功或失败。返回 0 才能沿成功路径收发数据;返回 -1 表示失败,不能当成已经连接。
失败的具体原因要看 errno:它是系统调用报告失败原因的错误码,只在返回值表明失败时才有意义,不能在调用成功后读一个旧值来推断失败。后文所有系统调用都按这个规则使用它。
服务端 bind 使用地址来说明“我在这里接待”;客户端 connect 使用地址来说明“我要去这里”。参数看起来相似,含义取决于调用的接口。
客户端通常不需要自己 bind。内核会选择本地地址和一个临时端口。假定这次选择的是 127.0.0.1:53000,那么连接的两端就是 127.0.0.1:53000 和 127.0.0.1:9090。下次连接的临时端口可能不同。
服务端准备好监听后,调用另一个接口取出已建立的连接:
两个 nullptr 表示暂时不取回客户端的地址信息。没有可接收的连接时,阻塞的 accept 会等待;成功时返回新 fd,失败时返回 -1。
客户端执行 connect 后,两端内核交换建立连接所需的信息,这个过程称为握手。握手由内核完成,不需要服务端应用参与:连接建立后先放进监听 socket 的队列,等应用调用 accept 取走。
所以两端的调用顺序并不固定。服务端可以先执行到 accept 等着;也可以晚一些才调用,此时客户端的 connect 可能早已成功返回。connect 成功只说明连接建好了,不说明服务端应用已经取走它,更不意味着文件查询已经执行。
为什么多个客户端都连 9090,服务还能分清?因为一条 TCP 连接由两端地址和端口共同区分。两个客户端即使目标相同,源地址和源端口也至少有一项不同。accept 得到的 socket 仍使用服务端口 9090,不需要给每个客户端另开一个服务端口。参见 accept(2) 与 tcp(7)。
有了连接,还要约定字节是什么意思
TCP 让两个程序有序地传递字节,但它不知道文件名、请求或响应是什么。我们自己定一个足够小的文本协议:
这个协议规定:以换行作为消息结束标记;服务端认出请求后,在自己的文件系统中查询 report.txt,再把大小转成十进制文本。查询失败时,可以回复 ERR file-unavailable\n。本例只接受固定文件名,暂不设计通用文件路径语法。
TCP 并不会执行查询。执行查询的是服务端应用代码。accept 只交付连接,recv 只交付字节,应用解析字节后才知道该做什么。
这就是网络编程和 RPC 的衔接处:这里我们手工定义消息和处理逻辑;RPC 框架则进一步提供编码、调用分发、结果匹配等机制,让上层用调用接口表达这些操作。
字节从一端到另一端,要经过哪里?
建立连接后,双方都能调用 send 和 recv。客户端并不只能发送,服务端也不只能接收;请求和响应走的是相反的方向。
先只跟踪客户端发出的请求。在本文使用的普通收发方式下,可以把路径看成:
客户端应用中的 request
↓ send
客户端内核的发送缓冲区
↓ TCP 传输
服务端内核的接收缓冲区
↓ recv
服务端应用中的 buffer
↓ 应用积累、解析
一条完整查询 → 执行文件查询发送缓冲区暂存交给本地发送机制的字节;接收缓冲区暂存已经到达、等待应用取走的字节。图中省略了协议栈和设备内部的细节,只保留应用理解收发所需要的边界。
注意:数据到达接收缓冲区,不要求对方应用恰好正在执行 recv。 即使服务端线程在做别的事,内核也可以先接收和保存数据;应用以后再取。但缓冲区容量有限,如果应用长期不读取,会通过 TCP 流量控制影响发送端,不能把它当成无限仓库。
响应沿相反方向经过同样的过程:服务端 send,客户端 recv。下面先看每一步完成时,应用究竟能确认什么。
send 返回,字节走到哪里了?
先从客户端发送请求看起:
std::string request = "SIZE report.txt\n";
ssize_t n = send(clientFd, request.data(), request.size(), 0);
request.data() 指向请求字节,request.size() 是希望发送的长度,最后的 0 表示不启用额外标志。ssize_t 是可以表示负数的长度类型,因此既能容纳字节数,也能表示失败时的 -1。
send 从应用提供的内存取字节,交给本地 socket 的发送机制。成功返回本次交给发送缓冲区的字节数。这个结果不证明对方应用已经读取,更不证明文件查询已完成。
一次 send 不保证交出全部字节。阻塞 socket 上这种情况较少见,通常发生在发送中途被信号打断或设置了发送超时时;到了下一讲的非阻塞 socket,发送缓冲区一满就会出现,非常常见。假如请求共 16 字节,本次只交出了前 6 字节,下次应从第 7 个字节开始发送,不能重发开头。
发送循环的错误路径
片段只强调偏移量,不能把循环退出直接当作成功。实际代码还要处理 EINTR(调用被信号中断,可按情况重试)、连接错误等。向已断开的连接发送还可能触发 SIGPIPE;Linux 可用 MSG_NOSIGNAL 抑制该信号并通过返回值处理错误。接口细节见 send(2)。
TCP 接下来负责传输和必要的重传,但无法替你判断服务端业务是否成功。客户端仍要收到并解析应用协议中的响应。
recv 拿到的是一批字节,不一定是一条消息
现在服务端读取请求,注意它使用 connFd,不是监听用的 listenFd:
connFd 指定读哪个 socket,buffer 指定把字节放在哪里,sizeof buffer 指定最多取多少,最后的 0 表示普通读取。内核完成这次读取,函数返回后,应用才根据返回的长度处理内容。
在默认的阻塞模式、标志为 0 的情形下,当前没数据、连接也没有结束或出错,线程就会等待。有数据可取时,调用可以返回现有的一部分字节。
| 返回结果 | 应用怎样理解 |
|---|---|
n > 0 | 读到了 n 字节,只有 buffer[0] 到 buffer[n - 1] 有效 |
n == 0 | 对于这里非零长度的读取,表示对端正常结束发送,且待读数据已读完 |
n == -1 | 调用失败,检查 errno;不同原因需要不同处理 |
recv 不自动在末尾追加字符串结束符 \0。处理文本时可用 std::string(buffer, n),但前提是已经确认 n > 0;不能直接假定 buffer 是以零结尾的 C 字符串。
还有一个更影响程序结构的事实:TCP 保留字节顺序,不保留应用每次 send 的边界。 对方一次发送 SIZE 4096\n,这边可能一次读完,也可能先读到 SIZE 40,稍后才读到 96\n。对方连续发送两行,这边也可能一次读到两行。这些是允许发生的情况,不是每次运行必然出现的拆分。
因此,recv 成功与“收到了完整响应”是两件事。消息边界必须由应用协议判定。我们选择的规则是寻找换行字节。参见 recv(2)。
半条响应读出来以后,放在哪里?
服务端对请求也要做相同的积累。为了把结果追踪到底,现在切到客户端读取响应:假定服务端已完成查询并发送 SIZE 4096\n。
假定客户端第一次读到了 SIZE 40,还没有换行。此时这 7 个字节已经被普通 recv 从内核接收缓冲区取走,放到了应用的 buffer 中。
它们不会留在内核里等后半条来拼接。第二次 recv 读到的是后续字节;把前后两段接起来,是应用自己的责任。
沿着同一个响应追踪四个时刻:
| 时刻 | 内核待读字节 | 应用积累区 |
|---|---|---|
| 第一段到达,还没读取 | SIZE 40 | 空 |
| 第一次读取并追加完成 | 空 | SIZE 40 |
| 后半段到达,还没再次读取 | 96\n | SIZE 40 |
| 再次读取并追加完成 | 空 | SIZE 4096\n |
现在可以按换行取出完整消息,同时保留其余字节:
size_t end = input.find('\n');
if (end != std::string::npos) {
std::string message = input.substr(0, end);
input.erase(0, end + 1);
// message 是 "SIZE 4096",接下来解释它的业务含义。
}
如果一次读取包含多行,就重复寻找并取出完整行;最后留下没有结束标记的尾部。真实服务还应限制消息和积累区大小,不能让没有换行的输入无限占用内存。
没有换行,就继续读;有了换行,就交付消息
把刚才的操作连成一个循环,关键是先检查已经积累的字节,只有还缺数据时才调用 recv。否则明明已有完整消息,也可能多读一次而阻塞。
下面是客户端读取一条响应的教学片段;假定使用阻塞 socket、消息长度受控。input 在整个循环期间存在。错误分支用注释说明,尚不是通用网络库函数。
std::string input;
for (;;) {
size_t end = input.find('\n');
if (end != std::string::npos) {
std::string message = input.substr(0, end);
input.erase(0, end + 1);
// 解释 message,然后结束本次等待。
break;
}
char buffer[1024];
ssize_t n = recv(clientFd, buffer, sizeof buffer, 0);
if (n > 0) {
input.append(buffer, n);
continue;
}
if (n < 0 && errno == EINTR) continue;
// n == 0:还没等到完整行,对端就结束了发送。
// 其他失败:停止本次读取,并处理错误。
break;
}
假定第一次 recv 返回 SIZE 40,追加后回到循环开头,找不到换行,于是再次读取。第二次可能等待;等 96\n 到达后,追加得到完整一行,下一轮直接取出消息并退出,不再调用 recv。
如果对端在只发送 SIZE 40 后正常结束发送,下一次读取可能返回 0。连接层面的正常结束,并不能让这半条响应变成合法消息;对我们约定的协议来说,它仍是一次不完整的响应。
这个片段只消费一行。如果要持续处理同一连接,剩余的 input 还必须交给下一次消息处理,不能随着本次函数返回而丢弃。后面进入事件循环时,这会成为连接状态的一部分。
暂时没数据、消息结束、连接结束
这三个状态必须分别判断。以前面的响应为例,收到 SIZE 4096\n 后,消息已经完整,但连接完全可以继续存在,供下一次查询使用。
如果双方都不关闭连接,客户端又无条件调用阻塞的 recv,就可能一直等下去。这不是上一次响应没传完,而是程序已经读完一条消息,却还在等待更多字节。
默认阻塞模式下,没有数据时通常是等待,不会因为“现在空了”就返回 0。要区分“暂时没数据”,需要把 socket 设为非阻塞。做法是用 fcntl 修改 fd 的状态标志,在原标志上加上 O_NONBLOCK:
int flags = fcntl(connFd, F_GETFL, 0);
fcntl(connFd, F_SETFL, flags | O_NONBLOCK);
// 两步失败时都返回 -1。
本文没有设置接收超时;在这个前提下,设置为非阻塞后,读取会在暂时无数据时以 EAGAIN / EWOULDBLOCK 返回。这表示“现在推进不了,可以稍后再试”,不表示连接失效。
所以,非阻塞并不意味着自动开一个后台线程,也不意味着系统以后会直接把完整消息交给你。当前调用返回以后,由应用决定去做什么、何时再次读取。它改变的是没有数据时调用如何返回,不改变消息的边界。下一讲再把它放进事件循环。
一次查询结束,应该关闭什么?
最简单的安排是:客户端发一条查询,服务端回复一条结果,然后关闭这条连接。客户端按换行得到结果,再释放自己的 fd。双方的监听和通信资源要分别看待。
这里假定没有通过 dup 等方式保留同一 socket 的其他描述符引用。close 释放当前 fd;以后内核可能把这个整数重新分配给另一个资源,所以不能继续用旧 fd 猜测它仍代表原来的连接。
还可以只结束一个方向。例如,客户端发送完全部请求后调用:
shutdown(clientFd, SHUT_WR);
这表示自己不再发送,但还可以接收服务端响应。对端读完已经发送的数据后,可以观察到接收返回 0。它不等于 close:fd 仍然需要在使用结束时释放。
TCP 是双向通信。一端正常结束发送,不意味着另一方向也已经结束。我们的一行协议本来就能判断请求结束,所以这里不必依赖 shutdown 来分隔请求;它只是帮助辨认“消息边界”和“发送方向结束”的区别。接口细节见 shutdown(2) 和 close(2)。
把一次成功的查询连起来
现在可以在脑中走完全部过程。下面是一次可能的执行顺序;真实的两端并发运行,不保证应用日志严格按这些行交替出现。
| 阶段 | 客户端进程 | 服务端进程 |
|---|---|---|
| 准备服务 | 尚未连接 | socket → bind → listen |
| 建立连接 | socket → connect | accept 得到 connFd |
| 发送查询 | 循环 send,交出整条请求 | 从 connFd 调用 recv |
| 处理查询 | 等待响应 | 积累到换行,解析请求,查询本地文件 |
| 返回结果 | recv,积累到换行,解析大小 | 循环 send,交出整条响应 |
| 释放资源 | close(clientFd) | close(connFd),可继续接受下一条连接 |
表中“循环 send”包含处理部分发送;“积累到换行”包含处理部分接收。表中只画成功路径,任何系统调用失败都应进入对应的错误处理,不能机械地继续下一格。
到这里,一条连接已经能承载一次文件查询。仍然没有使用 select、poll 或 epoll,因为一个线程只等待这一个客户端,阻塞模式就足以表达顺序。
展开:可以编译运行的完整服务端与客户端
把前面的片段收拢成两个文件。readLine 就是“积累到换行”的循环,sendAll 就是“部分发送后从偏移量继续”的循环;错误路径简化为打印并退出。
// size_server.cpp:只接待一个客户端,回答一次 SIZE report.txt 查询。
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#include <cerrno>
#include <cstdio>
#include <filesystem>
#include <string>
#include <system_error>
// 读到一条以换行结尾的消息;失败或对端提前结束时返回 false。
bool readLine(int fd, std::string& input, std::string& line) {
for (;;) {
size_t end = input.find('\n');
if (end != std::string::npos) {
line = input.substr(0, end);
input.erase(0, end + 1);
return true;
}
char buffer[1024];
ssize_t n = recv(fd, buffer, sizeof buffer, 0);
if (n > 0) {
input.append(buffer, static_cast<size_t>(n));
continue;
}
if (n < 0 && errno == EINTR) continue;
return false;
}
}
// 把整条消息交给发送缓冲区;处理部分发送。
bool sendAll(int fd, const std::string& data) {
size_t offset = 0;
while (offset < data.size()) {
ssize_t n = send(fd, data.data() + offset, data.size() - offset, 0);
if (n > 0) offset += static_cast<size_t>(n);
else if (n < 0 && errno == EINTR) continue;
else return false;
}
return true;
}
int main() {
int listenFd = socket(AF_INET, SOCK_STREAM, 0);
if (listenFd < 0) { perror("socket"); return 1; }
int on = 1;
setsockopt(listenFd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on);
sockaddr_in address{};
address.sin_family = AF_INET;
address.sin_port = htons(9090);
inet_pton(AF_INET, "127.0.0.1", &address.sin_addr);
if (bind(listenFd, reinterpret_cast<sockaddr*>(&address), sizeof address) < 0) {
perror("bind");
return 1;
}
if (listen(listenFd, 16) < 0) { perror("listen"); return 1; }
int connFd = accept(listenFd, nullptr, nullptr);
if (connFd < 0) { perror("accept"); return 1; }
std::string input, request;
if (readLine(connFd, input, request)) {
std::string response = "ERR file-unavailable\n";
if (request == "SIZE report.txt") {
std::error_code ec;
auto size = std::filesystem::file_size("report.txt", ec);
if (!ec) response = "SIZE " + std::to_string(size) + "\n";
}
if (!sendAll(connFd, response)) perror("send");
}
close(connFd);
close(listenFd);
}
客户端复用同样的 readLine 和 sendAll(复制到文件开头即可),main 如下:
// size_client.cpp:连接文件服务,查询 report.txt 的大小。
// 头文件与服务端相同(不需要 <filesystem> 和 <system_error>),
// 并在这里放上 readLine 与 sendAll 的定义。
int main() {
int clientFd = socket(AF_INET, SOCK_STREAM, 0);
if (clientFd < 0) { perror("socket"); return 1; }
sockaddr_in address{};
address.sin_family = AF_INET;
address.sin_port = htons(9090);
inet_pton(AF_INET, "127.0.0.1", &address.sin_addr);
if (connect(clientFd, reinterpret_cast<sockaddr*>(&address), sizeof address) < 0) {
perror("connect");
return 1;
}
std::string input, response;
if (!sendAll(clientFd, "SIZE report.txt\n")) { perror("send"); return 1; }
if (readLine(clientFd, input, response)) {
std::printf("response: %s\n", response.c_str());
} else {
std::printf("connection ended before a complete response\n");
}
close(clientFd);
}
在同一目录下编译,先准备一个 4096 字节的 report.txt,再分两个终端运行:
clang++ -std=c++17 -Wall -Wextra size_server.cpp -o size_server
clang++ -std=c++17 -Wall -Wextra size_client.cpp -o size_client
head -c 4096 /dev/zero > report.txt
./size_server # 终端 1:阻塞在 accept
./size_client # 终端 2我在 macOS(Apple clang 21)上运行,三种情形的结果与正文的推理一致:
- 有
report.txt时,客户端打印response: SIZE 4096。 - 删掉
report.txt再运行,客户端打印response: ERR file-unavailable:连接和收发都成功了,失败的是业务。 - 不启动服务端直接运行客户端,
connect失败并打印Connection refused。
服务端每次回复后先关闭连接,因此每次都会在 9090 上留下 TIME_WAIT;由于设置了 SO_REUSEADDR,紧接着重启服务端也能成功 bind。可以试着删掉 setsockopt 那一行,再快速连续运行两轮,观察 bind: Address already in use。
动手看一眼:连接真的长这样吗?
前面的 fd 和端口都是假定值。不写完整程序,也可以用 nc(netcat)扮演两端,检验几个结论。打开三个终端:
# 终端 1:扮演服务端,在 127.0.0.1:9090 监听
nc -l 127.0.0.1 9090
# 终端 2:扮演客户端,连接服务
nc 127.0.0.1 9090
# 终端 3:查看与 9090 有关的 TCP socket(Linux)
ss -tan '( sport = :9090 or dport = :9090 )'
# macOS 可改用:lsof -nP -iTCP:9090不同版本的 nc 参数略有差异,传统 netcat 需要写成 nc -l -p 9090。
先按正文预测,再对照终端里看到的结果:
- 只启动终端 1 时,应当只有一条
LISTEN记录,本地地址是127.0.0.1:9090,这就是监听 socket。 - 终端 2 连上以后,会多出一对
ESTAB记录:一条本地端口是9090,另一条本地端口是内核挑的临时端口,对应正文假定的53000。服务端没有为这位客户端另开端口。 - 在终端 2 输入
SIZE report.txt并回车,终端 1 会显示这一行;在终端 1 输入SIZE 4096并回车,终端 2 会显示它。nc并不理解这些文字,只是搬运字节,解释它们是应用协议的事。 - 在终端 2 按 Ctrl-C 结束客户端,终端 1 的
nc通常会随之退出:它的读取返回了0。再看终端 3,先关闭的那一端会留下TIME-WAIT。这里先关闭的是客户端;如果像本文的安排那样由服务端先关闭,TIME-WAIT就会占着9090,也就是前面重启时bind失败的原因。
问题怎样走到 I/O 多路复用?
假设服务端已经接受了 A、B 两条连接。线程先调用 recv(fdA, ...),A 暂时不发请求,线程就停在 A 上。此时 B 的完整请求已经到达,B 的接收缓冲区里有数据,但应用还没有执行读取 B 的代码。
单个线程怎样避免等错地方?这才轮到 select、poll、epoll 出场:先等待一组 fd 的就绪事件,再操作现在能够推进的对象。
线程离开 A 去处理 B 时,A 的半条消息不能丢失。前面阻塞循环里的 input,现在需要保存得更久:处理函数这次返回,下次仍能找到同一份积累区。
仅仅定义结构体还不够:这些 Connection 对象必须由事件循环或连接管理对象持有,活过多次处理函数调用。每次进入处理函数,再找到这个 fd 对应的状态继续读取、追加和解析。
实际事件循环通常配合非阻塞 socket:就绪状态可能变化,一次事件处理也可能想连续读取多批数据;非阻塞模式让线程在暂时无法继续时返回,而不是重新卡住。
检查理解:完整响应已经到达,但线程还卡在另一个连接上,会发生什么?
假定线程正阻塞在 recv(fdA, ...),此时 B 的 SIZE 4096\n 已经全部到达。A、B 都保持连接。
B 的字节可以先保存在 B 的内核接收缓冲区,但这不会替线程执行 recv(fdB, ...),也不会让等待 A 的调用因为 B 到达数据而完成。应用的 B 积累区仍要等它实际读取后才更新。
如果使用多路复用,应用可以先等待一组 fd 的就绪状态,再读取 B。读出字节后,仍然要追加、寻找换行并解析响应。因此要依次问:字节到了吗?应用取走了吗?消息拼完整了吗?业务处理完成了吗?这四个时刻可能不同。
带着这几个状态,继续读 select、poll 与 epoll:一个线程怎样照看多个连接。接下来不再假设“连接凭空出现”:你已经知道这些 fd 从哪里来、该调用哪个接口,以及一次读取以后哪些状态必须留下。