小红书抗住高并发的背后：Redis 7.0 性能必杀技之 I/O 多线程模型

io-threads 4

/* networking.c */
void initThreadedIO(void) {
   // 设置成 0 表示激活 I/O 多线程模型
    server.io_threads_active = 0;
    /* I/O 线程处于空闲状态 */
    io_threads_op = IO_THREADS_OP_IDLE;

    /* 如果 redis.conf 的 io-threads 配置为 1 表示使用单线程模型，直接退出 */
    if (server.io_threads_num == 1) return;

    // 线程数超过最大值 128，退出程序
    if (server.io_threads_num > IO_THREADS_MAX_NUM) {
        ....省略
        exit(1);
    }

    for (int i = 0; i < server.io_threads_num; i++) {
        /*  io_threads_list 链表，用于存储该线程要执行的 I/O 操作。*/
        io_threads_list[i] = listCreate();
        // 0 号线程不创建，0 号就是主线程，主线程也会处理任务逻辑。
        if (i == 0) continue;

        // 创建线程，主线程先对子线程上锁，挂起子线程，不让其进入工作模式
        pthread_t tid;
        pthread_mutex_init(&io_threads_mutex[i],NULL);
        setIOPendingCount(i, 0);
        // 挂起子线程，先不进入工作模式，等待主线程发出干活信号再执行任务。
        pthread_mutex_lock(&io_threads_mutex[i]);
        // 创建线程，指定I/O线程的入口函数 IOThreadMain
        if (pthread_create(&tid,NULL,IOThreadMain,(void*)(long)i) != 0) {
            serverLog(LL_WARNING,"Fatal: Can't initialize IO thread.");
            exit(1);
        }
        // I/O 线程数组
        io_threads[i] = tid;
    }
}

void *IOThreadMain(void *myid) {
    /* 每个线程创建一个 id */
    long id = (unsigned long)myid;
    char thdname[16];
    .....
    // 进入无限循环，等待主线程发出干活信号
    while(1) {
        /* 没有使用 sleep 设置等待时间实现忙等，而是循环，耗费 CPU*/
        for (int j = 0; j < 1000000; j++) {
            // 等待待处理的 I/O 操作出现，也就是读写客户端数据
            if (getIOPendingCount(id) != 0) break;
        }

        /*留机会给主线程上锁，挂起当前子线程 */
        if (getIOPendingCount(id) == 0) {
            pthread_mutex_lock(&io_threads_mutex[id]);
            pthread_mutex_unlock(&io_threads_mutex[id]);
            continue;
        }

        serverAssert(getIOPendingCount(id) != 0);

        /* 根据线程 id 以及待分配列表进行任务分配 */
        listIter li;
        listNode *ln;
        listRewind(io_threads_list[id],&li);
        while((ln = listNext(&li))) {
            client *c = listNodeValue(ln);
            if (io_threads_op == IO_THREADS_OP_WRITE) {
                // 将可写客户端任务分配
                writeToClient(c,0);
            } else if (io_threads_op == IO_THREADS_OP_READ) {
                // 读取客户端 socket 数据
                readQueryFromClient(c->conn);
            } else {
                serverPanic("io_threads_op value is unknown");
            }
        }

        listEmpty(io_threads_list[id]);
        setIOPendingCount(id, 0);
    }
}

int handleClientsWithPendingReadsUsingThreads(void) {
    ......

    /* 将所有待处理的客户端平均分配到不同的 I/O 线程的列表中*/
    listIter li;
    listNode *ln;
    listRewind(server.clients_pending_read,&li);
    int item_id = 0;
    while((ln = listNext(&li))) {
        client *c = listNodeValue(ln);
        int target_id = item_id % server.io_threads_num;
        listAddNodeTail(io_threads_list[target_id],c);
        item_id++;
    }

    /* 通过设置 `io_threads_op` 和调用 `setIOPendingCount` 函数，通知各个 I/O 线程开始处理可读取的客户端数据。 */
    io_threads_op = IO_THREADS_OP_READ;
    for (int j = 1; j < server.io_threads_num; j++) {
        int count = listLength(io_threads_list[j]);
        setIOPendingCount(j, count);
    }

    /* 主线程处理第一个等待队列任务 */
    listRewind(io_threads_list[0],&li);
    while((ln = listNext(&li))) {
        client *c = listNodeValue(ln);
        readQueryFromClient(c->conn);
    }
    listEmpty(io_threads_list[0]);

    /* 主线程处理完任务后，忙等等待所有 I/O 线程完成读取 socket 工作 */
    while(1) {
        unsigned long pending = 0;
        for (int j = 1; j < server.io_threads_num; j++)
            pending += getIOPendingCount(j);
        if (pending == 0) break;
    }

    ......

    return processed;
}