class Connection {
    enum class TimerKind { Idle, RequestDeadline, AuthSessionExpiry, RateLimitWindow };
    struct Timer { TimerKind kind; Clock::time_point at; std::string sessionId; };
    std::vector<Timer> timers_;
public:
    void addAuthSessionTimer(const std::string& sid, Clock::time_point at);  // 给 AuthService 用
    void addRateLimitTimer(Clock::time_point at);                            // 给 RateLimiter 用
    void onTick(Clock::time_point now) {
        for (const Timer& t : takeDue(now)) {
            switch (t.kind) {
            case TimerKind::Idle:
                close("idle"); break;
            case TimerKind::RequestDeadline:
                failPending(Status::Timeout); break;
            case TimerKind::AuthSessionExpiry:
                auth_->onSessionExpired(t.sessionId); break;
            case TimerKind::RateLimitWindow:
                limiter_->resetWindow(id_); break;
            }
        }
    }
};

"按到期时间排序、到点触发"是通用机制；认证会话过期、限流窗口重置是别人家的专用细节，却都写进了 Connection（第 2、6～7、15～18 行）。Connection 因此要知道 auth_ 和 limiter_，那两个模块也要知道 Connection 的专用方法。再加一种定时器，就得改枚举、加方法、加分支。

// 通用机制：只负责"到点调用回调"，不知道每个定时器是干什么的。
// 回调在事件循环线程里执行；取消已触发或不存在的 id 是无害的空操作。
class TimerQueue {
public:
    using Id = uint64_t;
    Id schedule(Clock::time_point at, std::function<void()> fn);
    void cancel(Id id);
    void runDue(Clock::time_point now);   // 事件循环每轮调用一次
};

// 具体细节：每个模块自己定义自己的定时器
void Connection::armIdleTimer() {
    timers_.cancel(idleTimer_);
    idleTimer_ = timers_.schedule(Clock::now() + opts_.idleTimeout,
                                  [this] { close("idle"); });
}
void AuthService::startSession(const Session& s) {
    expiry_[s.id] = timers_.schedule(s.expiresAt, [this, id = s.id] { expire(id); });
}

// 组合策略：各种超时设多长、断线时取消哪些定时器，由顶层组装代码决定
Server::Server(const Config& cfg)
    : conns_(timers_, {.idleTimeout = cfg.idleTimeout}),
      auth_(timers_, {.sessionTtl = cfg.sessionTtl}) {}

TimerQueue 可以原封不动地用在任何事件循环里；每种定时器只被一个模块理解；"超时设多长"这类策略集中在顶层配置。三部分可以各自理解、各自修改。

struct node { struct node *prev, *next; };
struct list { struct node *head, *tail; };

void list_remove(struct list *l, struct node *n) {
    if (n->prev) n->prev->next = n->next; else l->head = n->next;
    if (n->next) n->next->prev = n->prev; else l->tail = n->prev;
}
void list_push_back(struct list *l, struct node *n) {
    n->next = NULL; n->prev = l->tail;
    if (l->tail) l->tail->next = n; else l->head = n;
    l->tail = n;
}

每个修改操作都要区分"是不是头""是不是尾""链表是不是空的"。每多一种操作（插到某节点前、拼接两个链表），这些分支就再写一遍，漏掉一个就是空指针。

/* 环形链表，head 是哨兵节点，不存数据。
 * 空链表：head.next == head.prev == &head。 */
struct list { struct node head; };

void list_init(struct list *l) { l->head.next = l->head.prev = &l->head; }

void list_remove(struct node *n) {
    n->prev->next = n->next;
    n->next->prev = n->prev;
}
void list_push_back(struct list *l, struct node *n) {
    n->prev = l->head.prev;  n->next = &l->head;
    l->head.prev->next = n;  l->head.prev = n;
}

每个节点的前后永远有邻居（最坏情况下就是哨兵本身），"空""头""尾"不再是特殊情况，list_remove 甚至不需要知道节点属于哪个链表。Linux 内核的 list_head 就是这样设计的。代价：遍历的终止条件从"遇到 NULL"变成"回到 &head"，新手容易写错；需要判断"是否为空"的地方仍然要判断，只是只剩真正需要的那几处。