10 万 QPS 的单线程 Redis,卡在一条 HGETALL 上

周三下午,P99 从 1.2ms 跳到 410ms

监控告警弹出来的时候,第一反应是网络抖动:P99 从 1.2ms 跳到 410ms,QPS 从 9 万掉到 4 万。但集群 CPU 空闲率 70%,内存稳定,网络没有丢包,连接数也没涨。

翻 slowlog,里面孤零零躺着一条 700ms 的命令:一个后台导出功能对 200MB、80 万 field 的 Hash 执行了 HGETALL。同一条命令,那天被执行了 40 多次。

Redis 是单线程的,一条命令执行期间,其余所有连接的命令都得等它。这不是性能问题,是模型本身的特点。

先给结论:Redis 的 10 万 QPS 不是因为它算得快,是因为它从不停下来等。代价是它也不允许任何一条命令停下来。下面从 aeMain 开始,跟到 epoll_wait,讲清这份 QPS 的来源和它的边界。

入口:整个 Redis 只有一个 while

不管集群多大、连接多少,每个 Redis 实例的主线程都在跑同一个循环:

void aeMain(aeEventLoop *eventLoop) {
    eventLoop->stop = 0;
    while (!eventLoop->stop) {
        aeProcessEvents(eventLoop, AE_ALL_EVENTS |
                                   AE_CALL_BEFORE_SLEEP |
                                   AE_CALL_AFTER_SLEEP);
    }
}

int aeProcessEvents(aeEventLoop *eventLoop, int flags) {
    int processed = 0, numevents;

    if (eventLoop->maxfd != -1 ||
        ((flags & AE_TIME_EVENTS) && !(flags & AE_DONT_WAIT))) {
        struct timeval tv, *tvp = NULL;
        // tvp 由最近的时间事件算出,省略计算过程
        numevents = aeApiPoll(eventLoop, tvp);   // 阻塞在这里等事件
        for (int j = 0; j < numevents; j++) {
            // 逐个处理就绪 fd,下一节展开
        }
    }
    if (flags & AE_TIME_EVENTS)
        processed += processTimeEvents(eventLoop); // serverCron 在这跑
    return processed;
}

aeEventLoop 里只有两样东西:一张 fd 表(每个 fd 挂读回调和写回调),和一条时间事件链表。没有工作队列,没有线程池,也没有任务分发。所有网络请求和定时任务,都在这个 while 里串行执行。

一次 epoll_wait 之后,发生了什么

1 aeApiPoll:阻塞,但不是死等

Linux 下 aeApiPoll 就是 epoll_wait 的一层薄封装:

static int aeApiPoll(aeEventLoop *eventLoop, struct timeval *tvp) {
    aeApiState *state = eventLoop->apidata;
    int retval, numevents = 0;

    retval = epoll_wait(state->epfd, state->events, eventLoop->setsize,
            tvp ? (tvp->tv_sec*1000 + (tvp->tv_usec + 999)/1000) : -1);
    if (retval > 0) {
        numevents = retval;
        for (int j = 0; j < numevents; j++) {
            int mask = 0;
            struct epoll_event *e = state->events + j;
            if (e->events & EPOLLIN)  mask |= AE_READABLE;
            if (e->events & EPOLLOUT) mask |= AE_WRITABLE;
            if (e->events & EPOLLERR) mask |= AE_WRITABLE | AE_READABLE;
            if (e->events & EPOLLHUP) mask |= AE_WRITABLE | AE_READABLE;
            eventLoop->fired[j].fd = e->data.fd;
            eventLoop->fired[j].mask = mask;
        }
    }
    return numevents;
}

两个细节值得注意。第一,tvp 不是随便给,它等于"距离最近一个时间事件还有多久",所以 serverCron 能按时跑;没有时间事件时才传 NULL 死等。第二,返回值 numevents 是就绪 fd 的数量,后面的循环只处理这 n 个。复杂度是 O(就绪数),不是 O(连接数),这就是一个线程能管上万连接的原因,也是它不用 select 的原因。

2 事件分发:先写后读,是故意的

拿到就绪 fd 后,每个 fd 都可能同时可读可写。默认顺序是先读后写,但 Redis 在客户端写事件上挂了 AE_BARRIER 标志,顺序会被反过来:

int invert = fe->mask & AE_BARRIER;

if (!invert && fe->mask & mask & AE_READABLE) {
    fe->rfileProc(eventLoop, fd, fe->clientData, mask);
    fired++;
    fe = &eventLoop->events[fd];      /* 回调里可能扩容,重新取 */
}

if (fe->mask & mask & AE_WRITABLE) {
    if (!fired || fe->wfileProc != fe->rfileProc) {
        fe->wfileProc(eventLoop, fd, fe->clientData, mask);
        fired++;
    }
}

if (invert) {
    fe = &eventLoop->events[fd];
    if ((fe->mask & mask & AE_READABLE) &&
        (!fired || fe->wfileProc != fe->rfileProc)) {
        fe->rfileProc(eventLoop, fd, fe->clientData, mask);
        fired++;
    }
}

看着绕,目的只有两个:把已经算好的响应先发出去,减少客户端等待的 RTT;再读这条连接的新命令之前,先把机会让给其他连接。单线程模型里没有调度器帮你切,只能靠这种约定来保证公平——否则一条一直有数据的连接能把循环占死。

fired 那个判断容易被当成优化:真正的作用是防止读回调和写回调恰好是同一个函数指针时,同一轮里被执行两次。命令处理函数和响应发送函数天然不同,所以正常情况下它不会触发,但这里每个分支都必须守住。

3 processTimeEvents:给循环兜底

serverCron 默认 hz=10,也就是每 100ms 一次:抽样过期键、刷 AOF 缓冲、主从同步、集群心跳、更新统计。它跟网络事件共用同一个循环,所以一个慢命令不止拖慢请求,还会拖慢过期键回收和复制——这就是第一批"过期键明明到期却还在"的来源。

过期键的处理方式也踩着同一条线:不扫全库,每次随机抽 20 个带过期时间的 key,删掉过期的,如果这一批里超过 25% 已过期,就再来一轮。它用采样把"删除"摊到很多个 100ms 里,避免一次清理把事件循环卡住——思路和 UNLINK 一样,把大动作切片。

4 6.0 的多 IO 线程,只搬走了读写

io-threads 默认是 1,等于不启用。开到 4 以后,并行的是三件事:从 socket 读数据、解析 RESP、把响应写回 socket。命令执行、数据结构修改、过期键删除,仍然在主线程那一条时间线上。

所以"Redis 6 变多线程"是个误读。它把网络那一段 CPU 从主线程搬走了,并发上限并没有变成 4 倍。官方建议也保守:4 核开 2~3 个,8 核开 6 个,上限 8——再加,线程切换的收益就盖过并发了。

10 万 QPS 的真正来源:把"等待"删掉

四条加起来,才有 10 万这个量级。

纯内存,单条 GET 是哈希查找,微秒级;无锁,没有竞争就没有 CAS 重试和伪共享;事件驱动,等待这件事交给 epoll_wait,线程不挂起;命令短,10 万 QPS 意味着平均 10 微秒处理一条。

最后一条最容易忽略。多线程模型里,一次 IO 等待要经历挂起和唤醒,两次上下文切换大约 2~5 微秒。10 万 QPS 下,光切换就要吃掉小半个 CPU。Redis 干脆不切换——一个线程从头跑到尾,把"并发"交给操作系统,把"串行"留给自己。

有人会问:多核不用是不是浪费。这条时间线上真正难并行的不是计算,是共享数据——同一个 key 的读写必须串行,不同 key 又要抢分片锁,一次加锁解锁加上一次 CAS 重试,就把单条命令几微秒的预算吃光了。Redis 的选择很直白:既然热点本来就要排队,不如让整个实例排一条队,把锁的复杂度降到零,用 6.0 的 IO 线程单独去搬网络那段。

代价也就写在这里:没有队列隔离,任何一次阻塞都是全局阻塞。 一条 700ms 的 HGETALL,等于让 9 万个 QPS 集体排队 700ms,后面的请求还没进来就已经超时了。

这套模型给 Java 服务的启发

Netty 的 EventLoop 和它是同一个形状:一个 selector 线程管 N 个 channel,业务 handler 直接跑在 IO 线程上。所以在 Netty handler 里调数据库、sleep、序列化一个 5MB 的 JSON,和 Redis 里跑 HGETALL 是一回事——只不过 Redis 只有一个实例会疼,你的服务有几百个连接在等。

对应到日常写法:业务处理丢到独立线程池,IO 线程只做编解码;Redis 客户端用 pipeline 或 Lua 把 N 次 RTT 压成 1 次;大 Hash 拆成多个小 key,用 hash tag 保证落在同一个 slot;客户端超时设短,别让连接在池里堆着。

最后,5 条运维纪律

  • QPS 上不去就加 io-threads——命令执行还是串行,慢命令导致的瓶颈加线程没用。
  • KEYS、HGETALL、SMEMBERS 扫全量——单线程模型下,一次全量扫描冻结整个实例。
  • 大 key 直接 DEL——改用 UNLINK,把释放内存的动作挪到后台线程。
  • 单连接循环发命令——用 pipeline,把 N 个网络往返压成 1 个。
  • 拿均值 10 万 QPS 当 SLA——一条 700ms 的命令就能让 P99 直接爆表。

Redis 的单线程是一种设计选择:把等待从模型里删掉,换来一条极短的时间线;代价是所有命令共用这条线。

你们线上有没有被一条 HGETALL 或 KEYS 卡住过?最后是拆 key、换命令,还是直接禁用了?

关注我,每周拆一个真实生产故障。


标题:10 万 QPS 的单线程 Redis,卡在一条 HGETALL 上
作者:jiangyi
地址:http://jiangyi.space/articles/2026/11/11/1794148420491.html
公众号:服务端技术精选
    评论
    0 评论
avatar

取消