connect 的返回值只有两种,失败时留在 errno 里的原因却有五种以上。客户端要不要再试、隔多久再试、什么时候认输,全由这几个值决定。课件给的是一份状态机客户端:max_retries = 5,重试间隔固定 1 秒,连不上就打印一行日志继续。它把"失败以后还能再试"这件事演示完整了,判断依据和退避曲线还得自己补。
同一个 -1,五种不同的处境
| errno | 谁给出的 | 通常多快返回 | 该不该重试 |
|---|---|---|---|
ECONNREFUSED(111) | 对方内核回的 RST,该端口没有 listen | 毫秒 | 值得,短间隔 |
ETIMEDOUT(110) | SYN 没有回应,内核放弃了 | 分钟 | 值得,但要长间隔或异步 |
EINTR | 阻塞等待被信号打断 | 立即 | 连接尝试并未取消,等可写后查 SO_ERROR |
ENETUNREACH(101)/EHOSTUNREACH(113) | 路由表或中间设备拒绝 | 立即 | 不值得,报错退出 |
EMFILE/ENFILE | 本机 fd 耗尽 | 立即 | 清理后重试 |
ECONNREFUSED 说明网络通、主机在,只是端口上没人接客,所以服务重启窗口里它最常见,也是最值得立刻重试的一种。ETIMEDOUT 是完全相反的信息:SYN 出去没有回音。Linux 的 ipv4.tcp_syn_retries 默认 6 次,重传间隔逐次加倍,整个流程要一分钟以上才放弃;把它塞进 1 秒一次的重试循环,只会一边等一边把时间线拉长。
EINTR 最容易被"重试"两个字带偏。阻塞的 connect 被信号打断后,连接尝试仍在继续,close 才是取消它。正确做法是把描述符放进 select/poll 的可写集合,等它可写之后用 getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len) 取真正的结果;直接关掉重来也能跑,代价是多发一次 SYN。
/* retry_client.c —— gcc -std=c11 -Wall -Wextra retry_client.c -o retry_client */
#include <stdint.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/* 只负责一次尝试,把 errno 翻译成"下一步该干什么" */
enum conn_result { CONN_OK, CONN_RETRY_FAST, CONN_RETRY_SLOW, CONN_GIVE_UP };
static enum conn_result TryConnect(const char *ip, uint16_t port, int *fd_out)
{
*fd_out = -1;
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0)
return (errno == EMFILE || errno == ENFILE) ? CONN_RETRY_SLOW : CONN_GIVE_UP;
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(port);
if (inet_pton(AF_INET, ip, &server.sin_addr) != 1) {
close(fd);
return CONN_GIVE_UP; /* 地址写错,重试也没有意义 */
}
if (connect(fd, (struct sockaddr *)&server, sizeof(server)) == 0) {
*fd_out = fd;
return CONN_OK;
}
int saved = errno;
close(fd); /* 失败不做退避,就不再留着这个 fd */
switch (saved) {
case ECONNREFUSED:
return CONN_RETRY_FAST;
case EINTR: /* 也可以 poll 等可写后查 SO_ERROR */
return CONN_RETRY_FAST;
case ETIMEDOUT:
return CONN_RETRY_SLOW;
default:
return CONN_GIVE_UP;
}
}
/* 1,2,4,8,16,30 秒,上下浮动 20%,避免一批客户端同时醒来 */
static int BackoffSeconds(int attempt)
{
int base = 1 << (attempt < 5 ? attempt : 5);
if (base > 30) base = 30;
int span = base / 5;
if (span > 0)
base += rand() % (2 * span + 1) - span;
return base < 1 ? 1 : base;
}
int main(int argc, char **argv)
{
if (argc != 3) {
fprintf(stderr, "用法: %s ip port\n", argv[0]);
return 1;
}
uint16_t port = (uint16_t)strtoul(argv[2], NULL, 10);
int fd = -1;
for (int attempt = 0; attempt < 8 && fd < 0; ++attempt) {
enum conn_result r = TryConnect(argv[1], port, &fd);
if (r == CONN_OK) break;
if (r == CONN_GIVE_UP) return 1;
int wait = BackoffSeconds(attempt + (r == CONN_RETRY_SLOW ? 2 : 0));
printf("第 %d 次失败,%d 秒后重试\n", attempt + 1, wait);
sleep((unsigned)wait);
}
if (fd < 0) {
fprintf(stderr, "重连失败\n");
return 1;
}
printf("已连接,fd = %d\n", fd);
close(fd);
return 0;
}ENETUNREACH 和 EHOSTUNREACH 落到 default 里直接放弃,这是有意的:路由层面不通的时候,再试一万次也还是不通,重试循环只会掩盖真正的原因。
五个状态名,各自对应一个事件
课件的状态机是 NEW → CONNECTING → CONNECTED / DISCONNECTED → CLOSED,Execute() 里的分支只有四条:NEW 调 Connect(),CONNECTED 调 Process() 收发,DISCONNECTED 调 Reconnect(),CLOSED 清理后退出。CONNECTING 只在 Reconnect() 开头被赋值,主循环没有对应分支,落到 default 空转——它其实是给外部查询用的中间态,不是真正会停留的状态。这种写法的价值不在"高级",而在于读代码的人只看状态名就知道程序停在哪一步,不用顺着调用栈猜。
有一处名字和实际用法对不上:DISCONNECTED 的注释写的是"重连失败",但它实际在两处被赋值——首次 connect 失败,以及 read 返回 0(对方关闭)。两种情况的共同点是"当前没有可用连接",并不是"重连失败过一次"。状态名按发生了什么事来起,比按心情来起可靠;后者一旦多出第三种"连接没了"的路径,就得给同一个状态硬塞两种含义。
Disconnect() 也把两件事绑在了一起:关闭 fd(资源动作)和把状态置为 CLOSED(业务判断)。析构函数还会调它一次,于是"对象销毁"和"连接放弃"共用同一段逻辑。清理动作应该只管清理,状态由调用它的那一方决定,否则以后新增状态时会发现有人在你背后改了值。
Connect() 在 socket() 失败时直接 exit(1),这与整个状态机是矛盾的。socket() 失败最常见的原因是 fd 用尽,恰恰是最该清理、退避、再试的一类错误。把它改成返回失败、让状态回到 DISCONNECTED,重连逻辑才闭环。
每次重试都换一个新 fd,间隔要拉开
不要在失败的那个 fd 上反复调用 connect。它已经和本地临时端口、对端地址绑定成一个四元组,TCP 状态机停在半路,继续在它上面连只会得到 EALREADY 之类的错误。课件的顺序是对的:Connect() 每次先 socket(),失败后 Disconnect() 关闭,下一轮从零开始。
间隔固定成 1 秒,适合演示,不适合运行。服务端重启往往要几秒到几十秒,这期间客户端每秒撞一次门,日志刷得很快,恢复瞬间又会有大量客户端同时涌进来。上面那份程序里的 BackoffSeconds 把间隔拉成 1、2、4、8、16、30 秒,再叠一点抖动,避免所有客户端在第 1、2、4、8 秒同步醒来。
客户端不需要显式 bind。connect 时内核会给它分一个本地临时端口,这正是"必须有 IP 和端口、但不用用户自己绑"的原因;需要固定源端口(防火墙白名单、服务端按源地址识别)时才在 connect 之前手动 bind。
sleep 会把整个线程按住。一个客户端只管一条连接时无所谓;一个线程管几十条连接时,退避得挂进事件循环,用定时器而不是 sleep,否则一条连不上,其他连接也跟着停摆。

对方消失有三种面孔,写方向的坏消息来得最晚
read 返回 0,是对端发了 FIN。对方正常 close,内核立刻把这条连接的读方向标记结束,这是最干脆的一种。
read 返回 -1、errno 是 ECONNRESET,是对端进程崩了或者被 kill -9,操作系统替它发了 RST。也很干脆,但它说明连接是被强行掐断的,缓冲区里半条消息很可能已经丢了。
第三种没有信号:对方拔网线、断电,或者中间设备没了。没有 FIN,也没有 RST,read 一直阻塞。本地看 ss -tn,连接还挂在 ESTAB,只有等内核重传耗尽,read 才会报错,这个周期以分钟计。
写方向更慢。第一次 send 只是把数据拷进发送缓冲区就返回成功,哪怕对方早就不在了;写成功因此证明不了连接活着。真正写不出去时,内核先发 SIGPIPE,默认处置是终止进程(signal(7) 的动作表里写得很清楚:Broken pipe: write to pipe with no readers)。课件 Process() 里 write 失败后打印 errno 的那段代码,在这种场景下可能根本执行不到。
两种防法:进程级 signal(SIGPIPE, SIG_IGN),让 write 正常返回 EPIPE;或者单次调用用 send(fd, buf, len, MSG_NOSIGNAL),不改动宿主进程的信号表。写库时用后者,写自己的程序时两个都上。
课件 Process() 还有一处会导致空转:
getline(cin, inbuffer);
if(inbuffer.empty()) continue;用户按 Ctrl+D 之后 getline 一直失败,inbuffer 一直是空的,continue 就变成了 100% CPU 的死循环。判断条件应该是"这次读有没有成功":if (!std::getline(std::cin, line)) break;,并且要把这条路径和"对方掉线"区分开——输入结束不是网络事件,直接退出即可。
SO_KEEPALIVE 只回答“那台机器还在不在”
TCP keepalive 是内核在连接空闲时发探测段,默认参数在 Linux 上是 tcp_keepalive_time = 7200 秒、tcp_keepalive_intvl = 75 秒、tcp_keepalive_probes = 9。也就是说,连接静默两个小时后才开始敲第一下门,敲满 9 次才判死,全程两个多小时。它检测的是对端主机的 TCP 栈还在不在回话,检测不到对方进程死锁、业务线程卡住、房间已解散。
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
/* 打开 TCP keepalive;后三个选项是 Linux 特有,别的系统要用各自的接口 */
void enable_keepalive(int fd)
{
int on = 1;
setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &on, sizeof(on));
int idle = 60, intvl = 10, cnt = 3; /* 空闲 60s 后开始探测 */
setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(idle));
setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl));
setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt));
}它仍然值得打开:NAT 和防火墙会把长时间没有数据的映射悄悄回收,周期性的探测段能顺便续命。但不要把"断了能发现"这件事全压在它身上,它的时间尺度是小时。
心跳是协议的一部分,select 只是观察它的工具
应用层心跳解决的是"业务还在不在":客户端每隔几秒发一条带类型码的空报文,服务端回一条,两边都在固定时限内没收到任何数据就判死。设计上有三个参数要一起定:间隔、超时、以及"收到什么算活"。间隔必须小于超时,超时最好小于链路上最短的 NAT 空闲回收时间。任何数据都刷新最后活跃时间,不能只认心跳应答——业务数据同样证明连接通着。
select 在这里的角色是等待,不是判断。它返回可读,可能是因为来了数据,也可能是因为对方发了 FIN——读集合在连接关闭时同样会就绪。所以"可读"之后仍然要 recv,看返回值才能分清:
#include <errno.h>
#include <time.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/socket.h>
/* 返回 0 表示判定连接已断;业务报文由调用方另行处理 */
int session_loop(int sockfd)
{
time_t last_active = time(NULL);
for (;;) {
fd_set rfds;
struct timeval tv = { 1, 0 }; /* 每秒醒一次 */
FD_ZERO(&rfds);
FD_SET(sockfd, &rfds);
int n = select(sockfd + 1, &rfds, NULL, NULL, &tv);
if (n < 0) {
if (errno == EINTR) continue;
return 0;
}
if (n == 0) { /* 超时:没有数据 */
if (time(NULL) - last_active >= 10) return 0; /* 心跳超时,判死 */
if (send(sockfd, "PING\n", 5, MSG_NOSIGNAL) < 0) return 0;
continue;
}
char buf[512];
ssize_t m = recv(sockfd, buf, sizeof(buf), 0);
if (m == 0) return 0; /* FIN */
if (m < 0) {
if (errno == EINTR) continue;
return 0; /* ECONNRESET 或真错误 */
}
last_active = time(NULL); /* 收到任何数据都算活 */
}
}三层检测各有各的时间尺度:内核 keepalive 是小时级的兜底,应用心跳是秒级的业务可用性判断,recv 返回 0 或 RST 是立即的、但只在真正收发时才出现的信号。重连代码之所以要写成状态机,就是因为这三层会以不同顺序、在不同时刻报告同一件事:对方没了。
还没有评论 — 第一条由你来留。