redis执行流程源码分析

Redis源码整体运行流程详解 本文所引用的源码全部来自Redis2.8.2版本。 Redis源码整体运行流程的相关文件是:redis.h, redis.c, networking.c, ae.h, ae.c。 转载请注明,本文出自:http://blog.youkuaiyun.com/acceptedxukai/article/details/17842119 Redis Server端处理Client请求的流程图 阅读详情

本文所引用的源码全部来自Redis2.8.2版本。

Redis源码整体运行流程的相关文件是:redis.h, redis.c, networking.c, ae.h, ae.c。

转载请注明,本文出自:http://blog.youkuaiyun.com/acceptedxukai/article/details/17842119


Redis Server端处理Client请求的流程图


main函数


main函数主要的功能为:调用initServerConfig函数,进行默认的redisServer数据结构的参数初始化;调用daemonize函数,为服务器开始守护进程,对于守护进行相关详细信息见http://blog.youkuaiyun.com/acceptedxukai/article/details/8743189;调用initServer函数,初始化服务器;调用loadServerConfig函数,读取Redis的配置文件,使用配置文件中的参数替换默认的参数值;调用aeMain函数,开启事件循环,整个服务器开始工作。

initServer函数


该函数主要为初始化服务器,需要初始化的内容比较多,主要有:

1、创建事件循环

server.el = aeCreateEventLoop(server.maxclients+REDIS_EVENTLOOP_FDSET_INCR);

2、创建TCP与UDP Server,启动服务器,完成bind与listen

/* Open the TCP listening socket for the user commands. */  
    //server.ipfd是个int数组,启动服务器,完成bind,listen  
    if (listenToPort(server.port,server.ipfd,&server.ipfd_count) == REDIS_ERR)  
        exit(1);  
    /* Open the listening Unix domain socket. */  
    if (server.unixsocket != NULL) {  
        unlink(server.unixsocket); /* don't care if this fails */  
        server.sofd = anetUnixServer(server.neterr,server.unixsocket,server.unixsocketperm);  
        if (server.sofd == ANET_ERR) {  
            redisLog(REDIS_WARNING, "Opening socket: %s", server.neterr);  
            exit(1);  
        }  
    }
Redis2.8.2 TCP同时支持IPv4与IPv6,同时与之前版本的Redis不同,此版本支持多个TCP服务器,listenToPort函数主要还是调用anetTcpServer函数,完成socket()-->bind()-->listen(),下面详细查看下TCPServer的创建,UDP直接忽略吧,我也不知道UDP具体用在哪。

static int anetListen(char *err, int s, struct sockaddr *sa, socklen_t len) {  
    //绑定bind  
    if (bind(s,sa,len) == -1) {  
        anetSetError(err, "bind: %s", strerror(errno));  
        close(s);  
        return ANET_ERR;  
    }  
  
    /* Use a backlog of 512 entries. We pass 511 to the listen() call because 
     * the kernel does: backlogsize = roundup_pow_of_two(backlogsize + 1); 
     * which will thus give us a backlog of 512 entries */  
    //监听  
    if (listen(s, 511) == -1) {  
        anetSetError(err, "listen: %s", strerror(errno));  
        close(s);  
        return ANET_ERR;  
    }  
    return ANET_OK;  
}  
static int _anetTcpServer(char *err, int port, char *bindaddr, int af)  
{  
    int s, rv;  
    char _port[6];  /* strlen("65535") */  
    struct addrinfo hints, *servinfo, *p;  
  
    snprintf(_port,6,"%d",port);  
    memset(&hints,0,sizeof(hints));  
    hints.ai_family = af;  
    hints.ai_socktype = SOCK_STREAM;  
    //套接字地址用于监听绑定  
    hints.ai_flags = AI_PASSIVE;    /* No effect if bindaddr != NULL */  
    //可以加上hints.ai_protocol = IPPROTO_TCP;  
  
    /**getaddrinfo(const char *hostname, const char *servicename, 
                   const struct addrinfo *hint,struct addrinfo **res); 
       hostname:主机名 
       servicename: 服务名 
       hint: 用于过滤的模板,仅能使用ai_family, ai_flags, ai_protocol, ai_socktype,其余字段为0 
       res:得到所有可用的地址 
    */  
    if ((rv = getaddrinfo(bindaddr,_port,&hints,&servinfo)) != 0) {  
        anetSetError(err, "%s", gai_strerror(rv));  
        return ANET_ERR;  
    }  
    //轮流尝试多个地址,找到一个允许连接到服务器的地址时便停止  
    for (p = servinfo; p != NULL; p = p->ai_next) {  
        if ((s = socket(p->ai_family,p->ai_socktype,p->ai_protocol)) == -1)  
            continue;  
  
        if (af == AF_INET6 && anetV6Only(err,s) == ANET_ERR) goto error;  
        //设置套接字选项setsockopt,采用地址复用  
        if (anetSetReuseAddr(err,s) == ANET_ERR) goto error;  
        //bind, listen  
        if (anetListen(err,s,p->ai_addr,p->ai_addrlen) == ANET_ERR) goto error;  
        goto end;  
    }  
    if (p == NULL) {  
        anetSetError(err, "unable to bind socket");  
        goto error;  
    }  
  
error:  
    s = ANET_ERR;  
end:  
    freeaddrinfo(servinfo);  
    return s;  
}  
//if server.ipfd_count = 0, bindaddr = NULL  
int anetTcpServer(char *err, int port, char *bindaddr)  
{  
    return _anetTcpServer(err, port, bindaddr, AF_INET);  
}  
3、将listen的端口加入到事件监听中,进行监听,由aeCreateFileEvent函数完成,其注册的listen端口可读事件处理函数为acceptTcpHandler,这样在listen端口有新连接的时候会调用acceptTcpHandler,后者在accept这个新连接,然后就可以处理后续跟这个客户端连接相关的事件了。

    /* Create an event handler for accepting new connections in TCP and Unix 
         * domain sockets. */  
         //文件事件,用于处理响应外界的操作请求,事件处理函数为acceptTcpHandler/acceptUnixHandler  
         //在networking.c  
        for (j = 0; j < server.ipfd_count; j++) {  
            if (aeCreateFileEvent(server.el, server.ipfd[j], AE_READABLE,  
                acceptTcpHandler,NULL) == AE_ERR)  
                {  
                    redisPanic(  
                        "Unrecoverable error creating server.ipfd file event.");  
                }  
        }  
        if (server.sofd > 0 && aeCreateFileEvent(server.el,server.sofd,AE_READABLE,  
            acceptUnixHandler,NULL) == AE_ERR) redisPanic("Unrecoverable error creating server.sofd file event.");  

acceptTcpHandler函数


上面介绍了,initServer完成listen端口后,会加入到事件循环中,该事件为可读事件,并记录处理函数为fe->rfileProc = acceptTcpHandler;该函数分两步操作:用acceptTcpHandler接受这个客户端连接;然第二部初始化这个客户端连接的相关数据,将clientfd加入事件里面,设置的可读事件处理函数为readQueryFromClient,也就是读取客户端请求的函数。

void acceptTcpHandler(aeEventLoop *el, int fd, void *privdata, int mask) {  
    int cport, cfd;  
    char cip[REDIS_IP_STR_LEN];  
    REDIS_NOTUSED(el);//无意义  
    REDIS_NOTUSED(mask);  
    REDIS_NOTUSED(privdata);  
  
    //cfd为accept函数返回的客户端文件描述符,accept使服务器完成一个客户端的链接  
    cfd = anetTcpAccept(server.neterr, fd, cip, sizeof(cip), &cport);  
    if (cfd == AE_ERR) {  
        redisLog(REDIS_WARNING,"Accepting client connection: %s", server.neterr);  
        return;  
    }  
    redisLog(REDIS_VERBOSE,"Accepted %s:%d", cip, cport);  
    //将cfd加入事件循环并设置回调函数为readQueryFromClient,并初始化redisClient  
    acceptCommonHandler(cfd,0);  
}

第一步很简单即完成accept,主要关注第二步acceptCommonHandler函数

    static void acceptCommonHandler(int fd, int flags) {  
        redisClient *c;  
        if ((c = createClient(fd)) == NULL) {//创建新的客户端  
            redisLog(REDIS_WARNING,  
                "Error registering fd event for the new client: %s (fd=%d)",  
                strerror(errno),fd);  
            close(fd); /* May be already closed, just ignore errors */  
            return;  
        }  
        /* If maxclient directive is set and this is one client more... close the 
         * connection. Note that we create the client instead to check before 
         * for this condition, since now the socket is already set in non-blocking 
         * mode and we can send an error for free using the Kernel I/O */  
        //当前连接的客户端数目大于服务器最大运行的连接数,则拒绝连接  
        if (listLength(server.clients) > server.maxclients) {  
            char *err = "-ERR max number of clients reached\r\n";  
      
            /* That's a best effort error message, don't check write errors */  
            if (write(c->fd,err,strlen(err)) == -1) {  
                /* Nothing to do, Just to avoid the warning... */  
            }  
            server.stat_rejected_conn++;  
            freeClient(c);  
            return;  
        }  
        server.stat_numconnections++;  
        c->flags |= flags;  
    }  

createClient函数


此函数用来为新连接的客户端初始化一个redisClient数据结构,该数据结构有比较多的参数,详见redis.h。该函数完成两个操作,第一、为客户端创建事件处理函数readQueryFromClient专门接收客户端发来的指令,第二、初始化redisClient数据结构相关参数。 

    redisClient *createClient(int fd) {  
        redisClient *c = zmalloc(sizeof(redisClient));  
      
        /* passing -1 as fd it is possible to create a non connected client. 
         * This is useful since all the Redis 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. */  
         /** 
            因为 Redis 命令总在客户端的上下文中执行, 
            有时候为了在服务器内部执行命令,需要使用伪客户端来执行命令 
            在 fd == -1 时,创建的客户端为伪终端 
         */  
        if (fd != -1) {  
            //下面三个都是设置socket属性  
            anetNonBlock(NULL,fd);//非阻塞  
            anetEnableTcpNoDelay(NULL,fd);//no delay  
            if (server.tcpkeepalive)  
                anetKeepAlive(NULL,fd,server.tcpkeepalive);//keep alive  
      
            //创建一个accept fd的FileEvent事件,事件的处理函数是readQueryFromClient  
            if (aeCreateFileEvent(server.el,fd,AE_READABLE,  
                readQueryFromClient, c) == AE_ERR)  
            {  
                close(fd);  
                zfree(c);  
                return NULL;  
            }  
        }  
      
        selectDb(c,0);//默认选择第0个db, db.c  
        c->fd = fd;//文件描述符  
        c->name = NULL;  
        c->bufpos = 0;//将指令结果发送给客户端的字符串长度  
        c->querybuf = sdsempty();//请求字符串初始化  
        c->querybuf_peak = 0;//请求字符串顶峰时的长度值  
        c->reqtype = 0;//请求类型  
        c->argc = 0;//参数个数  
        c->argv = NULL;//参数内容  
        c->cmd = c->lastcmd = NULL;//操作指令  
        c->multibulklen = 0;//块个数  
        c->bulklen = -1;//每个块的长度  
        c->sentlen = 0;  
        c->flags = 0;//客户类型的标记,比较重要  
        c->ctime = c->lastinteraction = server.unixtime;  
        c->authenticated = 0;  
        c->replstate = REDIS_REPL_NONE;  
        c->reploff = 0;  
        c->repl_ack_off = 0;  
        c->repl_ack_time = 0;  
        c->slave_listening_port = 0;  
        c->reply = listCreate();//存放服务器应答的数据  
        c->reply_bytes = 0;  
        c->obuf_soft_limit_reached_time = 0;  
        listSetFreeMethod(c->reply,decrRefCountVoid);  
        listSetDupMethod(c->reply,dupClientReplyValue);  
        c->bpop.keys = dictCreate(&setDictType,NULL);//下面三个参数在list数据阻塞操作时使用  
        c->bpop.timeout = 0;  
        c->bpop.target = NULL;  
        c->io_keys = listCreate();  
        c->watched_keys = listCreate();//事务命令CAS中使用  
        listSetFreeMethod(c->io_keys,decrRefCountVoid);  
        c->pubsub_channels = dictCreate(&setDictType,NULL);  
        c->pubsub_patterns = listCreate();  
        listSetFreeMethod(c->pubsub_patterns,decrRefCountVoid);  
        listSetMatchMethod(c->pubsub_patterns,listMatchObjects);  
        // 如果不是伪客户端,那么将客户端加入到服务器客户端列表中  
        if (fd != -1) listAddNodeTail(server.clients,c);//添加到server的clients链表  
        initClientMultiState(c);//初始化事务指令状态  
        return c;  
    }  
客户端的请求指令字符串始终存放在querybuf中,在对querybuf解析后,将指令参数的个数存放在argc中,具体的指令参数存放在argv中;但是服务器应答的结果有两种存储方式:buf字符串、reply列表。

readQueryFromClient函数


readQueryFromClient函数用来读取客户端的请求命令行数据,并调用processInputBuffer函数依照redis通讯协议对数据进行解析。服务器使用最原始的read函数来读取客户端发送来的请求命令,并将字符串存储在querybuf中,根据需要对querybuf进行扩展。

    void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {  
        redisClient *c = (redisClient*) privdata;  
        int nread, readlen;  
        size_t qblen;  
        REDIS_NOTUSED(el);  
        REDIS_NOTUSED(mask);  
      
        server.current_client = c;  
        readlen = REDIS_IOBUF_LEN; //1024 * 16  
        /* If this is a multi bulk request, and we are processing a bulk reply 
         * that is large enough, try to maximize the probability that the query 
         * buffer contains exactly the SDS string representing the object, even 
         * at the risk of requiring more read(2) calls. This way the function 
         * processMultiBulkBuffer() can avoid copying buffers to create the 
         * Redis Object representing the argument. */  
        if (c->reqtype == REDIS_REQ_MULTIBULK && c->multibulklen && c->bulklen != -1  
            && c->bulklen >= REDIS_MBULK_BIG_ARG)  
        {  
            int remaining = (unsigned)(c->bulklen+2)-sdslen(c->querybuf);  
      
            if (remaining < readlen) readlen = remaining;  
        }  
      
        qblen = sdslen(c->querybuf);  
        if (c->querybuf_peak < qblen) c->querybuf_peak = qblen;  
        //对querybuf的空间进行扩展  
        c->querybuf = sdsMakeRoomFor(c->querybuf, readlen);  
        //读取客户端发来的操作指令  
        nread = read(fd, c->querybuf+qblen, readlen);  
        if (nread == -1) {  
            if (errno == EAGAIN) {  
                nread = 0;  
            } else {  
                redisLog(REDIS_VERBOSE, "Reading from client: %s",strerror(errno));  
                freeClient(c);  
                return;  
            }  
        } else if (nread == 0) {  
            redisLog(REDIS_VERBOSE, "Client closed connection");  
            freeClient(c);  
            return;  
        }  
        if (nread) {  
            //改变querybuf的实际长度和空闲长度,len += nread, free -= nread;  
            sdsIncrLen(c->querybuf,nread);  
            c->lastinteraction = server.unixtime;  
            if (c->flags & REDIS_MASTER) c->reploff += nread;  
        } else {  
            server.current_client = NULL;  
            return;  
        }  
        //客户端请求的字符串长度大于服务器最大的请求长度值  
        if (sdslen(c->querybuf) > server.client_max_querybuf_len) {  
            sds ci = getClientInfoString(c), bytes = sdsempty();  
      
            bytes = sdscatrepr(bytes,c->querybuf,64);  
            redisLog(REDIS_WARNING,"Closing client that reached max query buffer length: %s (qbuf initial bytes: %s)", ci, bytes);  
            sdsfree(ci);  
            sdsfree(bytes);  
            freeClient(c);  
            return;  
        }  
        //解析请求  
        processInputBuffer(c);  
        server.current_client = NULL;  
    }  

processInputBuffer函数主要用来处理请求的解析工作,redis有两种解析方式;行指令解析与多重指令解析,行指令解析直接忽略,下面详解多重指令解析。

    void processInputBuffer(redisClient *c) {  
        /* Keep processing while there is something in the input buffer */  
        while(sdslen(c->querybuf)) {  
            /* Immediately abort if the client is in the middle of something. */  
            if (c->flags & REDIS_BLOCKED) return;  
      
            /* REDIS_CLOSE_AFTER_REPLY closes the connection once the reply is 
             * written to the client. Make sure to not let the reply grow after 
             * this flag has been set (i.e. don't process more commands). */  
            if (c->flags & REDIS_CLOSE_AFTER_REPLY) return;  
      
            /* Determine request type when unknown. */  
            //当请求类型未知时,先确定属于哪种请求  
            if (!c->reqtype) {  
                if (c->querybuf[0] == '*') {  
                    c->reqtype = REDIS_REQ_MULTIBULK;//多重指令解析  
                } else {  
                    c->reqtype = REDIS_REQ_INLINE;//按行解析  
                }  
            }  
      
            if (c->reqtype == REDIS_REQ_INLINE) {  
                if (processInlineBuffer(c) != REDIS_OK) break;  
            } else if (c->reqtype == REDIS_REQ_MULTIBULK) {  
                if (processMultibulkBuffer(c) != REDIS_OK) break;  
            } else {  
                redisPanic("Unknown request type");  
            }  
      
            /* Multibulk processing could see a <= 0 length. */  
            if (c->argc == 0) {  
                resetClient(c);  
            } else {  
                /* Only reset the client when the command was executed. */  
                //执行相应指令  
                if (processCommand(c) == REDIS_OK)  
                    resetClient(c);  
            }  
        }  
    }  

多重指令解析的处理函数为processMultibulkBuffer,下面先简单介绍下Redis的通讯协议

    以下是这个协议的一般形式:  
    *< 参数数量 > CR LF  
    $< 参数 1 的字节数量 > CR LF  
    < 参数 1 的数据 > CR LF  
    ...  
    $< 参数 N 的字节数量 > CR LF  
    < 参数 N 的数据 > CR LF  
    举个例子,以下是一个命令协议的打印版本:  
    *3  
    $3  
    SET  
    $3  
    foo  
    $3  
    bar  
    这个命令的实际协议值如下:  
    "*3\r\n$3\r\nSET\r\n$3\r\foo\r\n$3\r\bar\r\n"  

    /** 
        例:querybuf = "*3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$3\r\nbar\r\n" 
    */  
    int processMultibulkBuffer(redisClient *c) {  
        char *newline = NULL;  
        int pos = 0, ok;  
        long long ll;  
      
        if (c->multibulklen == 0) {//参数数目为0,表示这是新的请求指令  
            /* The client should have been reset */  
            redisAssertWithInfo(c,NULL,c->argc == 0);  
      
            /* Multi bulk length cannot be read without a \r\n */  
            newline = strchr(c->querybuf,'\r');  
            if (newline == NULL) {  
                if (sdslen(c->querybuf) > REDIS_INLINE_MAX_SIZE) {  
                    addReplyError(c,"Protocol error: too big mbulk count string");  
                    setProtocolError(c,0);  
                }  
                return REDIS_ERR;  
            }  
      
            /* Buffer should also contain \n */  
            if (newline-(c->querybuf) > ((signed)sdslen(c->querybuf)-2))  
                return REDIS_ERR;  
      
            /* We know for sure there is a whole line since newline != NULL, 
             * so go ahead and find out the multi bulk length. */  
            redisAssertWithInfo(c,NULL,c->querybuf[0] == '*');  
            //将字符串转为long long整数,转换得到的结果存到ll中,ll就是后面参数的个数  
            ok = string2ll(c->querybuf+1,newline-(c->querybuf+1),&ll);  
            if (!ok || ll > 1024*1024) {  
                addReplyError(c,"Protocol error: invalid multibulk length");  
                setProtocolError(c,pos);  
                return REDIS_ERR;  
            }  
      
            pos = (newline-c->querybuf)+2;//跳过\r\n  
            if (ll <= 0) {//参数个数小于0,表示后面的参数数目大于等于绝对值ll  
                 /** s = sdsnew("Hello World"); 
                 * sdsrange(s,1,-1); => "ello World" 
                 */  
                sdsrange(c->querybuf,pos,-1);//querybuf="$3\r\nSET\r\n$3\r\nfoo\r\n$3\r\nbar\r\n"  
                return REDIS_OK;  
            }  
      
            c->multibulklen = ll;//得到指令参数个数  
      
            /* Setup argv array on client structure */  
            if (c->argv) zfree(c->argv);  
            c->argv = zmalloc(sizeof(robj*) * c->multibulklen);//申请参数内存空间  
        }  
      
        redisAssertWithInfo(c,NULL,c->multibulklen > 0);  
        /** 
            开始抽取字符串 
            querybuf = "*3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$3\r\nbar\r\n" 
            pos = 4 
        */  
        while(c->multibulklen) {  
            /* Read bulk length if unknown */  
            if (c->bulklen == -1) {//参数的长度为-1,这里用来处理每个参数的字符串长度值  
                /**newline = "\r\nSET\r\n$3\r\nfoo\r\n$3\r\nbar\r\n"*/  
                newline = strchr(c->querybuf+pos,'\r');  
                if (newline == NULL) {  
                    if (sdslen(c->querybuf) > REDIS_INLINE_MAX_SIZE) {  
                        addReplyError(c,"Protocol error: too big bulk count string");  
                        setProtocolError(c,0);  
                    }  
                    break;  
                }  
      
                /* Buffer should also contain \n */  
                if (newline-(c->querybuf) > ((signed)sdslen(c->querybuf)-2))  
                    break;  
      
                //每个字符串以$开头,后面的数字表示其长度  
                if (c->querybuf[pos] != '$') {  
                    addReplyErrorFormat(c,  
                        "Protocol error: expected '$', got '%c'",  
                        c->querybuf[pos]);  
                    setProtocolError(c,pos);  
                    return REDIS_ERR;  
                }  
      
                //得到字符串的长度值,ll  
                ok = string2ll(c->querybuf+pos+1,newline-(c->querybuf+pos+1),&ll);  
                if (!ok || ll < 0 || ll > 512*1024*1024) {  
                    addReplyError(c,"Protocol error: invalid bulk length");  
                    setProtocolError(c,pos);  
                    return REDIS_ERR;  
                }  
      
                //pos = 8  
                pos += newline-(c->querybuf+pos)+2;//跳过\r\n "SET\r\n$3\r\nfoo\r\n$3\r\nbar\r"  
                if (ll >= REDIS_MBULK_BIG_ARG) {//字符串长度超过1024*32,需要扩展  
                    size_t qblen;  
      
                    /* If we are going to read a large object from network 
                     * try to make it likely that it will start at c->querybuf 
                     * boundary so that we can optimize object creation 
                     * avoiding a large copy of data. */  
                     /** 
                        sdsrange(querybuf,pos,-1)是将[pos,len-1]之间的字符串使用memmove前移, 
                        然后后面的直接截断 
                     */  
                    sdsrange(c->querybuf,pos,-1);//"SET\r\n$3\r\nfoo\r\n$3\r\nbar\r"  
                    pos = 0;  
                    qblen = sdslen(c->querybuf);  
                    /* Hint the sds library about the amount of bytes this string is 
                     * going to contain. */  
                    if (qblen < ll+2)//这里只会到最后一个字符串才可能为True,并且数据不完整,数据不完整是由于redis使用非阻塞的原因  
                        c->querybuf = sdsMakeRoomFor(c->querybuf,ll+2-qblen);  
                }  
                c->bulklen = ll;  
            }  
      
            /* Read bulk argument */  
            //读取参数,没有\r\n表示数据不全,也就是说服务器接收到的数据不完整  
            if (sdslen(c->querybuf)-pos < (unsigned)(c->bulklen+2)) {  
                /* Not enough data (+2 == trailing \r\n) */  
                break;  
            } else {//数据完整  
                /* Optimization: if the buffer contains JUST our bulk element 
                 * instead of creating a new object by *copying* the sds we 
                 * just use the current sds string. */  
                if (pos == 0 &&  
                    c->bulklen >= REDIS_MBULK_BIG_ARG &&  
                    (signed) sdslen(c->querybuf) == c->bulklen+2)  
                {//数据刚好完整,那么就直接使用c->querybuf,然后清空querybuf,注意这里只可能在最后一个字符串才可能出现  
                    c->argv[c->argc++] = createObject(REDIS_STRING,c->querybuf);  
                    sdsIncrLen(c->querybuf,-2); /* remove CRLF */  
                    c->querybuf = sdsempty();  
                    /* Assume that if we saw a fat argument we'll see another one 
                     * likely... */  
                    c->querybuf = sdsMakeRoomFor(c->querybuf,c->bulklen+2);  
                    pos = 0;  
                } else {  
                    //抽取出具体的字符串,比如SET,建立一个stringObject  
                    c->argv[c->argc++] =  
                        createStringObject(c->querybuf+pos,c->bulklen);  
                    pos += c->bulklen+2;//跳过\r\n  
                }  
                c->bulklen = -1;  
                c->multibulklen--;  
            }  
        }  
      
        /** 
            由于采用的是非阻塞读取客户端数据的方式,那么如果c->multibulklen != 0,那么就表示 
            数据没有接收完全,首先需要将当前的querybuf数据截断 
        */  
        /* Trim to pos */  
        if (pos) sdsrange(c->querybuf,pos,-1);  
      
        /* We're done when c->multibulk == 0 */  
        if (c->multibulklen == 0) return REDIS_OK;  
      
        /* Still not read to process the command */  
      
        return REDIS_ERR;  
    }  


processCommand与call函数


客户端指令解析完之后,需要执行该指令,执行指令的两个函数为processCommand与call函数,这两个函数除了单纯的执行指令外,还做了许多其他的工作,这里不详解,看代码仅仅找到指令如何执行还是很简单的。


指令执行完之后,需要将得到的结果集返回给客户端,这部分是如何工作的,下面开始分析。

在networking.c中可以发现许多以addRelpy为前缀的函数名,这些函数都是用来处理各种不同类型的结果的,我们以典型的addReply函数为例,进行分析。


addReply函数

该函数第一步工作就是调用prepareClientToWrite函数为客户端创建一个写文件事件,事件的处理函数即将结果集发送给客户端的函数为sendReplyToClient.


int prepareClientToWrite(redisClient *c) {  
    if (c->flags & REDIS_LUA_CLIENT) return REDIS_OK;  
    if ((c->flags & REDIS_MASTER) &&  
        !(c->flags & REDIS_MASTER_FORCE_REPLY)) return REDIS_ERR;  
    if (c->fd <= 0) return REDIS_ERR; /* Fake client */  
    if (c->bufpos == 0 && listLength(c->reply) == 0 &&  
        (c->replstate == REDIS_REPL_NONE ||  
         c->replstate == REDIS_REPL_ONLINE) &&  
        aeCreateFileEvent(server.el, c->fd, AE_WRITABLE,  
        sendReplyToClient, c) == AE_ERR) return REDIS_ERR;  
    return REDIS_OK;  
} 

第二步,就是根据相应的条件,将得到的结果rboj数据存储到buf中或者reply链表中。对于存储的策略:redis优先将数据存储在固定大小的buf中,也就是redisClient结构体buf[REDIS_REPLY_CHUNK_BYTES]里,默认大小为16K。如果有数据没有发送完或c->buf空间不足,就会放到c->reply链表里面,链表每个节点都是内存buf,后来的数据放入最后面。具体的处理函数为_addReplyToBuffer和_addReplyStringToList两个函数。

    void addReply(redisClient *c, robj *obj) {  
        if (prepareClientToWrite(c) != REDIS_OK) return;  
      
        /* This is an important place where we can avoid copy-on-write 
         * when there is a saving child running, avoiding touching the 
         * refcount field of the object if it's not needed. 
         * 
         * If the encoding is RAW and there is room in the static buffer 
         * we'll be able to send the object to the client without 
         * messing with its page. */  
        if (obj->encoding == REDIS_ENCODING_RAW) {//字符串类型  
            //是否能将数据追加到c->buf中  
            if (_addReplyToBuffer(c,obj->ptr,sdslen(obj->ptr)) != REDIS_OK)  
                _addReplyObjectToList(c,obj);//添加到c->reply链表中  
        } else if (obj->encoding == REDIS_ENCODING_INT) {//整数类型  
            /* Optimization: if there is room in the static buffer for 32 bytes 
             * (more than the max chars a 64 bit integer can take as string) we 
             * avoid decoding the object and go for the lower level approach. */  
             //追加到c->buf中  
            if (listLength(c->reply) == 0 && (sizeof(c->buf) - c->bufpos) >= 32) {  
                char buf[32];  
                int len;  
      
                len = ll2string(buf,sizeof(buf),(long)obj->ptr);//整型转string  
                if (_addReplyToBuffer(c,buf,len) == REDIS_OK)  
                    return;  
                /* else... continue with the normal code path, but should never 
                 * happen actually since we verified there is room. */  
            }  
            obj = getDecodedObject(obj);//64位整数,先转换为字符串  
            if (_addReplyToBuffer(c,obj->ptr,sdslen(obj->ptr)) != REDIS_OK)  
                _addReplyObjectToList(c,obj);  
            decrRefCount(obj);  
        } else {  
            redisPanic("Wrong obj->encoding in addReply()");  
        }  
    }  

    /** 
        Server将数据发送给Client,有两种存储数据的缓冲形式,具体参见redisClient结构体 
        1、Response buffer 
            int bufpos; //回复 
            char buf[REDIS_REPLY_CHUNK_BYTES]; //长度为16 * 1024 
        2、list *reply; 
            unsigned long reply_bytes; Tot bytes of objects in reply list 
            int sentlen;            已发送的字节数 
        如果已经使用reply的形式或者buf已经不够存储,那么就将数据添加到list *reply中 
        否则将数据添加到buf中 
    */  
    int _addReplyToBuffer(redisClient *c, char *s, size_t len) {  
        size_t available = sizeof(c->buf)-c->bufpos;//计算出c->buf的剩余长度  
      
        if (c->flags & REDIS_CLOSE_AFTER_REPLY) return REDIS_OK;  
      
        /* If there already are entries in the reply list, we cannot 
         * add anything more to the static buffer. */  
        if (listLength(c->reply) > 0) return REDIS_ERR;  
      
        /* Check that the buffer has enough space available for this string. */  
        if (len > available) return REDIS_ERR;  
      
        //回复数据追加到buf中  
        memcpy(c->buf+c->bufpos,s,len);  
        c->bufpos+=len;  
        return REDIS_OK;  
    }  
      
    /** 
        1、如果链表长度为0: 新建一个节点并直接将robj追加到链表的尾部 
        2、链表长度不为0: 首先取出链表的尾部节点 
            1)、尾部节点的字符串长度 + robj中ptr字符串的长度 <= REDIS_REPLY_CHUNK_BYTES: 
                将robj->ptr追加到尾节点的tail->ptr后面 
            2)、反之: 新建一个节点并直接将robj追加到链表的尾部 
    */  
    void _addReplyObjectToList(redisClient *c, robj *o) {  
        robj *tail;  
      
        if (c->flags & REDIS_CLOSE_AFTER_REPLY) return;  
      
        //链表长度为0  
        if (listLength(c->reply) == 0) {  
            incrRefCount(o);//增加引用次数  
            listAddNodeTail(c->reply,o);//添加到链表末尾  
            c->reply_bytes += zmalloc_size_sds(o->ptr); //计算o->ptr的占用内存大小  
        } else {  
            //取出链表尾中的数据  
            tail = listNodeValue(listLast(c->reply));  
      
            /* Append to this object when possible. */  
            // 如果最后一个节点所保存的回复加上新回复内容总长度小于等于 REDIS_REPLY_CHUNK_BYTES  
            // 那么将新回复追加到节点回复当中。  
            if (tail->ptr != NULL &&  
                sdslen(tail->ptr)+sdslen(o->ptr) <= REDIS_REPLY_CHUNK_BYTES)  
            {  
                c->reply_bytes -= zmalloc_size_sds(tail->ptr);  
                tail = dupLastObjectIfNeeded(c->reply);  
                tail->ptr = sdscatlen(tail->ptr,o->ptr,sdslen(o->ptr));  
                c->reply_bytes += zmalloc_size_sds(tail->ptr);  
            } else {//为新回复单独创建一个节点  
                incrRefCount(o);  
                listAddNodeTail(c->reply,o);  
                c->reply_bytes += zmalloc_size_sds(o->ptr);  
            }  
        }  
        // 如果突破了客户端的最大缓存限制,那么关闭客户端  
        asyncCloseClientOnOutputBufferLimitReached(c);  
    }  


sendReplyToClient函数


终于到了最后一步,把c->buf与c->reply中的数据发送给客户端即可,发送同样使用的是最原始的write函数。发送完成之后,redis将当前客户端释放,并且删除写事件,代码比较简单,不详细解释。



小结

本文粗略的介绍了Redis整体运行的流程,从服务器的角度,介绍Redis是如何初始化,创建socket,接收客户端请求,解析请求及指令的执行,反馈执行的结果集给客户端等。如果读者想更深入的了解Redis的运行机制,需要亲自阅读源码,本文可以用作参考。同时也是学习linux socket编程的好工具,原本简简单单的socket->bind->listen->accept->read->write也可以用来做许多高效的业务,是Linux socket学习的不二选择。






简述Redis事务实现 如果客 户端发送的命令为MULTI、EXEC、WATCH、DISCARD中的⼀个,⽴即执⾏这个命令,否则将命令放⼊⼀ 个事务队列⾥⾯,然后向客户端返回QUEUED回复,如果客户端发送的命令为 EXEC、DISCARD、WATCH、MULTI 四个命令的其中⼀个,那么服务器⽴即执⾏这个命令。⾸先检查 此命令的格式是否正确,如果不正确,服务器会在客户端状态(redisClient)的 flags 属性关闭REDIS_MULTI 标识,并且返回错误信息给客户端。EXEC 标识,那么就直接取消事务的执⾏。 阅读详情

相关推荐

实战解析:如何用Python逆向破解FastMoss的TikTok数据加密签名(附完整代码)

本文详细解析了如何用Python逆向破解FastMoss平台的TikTok数据加密签名机制,包括MD5加密算法和JS逆向分析。通过完整的Python代码示例,帮助开发者理解签名生成原理并实现自动化请求,提升数据获取能力。

weixin_30955617的博客 561

Redis源码安装及基础操作

下载地址:Download | RedisRedisYou can download the last Redis source files here. For additional options, see the Redis downloads section below.Stable (7.0)Redis 7.0 …https://redis.io/download/解压完成后进入redis-7.0.11目录 然后编译安装安装完成后进入src目录,启动: ./redis-server

2302_77349861的博客 909

深入浅出一文搞懂Raft协议

前言 在分布式的世界里,要说最核心最复杂的功能,一致性的实现无出其右,之前的paxos算法堪称经典,被认为是同类算法中效果最好的,基本上成为分布式一致性的代名词,但是paxos算法也是出了名的难理解,而且相当不好实现。本人也花了很多时间、看了很多材料也没有真正理解。所以基于paxos的思想进行的一致性算法的简化和实现就成为了现实的需求,在此背景下,本文的主角Raft就出现了。 Raft算法的头号目标就是容易理解(UnderStandable),这从论文中就可以看出来。当然,R...

microGP的专栏 6488

Redis的源码编译安装与运行

Redis是一款基于内存的键值型NoSQL数据库,具有单线程模型、低延迟、数据持久化和集群支持等特点。与MySQL相比,Redis数据结构松散、无关联查询、语法无统一标准、不支持ACID事务,但扩展性更强。安装Redis需先安装依赖,解压编译后配置后台运行,并通过systemctl管理服务。实际应用中,可将关系型和非关系型数据库结合使用,MySQL适用于数据结构稳定、安全性要求高的场景,Redis则适合数据结构灵活、查询性能要求高的场景。

rumina1233的博客 729

mysql数据目录迁移后表不存在_mysql 直接从date 文件夹备份表,还原数据库之后提示 table doesn`t exist的原因和解决方法...

补充:正常情况下,建议数据库备份最好用工具进行备份,通过拷贝数据库表进行数据迁移,不同的环境会出现各种不同的意外问题。背景:今天在整理一个网站的时候,操作系统由于系统自动更新导致一直出现系统蓝屏死机,唉,悲剧了,于是重新安装了系统 windows server 2008 enterprise 32bit。详情:系统安装完成后,重新配置之前那个网站,appache服务配好之后,再配置数据的时候是这样...

weixin_39628271的博客 2675

优化NEXYS A7开发板(Xilinx Artix-7)Microblaze核的FLASH读写性能实战

本文针对NEXYS A7开发板(Xilinx Artix-7)上Microblaze核读写FLASH速度慢的问题,提供了系统性的优化实战指南。通过深入分析SPI控制器配置、Flash指令模式选择、Microblaze核的Cache与硬件加速器优化,以及程序运行位置(BRAM vs DDR)的调整,有效将FLASH读写性能从“龟速”提升至接近理论峰值。文章结合实测数据,为FPGA嵌入式开发者提供了清晰的性能瓶颈分析与解决方案。

carrot的博客 259

【Redis-04】Redis命令在客户端与服务器之间的执行流程

Redis本质上是一个数据结构服务器,支持键值对类型存储的内存管理系统,可以用作数据库、缓存和消息中间件,在我日常的开发中,基本上使用redis作为缓存中间件。在Redis中有两个重要的角色,一个是服务器server,一个是客户端client,他们是一对多的关系,服务器会保存每个与之相连接的客户端的状态信息。本文会从这两个角色,分析客户端和服务器中一些比较重要的属性结构,以及一个命令从客户端发送到服务器接受、处理并返回的实现原理。

qq_35850405的博客 1423

【C#】控制设备管理器中设备的启用/禁用_20220506

通过C#代码实现设备管理器的启用/停止 引入Manamger程序集,查找到所需设备,控制启停

weixin_45475139的博客 4530

redis源码安装运行

下载redis源码版压缩包:http://download.redis.io/releases/ 本文使用的是3.0.5,把redis-3.0.5.tar.gz 复制到你需要存放的地方,然后执行 tar -zxvf redis-3.0.5.tar.gz 解压,解压完毕后,进入解压完的目录,执行 make 等待编译完毕。编译成功无错后可以看到src 源文件夹中就会多了一些编译出来的可执行文件

coder_hwj的博客 1159

搭建自己的MQTT服务器,实现设备上云(Ubuntu+EMQX)

这篇文章教大家在ECS云服务器上部署EMQX,搭建自己私有的MQTT服务器,配置EMQX实现设备上云,设备数据转发,存储;服务器我采用的华为云的ECS服务器,系统选择Ubuntu系统。

2万+

uniapp - 详细手机端h5网页调用手机摄像头进行二维码识别扫描,在uniapp的H5移动端微信网页平台中,在浏览器中调用手机扫码功能详细教程,识别二维码并获取扫描结果(完整示例源码,一键复制即用

uniapp,h5,手机端网页,H5手机网页,uniapp开发h5实现扫码功能,uniapp微信h5网页扫码sdk使用教程,uniapp h5网页如何实现浏览器扫码,uniapp扫码功能怎么兼容h5_uniapph5怎么做扫码功能,uniapp的手机网页如何实现扫二维码一维码,浏览器H5实现js扫码,H5调用摄像头和扫一扫功能,亲测可用,H5调用本地摄像头实现扫一扫,uni-h5项目解决扫码功能,uniapp实现微信H5扫码,解决uniapp在H5端使用不能扫码问题,uni-app的h5扫码(二维码、条形码

✅ 精选推荐文章 1万+

redis源码分析八--从客户端发送set命令后看服务端的执行流程上

1、Redis服务端的执行流程 Redis程序分为客户端和服务端,之间通信是通过socket来传递指令信息,这里有一个问题就是我客户端发送一个set命令后服务器会做哪一些操作呢?具体操作语句见下图 这里我设置了一个字符串number值为12306传递给Redis服务器端来进行保存,服务器端是如何实时监听我们的发送指令,并且如何解析的呢? 首先我给出服务器端的调用流程图如下 首先服务器端在启动时...

曳凡的博客 461

详细分析一下华为自研的MetaERP系统中的合并报表流程与规则

华为MetaERP合并报表系统针对其全球化复杂业务量身定制,采用五层自动化架构:统一数据采集、多币种转换、智能对账协同、规则化抵消处理及多维分析输出。系统核心在于可配置的智能规则引擎,涵盖股权合并范围、内部交易抵消、未实现利润计算等复杂场景,实现多准则并行处理。相比传统软件,该系统深度集成业务数据、支持准实时合并,并通过参数化配置快速适应组织变革,成为华为全球财务管控的"数字神经中枢",在效率、准确性和安全性上具有显著优势。

金牌架构师 674

Redis 事务执行流程源码分析

一般事务执行流程为 # ./src/redis-cli 127.0.0.1:6379> MULTI OK 127.0.0.1:6379(TX)> set name molaifeng QUEUED 127.0.0.1:6379(TX)> set hobby coding QUEUED 127.0.0.1:6379(TX)> EXEC 1) OK 2) OK 结合源码分析如下 第一步 MULTI 就是给当前的客户端加上 CLIENT_MULTI 状态,当然了,如果当前客户端状态

molaifeng的专栏 220

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Spring Boot整合Redis

j

kkkkk777的博客 303

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

Redis命令处理流程:从客户端请求到结果返回

Redis命令处理流程:从客户端请求到结果返回 【免费下载链接】redis 项目地址: https://gitcode.com/gh_mirrors/redis/redis ...

gitblog_00907的博客 980

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

redis4.x源码情景分析-事务的实现原理

概述 本文讲述redis的事务的实现原理。 基本概念 事务(Transactions) 事务是一系列命令的集合,这个命令的集合要么全部执行成功,全部执行失败。redis事务类似于传统数据库的事务。 事务的使用 事务的使用通过multi命令开始,exec命令结束。 > MULTI OK > INCR foo QUEUED > INCR bar QUEUED > EXEC 1)...

zg_hover的专栏 494

Redisson延迟队列执行流程源码分析一下

这是我参与2022首次更文挑战的第1天,活动详情查看:2022首次更文挑战 前言 之前一篇文章描述了JDK自带的延迟队列DelayQueue【DelayQueue延迟处理任务记录一下】 在实际分布式项目中延迟任务一般不会使用JDK自带的延迟队列,因为它是基于JVM内存存储,没有持久化操作,所以当服务重启后就会丢失任务。 在项目中可以使用MQ死信队列或redisson延迟队列进行处理延迟任务,本篇文章将讲述redisson延迟队列的使用demo和其执行源码。 demo示例 通过脚手架创建一个简易..

a1472750149的博客 151

Redis集群分析(8)

1、 AOF持久化 在(4)到(7)中介绍了RDB的持久化方式,redis除了这种持久化方式外还有一种叫AOF的持久化方式。 如同(3)中介绍的那样,AOF会在执行命令的时候将命令写入到持久化文件中。所以在查看AOF的执行方式需要从redis的命令执行处开始。 2、 AOF源码分析 在分析AOF的源码前先简要分析redis的命令执行流程:要执行命令首先需要使用redis的客户端(redis-cli)连接redis的服务器,连接成功后在客户端中输入需要执行的命令,然后客户端通过网络连接(tcp连接)将输入的数

qq_39210987的博客 203

[redis 源码走读] - aof 持久化 ②

aof 文件存储 RESP 命令,新数据追加到文件末。aof 存储为了避免冗余,需要设置重写处理。aof 有三种存储策略,默认每秒存盘一次。根据自己的使用场景,选择存储策略。每秒存盘策略和重写功能通过多线程异步处理,保证主线程高性能。关注 redis 的博客,多看 redis.conf 配置项,里面有很多信息量。aof 持久化文件支持 aof 和 rdb 方式混合存储,可以快速重写,并且减少 aof 体积。aof 与 rdb 相比文件体积大,但是容灾能力强,出现问题丢失数据少。

smart_an的专栏 961

Redis RDB 持久化详解

来自公众号:程序员历小冰Redis 是一种内存数据库,将数据保存在内存中,读写效率要比传统的将数据保存在磁盘上的数据库要快很多。但是一旦进程退出,Redis 的数据就会丢...

架构师小秘圈 251

Redis集群分析(9)

1、 AOF重写 在(8)中介绍了AOF的持久化方式,在(8)中介绍到在将命令写到AOF的buf中的时候,还有可能写到AOF的重写buf中。 这与AOF的重写的机制有关,在(3)中介绍AOF的同时也介绍了重写。它是因为AOF记录的操作中可能出现废操作,所以需要重写AOF文件,去除废操作。但是重写AOF文件一般来说都比较耗时,所以不会让主进程来执行重写任务,会使用子进程来执行重写任务,主进程继续对外提供服务。 但是主进程继续提供服务就会产生一个问题:主进程会继续向AOF文件中写数据,子进程再修改这个文件就很容

qq_39210987的博客 191

Springboot Redis客户端配置及初始化过程源码解读

spring boot集成redis,配置比较简单,网上存在不同的配置。为什么有不同的配置文件? spring boot是如何加载redis的呢? 为了搞清楚背后的机制,阅读源码一探究竟。 1: spring boot 集成redis 为什么存在不同的配置文件 在spring boot 1.x.x集成redis时,默认jedis作为连接客户端。由于jedis是直连模式,在...

wiseyl的专栏 4954

Redis《RedisSerializer》

有关RedisSerializer

weixin_74772041的博客 1072

蔚来真题:Redis跳跃表是如何添加元素的?

跳跃表 Skip List,也称之为跳表,是一种数据结构,用于在有序元素的集合中进行高效的查找操作。它通过添加多层链表的方式,提供了一种以空间换时间的方式来加速查找。跳跃表由一个带有多层节点的链表组成,每一层都是原始链表的一个子集。最底层是一个完整的有序链表,包含所有元素。每个更高层级都是下层级的子集,通过添加额外的指针来跳过一些元素。这些额外的指针称为“跳跃指针”,它们允许快速访问更远的节点,从而减少了查找所需的比较次数。跳跃表的平均查找时间复杂度为 O(log n),其中 n 是元素的数量。

m0_57747934的博客 328
上一篇: PHP 缓存之客户端缓存
下一篇: C语言 二叉查找树相关算法
bad7code
博客等级 码龄11年 2粉丝 17原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值