typedef struct client {
    // client獨(dú)一無二的ID
    uint64_t id;            /* Client incremental unique ID. */
    // client的套接字
    int fd;                 /* Client socket. */
    // 指向當(dāng)前的數(shù)據(jù)庫
    redisDb *db;            /* Pointer to currently SELECTed DB. */
    // 保存指向數(shù)據(jù)庫的ID
    int dictid;             /* ID of the currently SELECTed DB. */
    // client的名字
    robj *name;             /* As set by CLIENT SETNAME. */
    // 輸入緩沖區(qū)
    sds querybuf;           /* Buffer we use to accumulate client queries. */
    // 輸入緩存的峰值
    size_t querybuf_peak;   /* Recent (100ms or more) peak of querybuf size. */
    // client輸入命令時，參數(shù)的數(shù)量
    int argc;               /* Num of arguments of current command. */
    // client輸入命令的參數(shù)列表
    robj **argv;            /* Arguments of current command. */
    // 保存客戶端執(zhí)行命令的歷史記錄
    struct redisCommand *cmd, *lastcmd;  /* Last command executed. */
    // 請求協(xié)議類型，內(nèi)聯(lián)或者多條命令
    int reqtype;            /* Request protocol type: PROTO_REQ_* */
    // 參數(shù)列表中未讀取命令參數(shù)的數(shù)量，讀取一個，該值減1
    int multibulklen;       /* Number of multi bulk arguments left to read. */
    // 命令內(nèi)容的長度
    long bulklen;           /* Length of bulk argument in multi bulk request. */
    // 回復(fù)緩存列表，用于發(fā)送大于固定回復(fù)緩沖區(qū)的回復(fù)
    list *reply;            /* List of reply objects to send to the client. */
    // 回復(fù)緩存列表對象的總字節(jié)數(shù)
    unsigned long long reply_bytes; /* Tot bytes of objects in reply list. */
    // 已發(fā)送的字節(jié)數(shù)或?qū)ο蟮淖止?jié)數(shù)
    size_t sentlen;         /* Amount of bytes already sent in the current
                               buffer or object being sent. */
    // client創(chuàng)建所需時間
    time_t ctime;           /* Client creation time. */
    // 最后一次和服務(wù)器交互的時間
    time_t lastinteraction; /* Time of the last interaction, used for timeout */
    // 客戶端的輸出緩沖區(qū)超過軟性限制的時間，記錄輸出緩沖區(qū)第一次到達(dá)軟性限制的時間
    time_t obuf_soft_limit_reached_time;
    // client狀態(tài)的標(biāo)志
    int flags;              /* Client flags: CLIENT_* macros. */
    // 認(rèn)證標(biāo)志，0表示未認(rèn)證，1表示已認(rèn)證
    int authenticated;      /* When requirepass is non-NULL. */
    // 從節(jié)點(diǎn)的復(fù)制狀態(tài)
    int replstate;          /* Replication state if this is a slave. */
    // 在ack上設(shè)置從節(jié)點(diǎn)的寫處理器，是否在slave向master發(fā)送ack，
    int repl_put_online_on_ack; /* Install slave write handler on ACK. */
    // 保存主服務(wù)器傳來的RDB文件的文件描述符
    int repldbfd;           /* Replication DB file descriptor. */
    // 讀取主服務(wù)器傳來的RDB文件的偏移量
    off_t repldboff;        /* Replication DB file offset. */
    // 主服務(wù)器傳來的RDB文件的大小
    off_t repldbsize;       /* Replication DB file size. */
    // 主服務(wù)器傳來的RDB文件的大小，符合協(xié)議的字符串形式
    sds replpreamble;       /* Replication DB preamble. */
    // replication復(fù)制的偏移量
    long long reploff;      /* Replication offset if this is our master. */
    // 通過ack命令接收到的偏移量
    long long repl_ack_off; /* Replication ack offset, if this is a slave. */
    // 通過ack命令接收到的偏移量所用的時間
    long long repl_ack_time;/* Replication ack time, if this is a slave. */
    // FULLRESYNC回復(fù)給從節(jié)點(diǎn)的offset
    long long psync_initial_offset; /* FULLRESYNC reply offset other slaves
                                       copying this slave output buffer
                                       should use. */
    char replrunid[CONFIG_RUN_ID_SIZE+1]; /* Master run id if is a master. */
    // 從節(jié)點(diǎn)的端口號
    int slave_listening_port; /* As configured with: REPLCONF listening-port */
    // 從節(jié)點(diǎn)IP地址
    char slave_ip[NET_IP_STR_LEN]; /* Optionally given by REPLCONF ip-address */
    // 從節(jié)點(diǎn)的功能
    int slave_capa;         /* Slave capabilities: SLAVE_CAPA_* bitwise OR. */
    // 事物狀態(tài)
    multiState mstate;      /* MULTI/EXEC state */
    // 阻塞類型
    int btype;              /* Type of blocking op if CLIENT_BLOCKED. */
    // 阻塞的狀態(tài)
    blockingState bpop;     /* blocking state */
    // 最近一個寫全局的復(fù)制偏移量
    long long woff;         /* Last write global replication offset. */
    // 監(jiān)控列表
    list *watched_keys;     /* Keys WATCHED for MULTI/EXEC CAS */
    // 訂閱頻道
    dict *pubsub_channels;  /* channels a client is interested in (SUBSCRIBE) */
    // 訂閱的模式
    list *pubsub_patterns;  /* patterns a client is interested in (SUBSCRIBE) */
    // 被緩存的ID
    sds peerid;             /* Cached peer ID. */
    /* Response buffer */
    // 回復(fù)固定緩沖區(qū)的偏移量
    int bufpos;
    // 回復(fù)固定緩沖區(qū)
    char buf[PROTO_REPLY_CHUNK_BYTES];
} client;

// 創(chuàng)建一個新的client
client *createClient(int fd) {
    client *c = zmalloc(sizeof(client));    //分配空間
    // 如果fd為-1，表示創(chuàng)建的是一個無網(wǎng)絡(luò)連接的偽客戶端，用于執(zhí)行l(wèi)ua腳本的時候
    // 如果fd不等于-1，表示創(chuàng)建一個有網(wǎng)絡(luò)連接的客戶端
    if (fd != -1) {
        // 設(shè)置fd為非阻塞模式
        anetNonBlock(NULL,fd);
        // 禁止使用 Nagle 算法，client向內(nèi)核遞交的每個數(shù)據(jù)包都會立即發(fā)送給server出去，TCP_NODELAY
        anetEnableTcpNoDelay(NULL,fd);
        // 如果開啟了tcpkeepalive，則設(shè)置 SO_KEEPALIVE
        if (server.tcpkeepalive)
            // 設(shè)置tcp連接的keep alive選項
            anetKeepAlive(NULL,fd,server.tcpkeepalive);
        // 創(chuàng)建一個文件事件狀態(tài)el，且監(jiān)聽讀事件，開始接受命令的輸入
        if (aeCreateFileEvent(server.el,fd,AE_READABLE,
            readQueryFromClient, c) == AE_ERR)
        {
            close(fd);
            zfree(c);
            return NULL;
        }
    }
    // 默認(rèn)選0號數(shù)據(jù)庫
    selectDb(c,0);
    // 設(shè)置client的ID
    c->id = server.next_client_id++;
    // client的套接字
    c->fd = fd;
    // client的名字
    c->name = NULL;
    // 回復(fù)固定(靜態(tài))緩沖區(qū)的偏移量
    c->bufpos = 0;
    // 輸入緩存區(qū)
    c->querybuf = sdsempty();
    // 輸入緩存區(qū)的峰值
    c->querybuf_peak = 0;
    // 請求協(xié)議類型，內(nèi)聯(lián)或者多條命令，初始化為0
    c->reqtype = 0;
    // 參數(shù)個數(shù)
    c->argc = 0;
    // 參數(shù)列表
    c->argv = NULL;
    // 當(dāng)前執(zhí)行的命令和最近一次執(zhí)行的命令
    c->cmd = c->lastcmd = NULL;
    // 查詢緩沖區(qū)剩余未讀取命令的數(shù)量
    c->multibulklen = 0;
    // 讀入?yún)?shù)的長度
    c->bulklen = -1;
    // 已發(fā)的字節(jié)數(shù)
    c->sentlen = 0;
    // client的狀態(tài)
    c->flags = 0;
    // 設(shè)置創(chuàng)建client的時間和最后一次互動的時間
    c->ctime = c->lastinteraction = server.unixtime;
    // 認(rèn)證狀態(tài)
    c->authenticated = 0;
    // replication復(fù)制的狀態(tài)，初始為無
    c->replstate = REPL_STATE_NONE;
    // 設(shè)置從節(jié)點(diǎn)的寫處理器為ack，是否在slave向master發(fā)送ack
    c->repl_put_online_on_ack = 0;
    // replication復(fù)制的偏移量
    c->reploff = 0;
    // 通過ack命令接收到的偏移量
    c->repl_ack_off = 0;
    // 通過ack命令接收到的偏移量所用的時間
    c->repl_ack_time = 0;
    // 從節(jié)點(diǎn)的端口號
    c->slave_listening_port = 0;
    // 從節(jié)點(diǎn)IP地址
    c->slave_ip[0] = '\0';
    // 從節(jié)點(diǎn)的功能
    c->slave_capa = SLAVE_CAPA_NONE;
    // 回復(fù)鏈表
    c->reply = listCreate();
    // 回復(fù)鏈表的字節(jié)數(shù)
    c->reply_bytes = 0;
    // 回復(fù)緩沖區(qū)的內(nèi)存大小軟限制
    c->obuf_soft_limit_reached_time = 0;
    // 回復(fù)鏈表的釋放和復(fù)制方法
    listSetFreeMethod(c->reply,decrRefCountVoid);
    listSetDupMethod(c->reply,dupClientReplyValue);
    // 阻塞類型
    c->btype = BLOCKED_NONE;
    // 阻塞超過時間
    c->bpop.timeout = 0;
    // 造成阻塞的鍵字典
    c->bpop.keys = dictCreate(&setDictType,NULL);
    // 存儲解除阻塞的鍵，用于保存PUSH入元素的鍵，也就是dstkey
    c->bpop.target = NULL;
    // 阻塞狀態(tài)
    c->bpop.numreplicas = 0;
    // 要達(dá)到的復(fù)制偏移量
    c->bpop.reploffset = 0;
    // 全局的復(fù)制偏移量
    c->woff = 0;
    // 監(jiān)控的鍵
    c->watched_keys = listCreate();
    // 訂閱頻道
    c->pubsub_channels = dictCreate(&setDictType,NULL);
    // 訂閱模式
    c->pubsub_patterns = listCreate();
    // 被緩存的peerid，peerid就是 ip:port
    c->peerid = NULL;
    // 訂閱發(fā)布模式的釋放和比較方法
    listSetFreeMethod(c->pubsub_patterns,decrRefCountVoid);
    listSetMatchMethod(c->pubsub_patterns,listMatchObjects);
    // 將真正的client放在服務(wù)器的客戶端鏈表中
    if (fd != -1) listAddNodeTail(server.clients,c);
    // 初始化client的事物狀態(tài)
    initClientMultiState(c);
    return c;
}

// 異步釋放client
void freeClientAsync(client *c) {
    // 如果是已經(jīng)即將關(guān)閉或者是lua腳本的偽client，則直接返回
    if (c->flags & CLIENT_CLOSE_ASAP || c->flags & CLIENT_LUA) return;
    c->flags |= CLIENT_CLOSE_ASAP;
    // 將client加入到即將關(guān)閉的client鏈表中
    // server.clients_to_close 中保存著服務(wù)器中所有待關(guān)閉的鏈表
    listAddNodeTail(server.clients_to_close,c);
}

// 取消設(shè)置異步釋放的client
void freeClientsInAsyncFreeQueue(void) {
    // 遍歷所有即將關(guān)閉的client
    while (listLength(server.clients_to_close)) {
        listNode *ln = listFirst(server.clients_to_close);
        client *c = listNodeValue(ln);
        // 取消立即關(guān)閉的標(biāo)志
        c->flags &= ~CLIENT_CLOSE_ASAP;
        freeClient(c);
        // 從即將關(guān)閉的client鏈表中刪除
        listDelNode(server.clients_to_close,ln);
    }
}

// 讀取client的輸入緩沖區(qū)的內(nèi)容
void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
    client *c = (client*) privdata;
    int nread, readlen;
    size_t qblen;
    UNUSED(el);
    UNUSED(mask);
    // 讀入的長度，默認(rèn)16MB
    readlen = PROTO_IOBUF_LEN;
    // 如果是多條請求，根據(jù)請求的大小，設(shè)置讀入的長度readlen
    if (c->reqtype == PROTO_REQ_MULTIBULK && c->multibulklen && c->bulklen != -1
        && c->bulklen >= PROTO_MBULK_BIG_ARG)
    {
        int remaining = (unsigned)(c->bulklen+2)-sdslen(c->querybuf);
        if (remaining < readlen) readlen = remaining;
    }
    // 輸入緩沖區(qū)的長度
    qblen = sdslen(c->querybuf);
    // 更新緩沖區(qū)的峰值
    if (c->querybuf_peak < qblen) c->querybuf_peak = qblen;
    // 擴(kuò)展緩沖區(qū)的大小
    c->querybuf = sdsMakeRoomFor(c->querybuf, readlen);
    // 將client發(fā)來的命令，讀入到輸入緩沖區(qū)中
    nread = read(fd, c->querybuf+qblen, readlen);
    // 讀操作出錯
    if (nread == -1) {
        if (errno == EAGAIN) {
            return;
        } else {
            serverLog(LL_VERBOSE, "Reading from client: %s",strerror(errno));
            freeClient(c);
            return;
        }
    // 讀操作完成
    } else if (nread == 0) {
        serverLog(LL_VERBOSE, "Client closed connection");
        freeClient(c);
        return;
    }
    // 更新輸入緩沖區(qū)的已用大小和未用大小。
    sdsIncrLen(c->querybuf,nread);
    // 設(shè)置最后一次服務(wù)器和client交互的時間
    c->lastinteraction = server.unixtime;
    // 如果是主節(jié)點(diǎn)，則更新復(fù)制操作的偏移量
    if (c->flags & CLIENT_MASTER) c->reploff += nread;
    // 更新從網(wǎng)絡(luò)輸入的字節(jié)數(shù)
    server.stat_net_input_bytes += nread;
    // 如果輸入緩沖區(qū)長度超過服務(wù)器設(shè)置的最大緩沖區(qū)長度
    if (sdslen(c->querybuf) > server.client_max_querybuf_len) {
        // 將client信息轉(zhuǎn)換為sds
        sds ci = catClientInfoString(sdsempty(),c), bytes = sdsempty();
        // 輸入緩沖區(qū)保存在bytes中
        bytes = sdscatrepr(bytes,c->querybuf,64);
        // 打印到日志
        serverLog(LL_WARNING,"Closing client that reached max query buffer length: %s (qbuf initial bytes: %s)", ci, bytes);
        // 釋放空間
        sdsfree(ci);
        sdsfree(bytes);
        freeClient(c);
        return;
    }
    // 處理client輸入的命令內(nèi)容
    processInputBuffer(c);
}

// 處理client輸入的命令內(nèi)容
void processInputBuffer(client *c) {
    server.current_client = c;
    // 一直讀輸入緩沖區(qū)的內(nèi)容
    while(sdslen(c->querybuf)) {
        // 如果處于暫停狀態(tài)，直接返回
        if (!(c->flags & CLIENT_SLAVE) && clientsArePaused()) break;
        // 如果client處于被阻塞狀態(tài)，直接返回
        if (c->flags & CLIENT_BLOCKED) break;
        // 如果client處于關(guān)閉狀態(tài)，則直接返回
        if (c->flags & (CLIENT_CLOSE_AFTER_REPLY|CLIENT_CLOSE_ASAP)) break;
        // 如果是未知的請求類型，則判定請求類型
        if (!c->reqtype) {
            // 如果是"*"開頭，則是多條請求，是client發(fā)來的
            if (c->querybuf[0] == '*') {
                c->reqtype = PROTO_REQ_MULTIBULK;
            // 否則就是內(nèi)聯(lián)請求，是Telnet發(fā)來的
            } else {
                c->reqtype = PROTO_REQ_INLINE;
            }
        }
        // 如果是內(nèi)聯(lián)請求
        if (c->reqtype == PROTO_REQ_INLINE) {
            // 處理Telnet發(fā)來的內(nèi)聯(lián)命令，并創(chuàng)建成對象，保存在client的參數(shù)列表中
            if (processInlineBuffer(c) != C_OK) break;
        // 如果是多條請求
        } else if (c->reqtype == PROTO_REQ_MULTIBULK) {
            // 將client的querybuf中的協(xié)議內(nèi)容轉(zhuǎn)換為client的參數(shù)列表中的對象
            if (processMultibulkBuffer(c) != C_OK) break;
        } else {
            serverPanic("Unknown request type");
        }
        // 如果參數(shù)為0，則重置client
        if (c->argc == 0) {
            resetClient(c);
        } else {
            /* Only reset the client when the command was executed. */
            // 執(zhí)行命令成功后重置client
            if (processCommand(c) == C_OK)
                resetClient(c);
            if (server.current_client == NULL) break;
        }
    }
    // 執(zhí)行成功，則將用于崩潰報告的client設(shè)置為NULL
    server.current_client = NULL;
}

// 將client的querybuf中的協(xié)議內(nèi)容轉(zhuǎn)換為client的參數(shù)列表中的對象
int processMultibulkBuffer(client *c) {
    char *newline = NULL;
    int pos = 0, ok;
    long long ll;
    // 參數(shù)列表中命令數(shù)量為0，因此先分配空間
    if (c->multibulklen == 0) {
        /* The client should have been reset */
        serverAssertWithInfo(c,NULL,c->argc == 0);
        /* Multi bulk length cannot be read without a \r\n */
        // 查詢第一個換行符
        newline = strchr(c->querybuf,'\r');
        // 沒有找到\r\n，表示不符合協(xié)議，返回錯誤
        if (newline == NULL) {
            if (sdslen(c->querybuf) > PROTO_INLINE_MAX_SIZE) {
                addReplyError(c,"Protocol error: too big mbulk count string");
                setProtocolError(c,0);
            }
            return C_ERR;
        }
        /* Buffer should also contain \n */
        // 檢查格式
        if (newline-(c->querybuf) > ((signed)sdslen(c->querybuf)-2))
            return C_ERR;
        /* We know for sure there is a whole line since newline != NULL,
         * so go ahead and find out the multi bulk length. */
        // 保證第一個字符為'*'
        serverAssertWithInfo(c,NULL,c->querybuf[0] == '*');
        // 將'*'之后的數(shù)字轉(zhuǎn)換為整數(shù)。*3\r\n
        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 C_ERR;
        }
        // 指向"*3\r\n"的"\r\n"之后的位置
        pos = (newline-c->querybuf)+2;
        // 空白命令，則將之前的刪除，保留未閱讀的部分
        if (ll <= 0) {
            sdsrange(c->querybuf,pos,-1);
            return C_OK;
        }
        // 參數(shù)數(shù)量
        c->multibulklen = ll;
        /* Setup argv array on client structure */
        // 分配client參數(shù)列表的空間
        if (c->argv) zfree(c->argv);
        c->argv = zmalloc(sizeof(robj*)*c->multibulklen);
    }
    serverAssertWithInfo(c,NULL,c->multibulklen > 0);
    // 讀入multibulklen個參數(shù)，并創(chuàng)建對象保存在參數(shù)列表中
    while(c->multibulklen) {
        /* Read bulk length if unknown */
        // 讀入?yún)?shù)的長度
        if (c->bulklen == -1) {
            // 找到換行符，確保"\r\n"存在
            newline = strchr(c->querybuf+pos,'\r');
            if (newline == NULL) {
                if (sdslen(c->querybuf) > PROTO_INLINE_MAX_SIZE) {
                    addReplyError(c,
                        "Protocol error: too big bulk count string");
                    setProtocolError(c,0);
                    return C_ERR;
                }
                break;
            }
            /* Buffer should also contain \n */
            // 檢查格式
            if (newline-(c->querybuf) > ((signed)sdslen(c->querybuf)-2))
                break;
            // $3\r\nSET\r\n...，確保是'$'字符，保證格式
            if (c->querybuf[pos] != '$') {
                addReplyErrorFormat(c,
                    "Protocol error: expected '$', got '%c'",
                    c->querybuf[pos]);
                setProtocolError(c,pos);
                return C_ERR;
            }
            // 將參數(shù)長度保存到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 C_ERR;
            }
            // 定位第一個參數(shù)的位置，也就是SET的S
            pos += newline-(c->querybuf+pos)+2;
            // 參數(shù)長度太長，進(jìn)行優(yōu)化
            if (ll >= PROTO_MBULK_BIG_ARG) {
                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. */
                // 如果我們要從網(wǎng)絡(luò)中讀取一個大的對象，嘗試使它可能從c-> querybuf邊界開始，以便我們可以優(yōu)化對象創(chuàng)建，避免大量的數(shù)據(jù)副本
                // 保存未讀取的部分
                sdsrange(c->querybuf,pos,-1);
                // 重置偏移量
                pos = 0;
                // 獲取querybuf中已使用的長度
                qblen = sdslen(c->querybuf);
                /* Hint the sds library about the amount of bytes this string is
                 * going to contain. */
                // 擴(kuò)展querybuf的大小
                if (qblen < (size_t)ll+2)
                    c->querybuf = sdsMakeRoomFor(c->querybuf,ll+2-qblen);
            }
            // 保存參數(shù)的長度
            c->bulklen = ll;
        }
        /* Read bulk argument */
        // 因為只讀了multibulklen字節(jié)的數(shù)據(jù)，讀到的數(shù)據(jù)不夠，則直接跳出循環(huán)，執(zhí)行processInputBuffer()函數(shù)循環(huán)讀取
        if (sdslen(c->querybuf)-pos < (unsigned)(c->bulklen+2)) {
            /* Not enough data (+2 == trailing \r\n) */
            break;
        // 為參數(shù)創(chuàng)建了對象
        } 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. */
            // 如果讀入的長度大于32k
            if (pos == 0 &&
                c->bulklen >= PROTO_MBULK_BIG_ARG &&
                (signed) sdslen(c->querybuf) == c->bulklen+2)
            {
                c->argv[c->argc++] = createObject(OBJ_STRING,c->querybuf);
                // 跳過換行
                sdsIncrLen(c->querybuf,-2); /* remove CRLF */
                /* Assume that if we saw a fat argument we'll see another one
                 * likely... */
                // 設(shè)置一個新長度
                c->querybuf = sdsnewlen(NULL,c->bulklen+2);
                sdsclear(c->querybuf);
                pos = 0;
            // 創(chuàng)建對象保存在client的參數(shù)列表中
            } else {
                c->argv[c->argc++] =
                    createStringObject(c->querybuf+pos,c->bulklen);
                pos += c->bulklen+2;
            }
            // 清空命令內(nèi)容的長度
            c->bulklen = -1;
            // 未讀取命令參數(shù)的數(shù)量，讀取一個，該值減1
            c->multibulklen--;
        }
    }
    /* Trim to pos */
    // 刪除已經(jīng)讀取的，保留未讀取的
    if (pos) sdsrange(c->querybuf,pos,-1);
    /* We're done when c->multibulk == 0 */
    // 命令的參數(shù)全部被讀取完
    if (c->multibulklen == 0) return C_OK;
    /* Still not read to process the command */
    return C_ERR;
}

"*3\r\n$3\r\nSET\r\n$5\r\nmykey\r\n$7\r\nmyvalue\r\n"

// 寫事件處理程序，只是發(fā)送回復(fù)給client
void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) {
    UNUSED(el);
    UNUSED(mask);
    // 發(fā)送完數(shù)據(jù)會刪除fd的可讀事件
    writeToClient(fd,privdata,1);
}

// 將輸出緩沖區(qū)的數(shù)據(jù)寫給client，如果client被釋放則返回C_ERR，沒被釋放則返回C_OK
int writeToClient(int fd, client *c, int handler_installed) {
    ssize_t nwritten = 0, totwritten = 0;
    size_t objlen;
    size_t objmem;
    robj *o;
    // 如果指定的client的回復(fù)緩沖區(qū)中還有數(shù)據(jù)，則返回真，表示可以寫socket
    while(clientHasPendingReplies(c)) {
        // 固定緩沖區(qū)發(fā)送未完成
        if (c->bufpos > 0) {
            // 將緩沖區(qū)的數(shù)據(jù)寫到fd中
            nwritten = write(fd,c->buf+c->sentlen,c->bufpos-c->sentlen);
            // 寫失敗跳出循環(huán)
            if (nwritten <= 0) break;
            // 更新發(fā)送的數(shù)據(jù)計數(shù)器
            c->sentlen += nwritten;
            totwritten += nwritten;
            // 如果發(fā)送的數(shù)據(jù)等于buf的偏移量，表示發(fā)送完成
            if ((int)c->sentlen == c->bufpos) {
                // 則將其重置
                c->bufpos = 0;
                c->sentlen = 0;
            }
        // 固定緩沖區(qū)發(fā)送完成，發(fā)送回復(fù)鏈表的內(nèi)容
        } else {
            // 回復(fù)鏈表的第一條回復(fù)對象，和對象值的長度和所占的內(nèi)存
            o = listNodeValue(listFirst(c->reply));
            objlen = sdslen(o->ptr);
            objmem = getStringObjectSdsUsedMemory(o);
            // 跳過空對象，并刪除這個對象
            if (objlen == 0) {
                listDelNode(c->reply,listFirst(c->reply));
                c->reply_bytes -= objmem;
                continue;
            }
            // 將當(dāng)前節(jié)點(diǎn)的值寫到fd中
            nwritten = write(fd, ((char*)o->ptr)+c->sentlen,objlen-c->sentlen);
            // 寫失敗跳出循環(huán)
            if (nwritten <= 0) break;
            // 更新發(fā)送的數(shù)據(jù)計數(shù)器
            c->sentlen += nwritten;
            totwritten += nwritten;
            // 發(fā)送完成，則刪除該節(jié)點(diǎn)，重置發(fā)送的數(shù)據(jù)長度，更新回復(fù)鏈表的總字節(jié)數(shù)
            if (c->sentlen == objlen) {
                listDelNode(c->reply,listFirst(c->reply));
                c->sentlen = 0;
                c->reply_bytes -= objmem;
            }
        }
        // 更新寫到網(wǎng)絡(luò)的字節(jié)數(shù)
        server.stat_net_output_bytes += totwritten;
        // 如果這次寫的總量大于NET_MAX_WRITES_PER_EVENT的限制，則會中斷本次的寫操作，將處理時間讓給其他的client，以免一個非常的回復(fù)獨(dú)占服務(wù)器，剩余的數(shù)據(jù)下次繼續(xù)在寫
        // 但是，如果當(dāng)服務(wù)器的內(nèi)存數(shù)已經(jīng)超過maxmemory，即使超過最大寫NET_MAX_WRITES_PER_EVENT的限制，也會繼續(xù)執(zhí)行寫入操作，是為了盡快寫入給客戶端
        if (totwritten > NET_MAX_WRITES_PER_EVENT &&
            (server.maxmemory == 0 ||
             zmalloc_used_memory() < server.maxmemory)) break;
    }
    // 處理寫入失敗
    if (nwritten == -1) {
        if (errno == EAGAIN) {
            nwritten = 0;
        } else {
            serverLog(LL_VERBOSE,
                "Error writing to client: %s", strerror(errno));
            freeClient(c);
            return C_ERR;
        }
    }
    // 寫入成功
    if (totwritten > 0) {
        // 如果不是主節(jié)點(diǎn)服務(wù)器，則更新最近和服務(wù)器交互的時間
        if (!(c->flags & CLIENT_MASTER)) c->lastinteraction = server.unixtime;
    }
    // 如果指定的client的回復(fù)緩沖區(qū)中已經(jīng)沒有數(shù)據(jù)，發(fā)送完成
    if (!clientHasPendingReplies(c)) {
        c->sentlen = 0;
        // 刪除當(dāng)前client的可讀事件的監(jiān)聽
        if (handler_installed) aeDeleteFileEvent(server.el,c->fd,AE_WRITABLE);
        /* Close connection after entire reply has been sent. */
        // 如果指定了寫入按成之后立即關(guān)閉的標(biāo)志，則釋放client
        if (c->flags & CLIENT_CLOSE_AFTER_REPLY) {
            freeClient(c);
            return C_ERR;
        }
    }
    return C_OK;
}

CLIENT KILL [ip:port] [ID client-id] [TYPE normal|master|slave|pubsub] [ADDR ip:port] [SKIPME yes/no] 
CLIENT GETNAME
CLIENT LIST
CLIENT PAUSE timeout 
CLIENT REPLY ON|OFF|SKIP 
CLIENT SETNAME connection-name 

// client 命令的實現(xiàn)
void clientCommand(client *c) {
    listNode *ln;
    listIter li;
    client *client;
    //  CLIENT LIST 的實現(xiàn)
    if (!strcasecmp(c->argv[1]->ptr,"list") && c->argc == 2) {
        /* CLIENT LIST */
        // 獲取所有的client信息
        sds o = getAllClientsInfoString();
        // 添加到到輸入緩沖區(qū)中
        addReplyBulkCBuffer(c,o,sdslen(o));
        sdsfree(o);
    // CLIENT REPLY ON|OFF|SKIP 命令實現(xiàn)
    } else if (!strcasecmp(c->argv[1]->ptr,"reply") && c->argc == 3) {
        /* CLIENT REPLY ON|OFF|SKIP */
        // 如果是 ON
        if (!strcasecmp(c->argv[2]->ptr,"on")) {
            // 取消 off 和 skip 的標(biāo)志
            c->flags &= ~(CLIENT_REPLY_SKIP|CLIENT_REPLY_OFF);
            // 回復(fù) +OK
            addReply(c,shared.ok);
        // 如果是 OFF
        } else if (!strcasecmp(c->argv[2]->ptr,"off")) {
            // 打開 OFF標(biāo)志
            c->flags |= CLIENT_REPLY_OFF;
        // 如果是 SKIP
        } else if (!strcasecmp(c->argv[2]->ptr,"skip")) {
            // 沒有設(shè)置 OFF 則設(shè)置 SKIP 標(biāo)志
            if (!(c->flags & CLIENT_REPLY_OFF))
                c->flags |= CLIENT_REPLY_SKIP_NEXT;
        } else {
            addReply(c,shared.syntaxerr);
            return;
        }
    //  CLIENT KILL [ip:port] [ID client-id] [TYPE normal | master | slave | pubsub] [ADDR ip:port] [SKIPME yes / no]
    } else if (!strcasecmp(c->argv[1]->ptr,"kill")) {
        /* CLIENT KILL <ip:port>
         * CLIENT KILL <option> [value] ... <option> [value] */
        char *addr = NULL;
        int type = -1;
        uint64_t id = 0;
        int skipme = 1;
        int killed = 0, close_this_client = 0;
        // CLIENT KILL addr:port只能通過地址殺死client，舊版本兼容
        if (c->argc == 3) {
            /* Old style syntax: CLIENT KILL <addr> */
            addr = c->argv[2]->ptr;
            skipme = 0; /* With the old form, you can kill yourself. */
        // 新版本可以根據(jù)[ID client-id] [master|normal|slave|pubsub] [ADDR ip:port] [SKIPME yes/no]殺死client
        } else if (c->argc > 3) {
            int i = 2; /* Next option index. */
            /* New style syntax: parse options. */
            // 解析語法
            while(i < c->argc) {
                int moreargs = c->argc > i+1;
                // CLIENT KILL [ID client-id]
                if (!strcasecmp(c->argv[i]->ptr,"id") && moreargs) {
                    long long tmp;
                    // 獲取client的ID
                    if (getLongLongFromObjectOrReply(c,c->argv[i+1],&tmp,NULL)
                        != C_OK) return;
                    id = tmp;
                // CLIENT KILL TYPE type, 這里的 type 可以是 [master|normal|slave|pubsub]
                } else if (!strcasecmp(c->argv[i]->ptr,"type") && moreargs) {
                    // 獲取client的類型，[master|normal|slave|pubsub]四種之一
                    type = getClientTypeByName(c->argv[i+1]->ptr);
                    if (type == -1) {
                        addReplyErrorFormat(c,"Unknown client type '%s'",
                            (char*) c->argv[i+1]->ptr);
                        return;
                    }
                // CLIENT KILL [ADDR ip:port]
                } else if (!strcasecmp(c->argv[i]->ptr,"addr") && moreargs) {
                    // 獲取ip:port
                    addr = c->argv[i+1]->ptr;
                // CLIENT KILL [SKIPME yes/no]
                } else if (!strcasecmp(c->argv[i]->ptr,"skipme") && moreargs) {
                    // 如果是yes，設(shè)置設(shè)置skipme，調(diào)用該命令的客戶端將不會被殺死
                    if (!strcasecmp(c->argv[i+1]->ptr,"yes")) {
                        skipme = 1;
                    // 設(shè)置為no會影響到還會殺死調(diào)用該命令的客戶端。
                    } else if (!strcasecmp(c->argv[i+1]->ptr,"no")) {
                        skipme = 0;
                    } else {
                        addReply(c,shared.syntaxerr);
                        return;
                    }
                } else {
                    addReply(c,shared.syntaxerr);
                    return;
                }
                i += 2;
            }
        } else {
            addReply(c,shared.syntaxerr);
            return;
        }
        /* Iterate clients killing all the matching clients. */
        listRewind(server.clients,&li);
        // 迭代所有的client節(jié)點(diǎn)
        while ((ln = listNext(&li)) != NULL) {
            client = listNodeValue(ln);
            // 比較當(dāng)前client和這四類信息，如果有一個不符合就跳過本層循環(huán)，否則就比較下一個信息
            if (addr && strcmp(getClientPeerId(client),addr) != 0) continue;
            if (type != -1 && getClientType(client) != type) continue;
            if (id != 0 && client->id != id) continue;
            if (c == client && skipme) continue;
            /* Kill it. */
            // 殺死當(dāng)前的client
            if (c == client) {
                close_this_client = 1;
            } else {
                freeClient(client);
            }
            // 計算殺死client的個數(shù)
            killed++;
        }
        /* Reply according to old/new format. */
        // 回復(fù)client信息
        if (c->argc == 3) {
            // 沒找到符合信息的
            if (killed == 0)
                addReplyError(c,"No such client");
            else
                addReply(c,shared.ok);
        } else {
            // 發(fā)送殺死的個數(shù)
            addReplyLongLong(c,killed);
        }
        /* If this client has to be closed, flag it as CLOSE_AFTER_REPLY
         * only after we queued the reply to its output buffers. */
        if (close_this_client) c->flags |= CLIENT_CLOSE_AFTER_REPLY;
    //  CLIENT SETNAME connection-name
    } else if (!strcasecmp(c->argv[1]->ptr,"setname") && c->argc == 3) {
        int j, len = sdslen(c->argv[2]->ptr);
        char *p = c->argv[2]->ptr;
        /* Setting the client name to an empty string actually removes
         * the current name. */
        // 設(shè)置名字為空
        if (len == 0) {
            // 先釋放掉原來的名字
            if (c->name) decrRefCount(c->name);
            c->name = NULL;
            addReply(c,shared.ok);
            return;
        }
        /* Otherwise check if the charset is ok. We need to do this otherwise
         * CLIENT LIST format will break. You should always be able to
         * split by space to get the different fields. */
        // 檢查名字格式是否正確
        for (j = 0; j < len; j++) {
            if (p[j] < '!' || p[j] > '~') { /* ASCII is assumed. */
                addReplyError(c,
                    "Client names cannot contain spaces, "
                    "newlines or special characters.");
                return;
            }
        }
        // 釋放原來的名字
        if (c->name) decrRefCount(c->name);
        // 設(shè)置新名字
        c->name = c->argv[2];
        incrRefCount(c->name);
        addReply(c,shared.ok);
    //  CLIENT GETNAME
    } else if (!strcasecmp(c->argv[1]->ptr,"getname") && c->argc == 2) {
        // 回復(fù)名字
        if (c->name)
            addReplyBulk(c,c->name);
        else
            addReply(c,shared.nullbulk);
    //  CLIENT PAUSE timeout
    } else if (!strcasecmp(c->argv[1]->ptr,"pause") && c->argc == 3) {
        long long duration;
        // 以毫秒為單位將等待時間保存在duration中
        if (getTimeoutFromObjectOrReply(c,c->argv[2],&duration,UNIT_MILLISECONDS)
                                        != C_OK) return;
        // 暫停client
        pauseClients(duration);
        addReply(c,shared.ok);
    } else {
        addReplyError(c, "Syntax error, try CLIENT (LIST | KILL | GETNAME | SETNAME | PAUSE | REPLY)");
    }
}