计算机网络 / 系统课时

连接超时和心跳怎样实现

连接超时和心跳怎样实现

长连接不能只依赖“对端最终会主动断开”。服务端需要在事件循环里统一管理空闲连接、心跳请求和心跳响应超时,并确保连接有活动时能低成本续期。本节给出一个可落地的定时器模型,并说明什么时候该用最小堆,什么时候该换时间轮。

学习目标

  • 区分空闲超时、心跳发送周期与心跳响应超时
  • 使用集中式定时器管理器在事件循环中续期和回收连接
  • 根据连接规模与时间精度选择最小堆或时间轮

先把不同的超时拆开

空闲超时用于回收长期没有有效业务流量的连接;心跳周期决定什么时候主动发送 PING;心跳响应超时则只在已经发出心跳后生效,用于判断对端是否还活着。把三者合成一个“超时时间”会让正常的低频连接被误杀,也会让失联连接回收过慢。

计时项 起点 到期动作
空闲超时 最近一次有效读写 关闭长期无业务活动的连接
心跳周期 最近一次业务活动或上次心跳 发送 PING,进入等待响应状态
心跳响应超时 发出 PING 未收到 PONG 则关闭连接

所有截止时间都应基于单调时钟,而不是墙上时间。系统时间被 NTP 校正或人工修改时,单调时钟仍保持只向前推进,适合做超时判断。

连接超时与心跳状态迁移

定时器不要一连接一线程

高并发服务通常让一个 Reactor 管理成千上万个连接,因此不应为每个连接创建线程,也不应为每个连接单独创建 timerfd。更常见的做法是维护一个集中式定时器结构,只让事件循环知道“最近一个截止时间”。

使用最小堆时,堆顶就是最近到期的定时器,插入和弹出复杂度为 O(log⁡N)O(\log N)。连接活动后可以直接压入一个新截止时间,并给连接递增版本号;旧定时器到期时发现版本号已经过期,就直接忽略。这避免了在堆中查找并删除旧节点的复杂操作。

时间轮则把截止时间映射到固定时间槽。对大量、精度较粗且超时区间相近的连接,插入和到期扫描通常可以做到摊还 O(1)O(1);代价是时间精度受 tick 影响,长超时还需要记录轮数或使用分层时间轮。

用版本号实现可续期的定时器

下面用整数秒模拟事件循环时间,避免真实睡眠造成不可重复的输出。idleGen 和 pongGen 分别标识当前有效的空闲定时器与心跳响应定时器;续期时只增加版本并压入新节点,不立即删除旧节点。

cpp
#include <cstdint>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <vector>

enum class TimerKind { Idle, Pong };

struct Timer {
    long deadline;
    int fd;
    std::uint64_t generation;
    TimerKind kind;
};

struct Earlier {
    bool operator()(const Timer& a, const Timer& b) const {
        return a.deadline > b.deadline;
    }
};

struct Connection {
    long lastActivity = 0;
    std::uint64_t idleGen = 0;
    std::uint64_t pongGen = 0;
    bool awaitingPong = false;
    bool closed = false;
};

class TimerManager {
public:
    void add(int fd, long now) {
        connections_[fd] = Connection{now};
        scheduleIdle(fd);
    }

    void touch(int fd, long now) {
        auto& c = connections_.at(fd);
        if (c.closed) return;
        c.lastActivity = now;
        scheduleIdle(fd);
    }

    void sendPing(int fd, long now) {
        auto& c = connections_.at(fd);
        if (c.closed || c.awaitingPong) return;

        c.awaitingPong = true;
        ++c.pongGen;
        timers_.push(Timer{now + kPongTimeout, fd, c.pongGen, TimerKind::Pong});
        std::cout << "PING fd=" << fd << " at=" << now << "\n";
    }

    void onPong(int fd, long now) {
        auto& c = connections_.at(fd);
        if (c.closed || !c.awaitingPong) return;

        c.awaitingPong = false;
        ++c.pongGen;  // 让旧的 pong deadline 失效。
        std::cout << "PONG fd=" << fd << " at=" << now << "\n";
        touch(fd, now);
    }

    void advance(long now) {
        while (!timers_.empty() && timers_.top().deadline <= now) {
            Timer timer = timers_.top();
            timers_.pop();

            auto it = connections_.find(timer.fd);
            if (it == connections_.end() || it->second.closed) continue;
            Connection& c = it->second;

            if (timer.kind == TimerKind::Idle) {
                if (timer.generation != c.idleGen) continue;
                close(timer.fd, now, "idle timeout");
            } else {
                if (timer.generation != c.pongGen || !c.awaitingPong) continue;
                close(timer.fd, now, "heartbeat timeout");
            }
        }
    }

private:
    static constexpr long kIdleTimeout = 10;
    static constexpr long kPongTimeout = 3;

    std::unordered_map<int, Connection> connections_;
    std::priority_queue<Timer, std::vector<Timer>, Earlier> timers_;

    void scheduleIdle(int fd) {
        auto& c = connections_.at(fd);
        ++c.idleGen;
        timers_.push(Timer{
            c.lastActivity + kIdleTimeout,
            fd,
            c.idleGen,
            TimerKind::Idle
        });
    }

    void close(int fd, long now, const char* reason) {
        auto& c = connections_.at(fd);
        c.closed = true;
        c.awaitingPong = false;
        ++c.idleGen;
        ++c.pongGen;
        std::cout << "CLOSE fd=" << fd
                  << " reason=" << reason
                  << " at=" << now << "\n";
    }
};

int main() {
    TimerManager manager;
    manager.add(10, 0);
    manager.add(20, 0);

    manager.touch(10, 4);   // fd=10 的旧 idle 定时器将变成陈旧节点。
    manager.advance(10);    // fd=20 空闲超时,fd=10 不会被旧节点误关。

    manager.sendPing(10, 10);
    manager.onPong(10, 12);
    manager.advance(13);    // 旧 pong 定时器已经失效。

    manager.sendPing(10, 15);
    manager.advance(18);    // 第二次心跳没有收到 PONG。
}

把源码保存为 timer_demo.cpp 后编译并运行:

bash
c++ -std=c++17 -O2 -Wall -Wextra timer_demo.cpp -o timer_demo && ./timer_demo

预期输出:

text
CLOSE fd=20 reason=idle timeout at=10
PING fd=10 at=10
PONG fd=10 at=12
PING fd=10 at=15
CLOSE fd=10 reason=heartbeat timeout at=18

这个版本故意保留陈旧堆节点,以换取简单的续期操作。生产系统要监控“堆节点数 / 活跃连接数”的比例;如果陈旧节点长期堆积,可以在低负载时重建堆,或改用支持删除的索引堆。

接入 Reactor 时怎样安排唤醒

最小堆方案可以把“距离堆顶截止时间还有多少毫秒”作为 epoll_wait 的 timeout;也可以只维护一个 timerfd,每次堆顶变化时把它重新设置为最近的绝对截止时间,并把 timerfd 本身注册进 epoll。后一种方式能让 socket、跨线程唤醒和定时器都走同一事件入口。

处理连接活动时,先更新连接状态并续期;处理定时事件时,再校验版本号和当前连接状态。即使“收到 PONG”与“心跳截止”非常接近,只要事件循环在关闭前再次检查 awaitingPong 和版本号,就不会仅凭一个陈旧定时器误关连接。

什么时候换成时间轮

当连接数达到很大规模、超时精度只需要几十毫秒到秒级、而且大量连接共享相近超时时间时,时间轮通常比堆更合适。每次活动把连接节点移动到新的槽位,tick 到达后只扫描当前槽;对于超过一圈的截止时间,可以记录剩余轮数,或使用分层时间轮覆盖更长范围。

无论选择最小堆还是时间轮,真正的设计目标都一样:只有事件循环修改连接生命周期,定时器只提供“该检查谁了”的提示。到期时必须重新校验连接当前状态,而不是把旧定时器当成不可撤销的关闭命令。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

连接超时和心跳怎样实现

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通