redis中的io多线程(线程池)

redis多线程模型

redis为什么引入I/O多线程

Redis 的性能瓶颈在网络 IO 的处理上。Redis 是网络 IO 密集型,需要同时处理多条并发请求,读写 IO 的问题(请求大量数据,写日志业务等)。多线程处理网络 IO,单线程执行命令。

Redis 线程池作用读写 IO 阶段,即 read, decode 和 encode, send 阶段。主线程处理业务逻辑,之所以用单线程执行命令,是因为 Redis 采用高效的数据结构,其业务逻辑处理较快。

在这里插入图片描述

I/O多线程模型

主线程拥有两个全局队列clients_pending_readclients_pending_write,每个 io 线程(主线程同时也是 io 线程)拥有一个专属队列 io_threads_list[id]。主线程既作为生产者,产生任务;又作为消费者,获取任务执行。

首先,主线程将一次循环的所有就绪的读事件收集到自己的全局任务队列clients_pending_read中,再把每个事件负载均衡地分配到每个 io 线程的专属任务队列中。一次事件循环中不会出现同名 fd,不同的 fd 分配到每个 io 线程各自的队列中,避免了多个 io 线程同时从全局队列中取数据,因此,不需要加锁操作。

接下来,io 线程从自己的专属队列中取出任务,(除主线程外)并发执行 read 和 decode 操作。主线程将解析后的任务做 compute 操作。最后,io 线程(包括主线程)并发执行 encode 和 send 操作。

在这里插入图片描述

redis的单线程是指,命令执行(logic)都是在单线程中运行的
接受数据read和发送数据write都是可以在io多线程(线程池)中去运行

在Redis中,生产者也可以作为消费者,反之亦然,没有明确界限。

源码解析

测试设置

redis 线程池默认作用在 encode, send 阶段,这是因为客户端从 redis 获取大量数据需要并发处理。若想作用在 read, decode 阶段,需要手动开启。在 redis.conf 文件中,可以设置:

 # 开启io线程的数量
 io-threads 4
 
 # 优化:read deconde 过程。默认优化,encode send从 redis 获取大量数据
 io-threads-do-reads yes

开启 io 多线程的前提是有多个并发连接。如何在单个连接的情况下,开启 io 多线程调试,需要修改 redis 源码:

 // networking.c
 int stopThreadedIOIfNeeded(void) {
     // 单个连接的情况下,开启多线程调试,永远不关闭 io 多线程
     return 0;   
     ...
 }

连接建立

主线程处理连接建立,listenfd

  • 连接到达,触发读事件回调:acceptTcpHandler
  • 接收连接:acceptTcpHandler
  • 初始化新连接:createClient
 // server.c
 void initServer(void) {
    ...
    // 1、连接到来,触发读事件回调
    if (aeCreateFileEvent(server.el, server.ipfd[j], AE_READABLE,
             acceptTcpHandler,NULL) == AE_ERR)  
    ...
 }
 
 // networking.c
 void acceptTcpHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
     ...
     while(max--) {
         // 2、接收连接:内部封装 accept
         cfd = anetTcpAccept(server.neterr, fd, cip, sizeof(cip), &cport);
         ...
         // 为 cfd 初始化新连接,内部调用 createClient
         acceptCommonHandler(connCreateAcceptedSocket(cfd),0,cip);
     }
 }
 
 static void acceptCommonHandler(connection *conn, int flags, char *ip) {
     ...
     /* Create connection and client */
     // 3、创建新的连接
     if ((c = createClient(conn)) == NULL) {
         ...
     }
     ...
 }
 
 client *createClient(connection *conn) {
    client *c = zmalloc(sizeof(client));

    /* passing NULL as conn it is possible to create a non connected client.
     * This is useful since all the commands needs to be executed
     * in the context of a client. When commands are executed in other
     * contexts (for instance a Lua script) we need a non connected client. */
    if (conn) {
        connNonBlock(conn);
        connEnableTcpNoDelay(conn);
        if (server.tcpkeepalive)
            connKeepAlive(conn,server.tcpkeepalive);
        // 4.接收数据的读事件触发,回调readQueryFromClient函数
        connSetReadHandler(conn, readQueryFromClient);
        connSetPrivateData(conn, c);
    }
}

数据传输

clientfd

  • 读事件回调:readQueryFromClient

  • 分割并处理数据包 processInputBuffer

    • 分割数据包:processInlineBuffer 和 processMultibulkBuffer
    • 处理数据包:processCommandAndResetClient
  • 数据写到 buffer:addReply

  • 数据写到 socket:writeToClient

  • 写事件回调:sendReplyToClient

当读事件触发时,执行读事件回调函数。主线程收集读事件就绪的连接放入全局任务队列``clients_pending_read,并设置连接状态为CLIENT_PENDING_READ`。子线程从该全局队列中获取任务后,也调用该读事件回调函数,进行 read 和 decode 的业务逻辑处理。

// networking.c
 void readQueryFromClient(connection *conn) {
     ...
     /* Check if we want to read from the client later when exiting from
      * the event loop. This is the case if threaded I/O is enabled. */
     // 开启 io 线程后,延迟处理客户端的读,将任务丢到全局队列,再分配给 io 线程
     // 主线程返回 1,不执行业务逻辑处理;
     // 子线程返回 0,继续往下,执行业务逻辑处理
     if (postponeClientRead(c)) return;  
 
     // 1、read 阶段,(io 线程)将任务读到缓冲区 
     nread = connRead(c->conn, c->querybuf+qblen, readlen);
 
     // 2、decode 阶段,(io 线程)解析数据包
      processInputBuffer(c);
 }
 
 int postponeClientRead(client *c) {
     if (server.io_threads_active &&
         server.io_threads_do_reads &&
         !clientsArePaused() &&
         !ProcessingEventsWhileBlocked &&
         !(c->flags & (CLIENT_MASTER|CLIENT_SLAVE|CLIENT_PENDING_READ)))
     {
         // 主线程,返回 1
         // 将连接状态设置为 CLIENT_PENDING_READ
         c->flags |= CLIENT_PENDING_READ;
         // 收集任务,把客户端连接放到全局队列中,后续会分配到 io 线程
         listAddNodeHead(server.clients_pending_read,c);
         return 1;
     } else {
         // 子线程,即 io 线程,返回 0
         return 0;
     }
 }

子线程(IO 线程)从专属任务队列 io_threads_pending获取任务,执行 read decode 和 encode write 业务逻辑处理。

// networking.c
 // 线程池入口函数:子线程
 void *IOThreadMain(void *myid) {
     ...
     while(1) {
         /* Wait for start */
         // 等待获取专属任务队列中的任务
         for (int j = 0; j < 1000000; j++) {
             if (io_threads_pending[id] != 0) break;
         }      
         ...
         /* Process: note that the main thread will never touch our list
          * before we drop the pending count to 0. */
         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) {
                 // encode 和 write
                 writeToClient(c,0);
             } else if (io_threads_op == IO_THREADS_OP_READ) {
                 // read 和 decode,读事件回调函数
                 readQueryFromClient(c->conn);
             } else {
                 serverPanic("io_threads_op value is unknown");
             }
         }
         listEmpty(io_threads_list[id]);
         io_threads_pending[id] = 0;
         ...
     }
 }

子线程 decode 结束后,设置连接状态 CLIENT_PENDING_COMMAND,交给主线程来 compute,退出读事件回调函数。主线程负责 compute ,解析 redis 命令。

// networking.c
 // readQueryFromClient 函数中 decode 阶段调用
 void processInputBuffer(client *c) {
     /* Keep processing while there is something in the input buffer */
     while(c->qb_pos < sdslen(c->querybuf)) {
     ...
         if (c->reqtype == PROTO_REQ_INLINE) {
             // 分割数据包。并判断是否完整
             if (processInlineBuffer(c) != C_OK) break;
             ...
         } else if (c->reqtype == PROTO_REQ_MULTIBULK) {
             // 分割 pipline 的数据包,并判断是否完整
             if (processMultibulkBuffer(c) != C_OK) break;
         }
         ...
         else {
             /* If we are in the context of an I/O thread, we can't really
              * execute the command here. All we can do is to flag the client
              * as one that needs to process the command. */
             // io 线程设置任务状态,交给主线程compute,退出读事件回调函数
             if (c->flags & CLIENT_PENDING_READ) {
                 c->flags |= CLIENT_PENDING_COMMAND;
                 break;
             }/* We are finally ready to execute the command. */
             // 3、compute,主线程解析命令
             if (processCommandAndResetClient(c) == C_ERR) {
                 /* If the client is no longer valid, we avoid exiting this
                  * loop and trimming the client buffer later. So we return
                  * ASAP in that case. */
                 return;
             }
         }
     }
     ...
 }

主线程 compute 结束后,调用 addReply 函数,将处理完的连接放到全局任务队列clients_pending_write,并将待发送的数据写到缓冲区。

// networking.c
 int processCommandAndResetClient(client *c) {
     ...
     // 处理命令
     if (processCommand(c) == C_OK) {
         commandProcessed(c);
     }
     ...
 }
 
 // server.c
 int processCommand(client *c) {
     ...
     /* Exec the command */
     // 开启 io 多线程,且不是事务命令
     if (c->flags & CLIENT_MULTI &&
         c->cmd->proc != execCommand && c->cmd->proc != discardCommand &&
         c->cmd->proc != multiCommand && c->cmd->proc != watchCommand)
     {
         // 把数据写到缓冲区
         addReply(c,shared.queued);
     } else {
         // 执行 redis 命令
         call(c,CMD_CALL_FULL);
         ...
     }
     ...
 }// networking.c
 // 数据写到发送缓冲区
 void addReply(client *c, robj *obj) {
     if (prepareClientToWrite(c) != C_OK) return;
     ...
 }int prepareClientToWrite(client *c) {
     ...
     if (!clientHasPendingReplies(c) && !(c->flags & CLIENT_PENDING_READ))
             clientInstallWriteHandler(c);   // 任务写到全局队列中
     ...
 }

接下来,子线程和主线程都可以从自己的专属任务队列中获得该任务,执行 encode 和 send 的业务逻辑处理 writeToClient。若数据未发送完,则注册写事件回调,等待再次发送。

// 子线程:线程池入口函数
 void *IOThreadMain(void *myid) {
     ... 
         if (io_threads_op == IO_THREADS_OP_WRITE) {
             // encode 和 write
             writeToClient(c,0); // 数据写到 socket
         } else if (io_threads_op == IO_THREADS_OP_READ) {
             // read 和 decode
             readQueryFromClient(c->conn); // 读事件回调函数
     ...
 }
 // 主线程
 int handleClientsWithPendingWritesUsingThreads(void) {
     int processed = listLength(server.clients_pending_write);
    if (processed == 0) return 0; /* Return ASAP if there are no clients. */

    /* If I/O threads are disabled or we have few clients to serve, don't
     * use I/O threads, but the boring synchronous code. */
    if (server.io_threads_num == 1 || stopThreadedIOIfNeeded()) {//判断是否有必要开启IO多线程
        return handleClientsWithPendingWrites();
    }

    /* Start threads if needed. */
    if (!server.io_threads_active) startThreadedIO();//开启io多线程

    /* Distribute the clients across N different lists. */
    listIter li;
    listNode *ln;
    listRewind(server.clients_pending_write,&li);//创建一个迭代器li,用于遍历任务队列clients_pending_write
    int item_id = 0;//默认是0,先分配给主线程去做(生产者也可能是消费者),如果设置成1,则先让io线程1去做
    //io_threads_list[0] 主线程
    //io_threads_list[1] io线程
    //io_threads_list[2] io线程   
    //io_threads_list[3] io线程   
    //io_threads_list[4] io线程
    while((ln = listNext(&li))) {
        client *c = listNodeValue(ln);//取出一个任务
        c->flags &= ~CLIENT_PENDING_WRITE;

        /* Remove clients from the list of pending writes since
         * they are going to be closed ASAP. */
        if (c->flags & CLIENT_CLOSE_ASAP) {//表示该客户端的输出缓冲区超过了服务器允许范围,将在下一次循环进行一个关闭,也不返回任何信息给客户端,删除待读客户端
            listDelNode(server.clients_pending_write, ln);
            continue;
        }

        /* Since all replicas and replication backlog use global replication
         * buffer, to guarantee data accessing thread safe, we must put all
         * replicas client into io_threads_list[0] i.e. main thread handles
         * sending the output buffer of all replicas. */
        if (getClientType(c) == CLIENT_TYPE_SLAVE) {
            listAddNodeTail(io_threads_list[0],c);
            continue;
        }
        //负载均衡:将任务队列中的任务 添加 到不同的线程消费队列中去,每个线程就可以从当前线程的消费队列中取任务就行了
        //这样做的好处是,避免加锁。当前是在主线程中,进行分配任务
        //通过取余操作,将任务均分给不同io线程
        int target_id = item_id % server.io_threads_num;
        listAddNodeTail(io_threads_list[target_id],c);
        item_id++;
    }

    /* Give the start condition to the waiting threads, by setting the
     * start condition atomic var. */
    io_threads_op = IO_THREADS_OP_WRITE;
    for (int j = 1; j < server.io_threads_num; j++) {
        int count = listLength(io_threads_list[j]);
        setIOPendingCount(j, count);//设置io线程启动条件,启动io线程
    }
     
     /* Also use the main thread to process a slice of clients. */
     // 让主线程去处理一部分任务
     listRewind(io_threads_list[0],&li);
     while((ln = listNext(&li))) {
         client *c = listNodeValue(ln);
         writeToClient(c,0); 
     }
     listEmpty(io_threads_list[0]);
     
      /* Wait for all the other threads to end their work. */
    while(1) {//剩下的任务io_threads_list[1],io_threads_list[2].....给io线程去做,等待io线程完成任务
        unsigned long pending = 0;
        for (int j = 1; j < server.io_threads_num; j++)
            pending += getIOPendingCount(j);//等待io线程结束,并返回处理的数量
        if (pending == 0) break;
    }

    io_threads_op = IO_THREADS_OP_IDLE;
     
     /* Run the list of clients again to install the write handler where
      * needed. */
     listRewind(server.clients_pending_write,&li);
     while((ln = listNext(&li))) {
         client *c = listNodeValue(ln);
         /* Install the write handler if there are pending writes in some
          * of the clients. */
         // 数据没写完,注册写事件回调
         if (clientHasPendingReplies(c) &&
                 connSetWriteHandler(c->conn, sendReplyToClient) == AE_ERR)
         {
             freeClientAsync(c);
         }
     }
     listEmpty(server.clients_pending_write);
     ...
 }

负载均衡:将任务队列中的任务 添加 到不同的线程消费队列中去,每个线程就可以从当前线程的消费队列中取任务就行了。这样做的好处是,避免加锁。当前是在主线程中,进行分配任务通过取余操作,将任务均分给不同的io线程。

线程调度

开启io线程startThreadedIO

每个io线程都有一把锁,如果主线程把锁还回去了,那么io线程就会启动,不再阻塞
并设置io线程标识为活跃状态io_threads_active=1

void startThreadedIO(void) {
    serverAssert(server.io_threads_active == 0);
    for (int j = 1; j < server.io_threads_num; j++)
        pthread_mutex_unlock(&io_threads_mutex[j]);
    server.io_threads_active = 1;
}
关闭io线程stopThreadedIO

每个io线程都有一把锁,如果主线程拿了,那么io线程就会阻塞等待,也就是停止了IO线程
并设置io线程标识为非活跃状态io_threads_active=0

void stopThreadedIO(void) {
    /* We may have still clients with pending reads when this function
     * is called: handle them before stopping the threads. */
    handleClientsWithPendingReadsUsingThreads();
    serverAssert(server.io_threads_active == 1);
    for (int j = 1; j < server.io_threads_num; j++)
        pthread_mutex_lock(&io_threads_mutex[j]);//
    server.io_threads_active = 0;
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值