Redis 主从复制（Replication）

为了保证服务的可用性，现代数据库都提供了复制功能，同时在多个进程中维护一致的数据状态。
Redis 支持一主多从的复制架构，该功能被简化成了一条 SLAVEOF 命令，下面通过条命令来解析 Redis 的主从复制机制。

通过 tcpdump 观察

在本机上通过 redis-server 启动两个服务，然后通过 tcpdump 观察主从间的交互情况：

redis-server --port 6379 --requirepass 123456 # 启动 master
redis-server --port 6380 --masterauth 123456  # 启动 slave
tcpdump -t -i lo0 host localhost and port 6379 | awk -F ']' '{print $1"]"$3}'

# 在 localhost:6380 上执行 SLAVEOF localhost 6379 建立同步连接，进入 Full-ReSync 阶段
localhost.59297 > localhost.6379: Flags [S]
localhost.6379 > localhost.59297: Flags [S.]
localhost.59297 > localhost.6379: Flags [P.] "PING"
localhost.6379 > localhost.59297: Flags [P.] "NOAUTH Authentication required."
localhost.59297 > localhost.6379: Flags [P.] "AUTH 123456"
localhost.6379 > localhost.59297: Flags [P.] "OK"
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF listening-port 6380"
localhost.6379 > localhost.59297: Flags [P.] "OK":
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF capa eof"
localhost.6379 > localhost.59297: Flags [P.] "OK":
localhost.59297 > localhost.6379: Flags [P.] "PSYNC ? -1"
localhost.6379 > localhost.59297: Flags [P.] "FULLRESYNC 8efb6ca4edf1258c05a5ced43b0c73fe4deb1908 1"
localhost.6379 > localhost.59297: Flags [P.] [|RESP:
localhost.6379 > localhost.59297: Flags [P.] "REDIS0007M-z^Iredis-ver^F3.2.11M-z" [|RESP

# 完成 Full-ReSync 后进入 Propagation 阶段
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "1"
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "1"
localhost.6379 > localhost.59297: Flags [P.] "PING"
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "15"
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "15"
localhost.6379 > localhost.59297: Flags [P.] "SELECT" "0" "SET" "KEY" "VALUE"
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "85"
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "85"
localhost.6379 > localhost.59297: Flags [P.] "SET" "KEY2" "VALUE2"
localhost.6379 > localhost.59297: Flags [P.] "MSET" "KEY3" "VALUE3" "KEY4" "VALUE4" "KEY5" "VALUE5"
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "256"
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "256"
localhost.6379 > localhost.59297: Flags [P.] "PING"
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "270"
localhost.59297 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "270"

# 在 localhost:6380 上执行 DEBUG SLEEP 60 模拟网络中断的情况
localhost.6379 > localhost.59297: Flags [P.] "PING"
localhost.6379 > localhost.59297: Flags [P.] "SET" "KEY6" "VALUE6"
localhost.6379 > localhost.59297: Flags [P.] "SET" "KEY7" "VALUE7"
localhost.6379 > localhost.59297: Flags [P.] "PING"
localhost.6379 > localhost.59297: Flags [P.] "MSET" "KEY8" "VALUE8" "KEY9" "VALUE9"
localhost.6379 > localhost.59297: Flags [P.] "PING"
localhost.6379 > localhost.59297: Flags [P.] "PING"
localhost.59297 > localhost.6379: Flags [.]
localhost.59297 > localhost.6379: Flags [R.]

# 旧的同步连接断开后重新建立同步连接，进入 Partical-ReSync 阶段
localhost.59313 > localhost.6379: Flags [S]
localhost.6379 > localhost.59313: Flags [S.]
localhost.59313 > localhost.6379: Flags [P.] "PING"
localhost.6379 > localhost.59313: Flags [P.] "NOAUTH Authentication required."
localhost.59313 > localhost.6379: Flags [P.] "AUTH 123456"
localhost.6379 > localhost.59313: Flags [P.] "OK"
localhost.59313 > localhost.6379: Flags [P.] "REPLCONF listening-port 6380"
localhost.6379 > localhost.59313: Flags [P.] "OK"
localhost.59313 > localhost.6379: Flags [P.] "REPLCONF capa eof"
localhost.6379 > localhost.59313: Flags [P.] "OK"
localhost.59313 > localhost.6379: Flags [P.] "PSYNC 8efb6ca4edf1258c05a5ced43b0c73fe4deb1908 271"
localhost.6379 > localhost.59313: Flags [P.] "CONTINUE"
localhost.6379 > localhost.59313: Flags [P.] "PING" "PING" "SET" "KEY6" "VALUE6" "PING" "SET" "KEY7" "VALUE7" "PING" "MSET" "KEY8" "VALUE8" "KEY9" "VALUE9" "PING" "PING"
localhost.59313 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "519"
localhost.59313 > localhost.6379: Flags [P.] "REPLCONF" "ACK" "519"
localhost.6379 > localhost.59313: Flags [P.] "PING"
localhost.59313 > localhost.6379: Flags [P.]: "REPLCONF" "ACK" "533"
localhost.59313 > localhost.6379: Flags [P.]: "REPLCONF" "ACK" "533"

整个过程可以分为 Full-ReSync, Command-Propagate, Partical-ReSync 总共 3 阶段：

             +----------------------+                +---------------------+
             | redisServer (master) |                | redisServer (slave) |
             |    localhost:6379    |                |    localhost:6380   |
             +----------------------+                +---------------------+ 
             |        slaves        |                |        master       | 
             +----------------------+                +---------------------+ 
                        |                                       |
                 +----------------+                      +-------------+
                 | redisClient[?] |                      | redisClient |  
                 +----------------+                      +-------------+
                                                                |
       ^                <<<<<<<<<<<<<<<<<< PING <<<<<<<<<<<<<<<<<                
       |                |                                               Step 1 : 检查套接字与 master 状态
       |                >>>>>>>>>>>>> PONG / NOAUTH >>>>>>>>>>>>>                
       |                                                        |                
       |                <<<<<<<<<<<<<<<<<< AUTH <<<<<<<<<<<<<<<<<                
       |                |                                               Step 2 : 身份验证
       |                >>>>>>>>>>>>>>>>>>> OK >>>>>>>>>>>>>>>>>>                
       |                                                        |                
       |                <<<< REPLCONF listening-port [port] <<<<<                
       |                |                                               Step 3 : 发送 slave 端口 
   Full-ReSync          >>>>>>>>>>>>>>>>>>> OK >>>>>>>>>>>>>>>>>>           
       |                                                        |                
       |                <<<<<< REPLCONF capa [eof|psync2] <<<<<<<                
       |                |                                               Step 4 : 检查命令兼容性
       |                >>>>>>>>>>>>>>>>>>> OK >>>>>>>>>>>>>>>>>>                
       |                                                        |                
       |                <<<<<<<<<<<<<< PSYNC ? -1 <<<<<<<<<<<<<<<                
       |                |                                                        
       |                >>>>>> FULLRESYNC [replid] [offset] >>>>>       Step 6 : 执行全量同步
       |                V                                                        
       |              BGSAVE                                                     
       |                V                                                        
       v                >>>>>>>>>>>>> RDB Snapshot >>>>>>>>>>>>>>                


       ^                <<<<<<<<< REPLCONF ACK [offset] <<<<<<<<<               
       |                >>>>>>>>>>>>>>> COMMAND 1 >>>>>>>>>>>>>>>                
       |                >>>>>>>>>>>>>>> COMMAND 2 >>>>>>>>>>>>>>>                
       |                <<<<<<<< REPLCONF ACK [offset+?] <<<<<<<<       心跳检测 & 命令传播         
Command-Propagate       >>>>>>>>>>>>>>>>>> PING >>>>>>>>>>>>>>>>>          
       |                >>>>>>>>>>>>>>> COMMAND 3 >>>>>>>>>>>>>>>                
       |                <<<<<<<< REPLCONF ACK [offset+?] <<<<<<<<                
       |                <<<<<<<< REPLCONF ACK [offset+?] <<<<<<<<                
       v                >>>>>>>>>>>>>>>>>> PING >>>>>>>>>>>>>>>>>                


       ^                =========================================                
       |                ====== The Same With Full-ReSync ========                
       |                =========================================                
       |                                                        |                
  Partical-ReSync       <<<<<<<< PSYNC [replid] [offset] <<<<<<<<       重连后执行部分同步
       |                |                                                        
       |                >>>>>>>>>>>>>>> CONTINUE >>>>>>>>>>>>>>>>                
       |                >>>>>>>>>>>>>>> COMMAND N >>>>>>>>>>>>>>>                
       v                >>>>>>>>>>>>>>> COMMAND ... >>>>>>>>>>>>>                

PSYNC 命令

最初 Redis 用于同步的命令是SYNC，每次重连执行该命令时都会生成、传输、加载整个完整的 RDB 快照，严重占用机器资源与网络带宽。为了解决这一问题，后续版本的 Redis 追加了PSYNC命令，该命令支持以下两种同步模式：

• 全量重新同步Full-ReSync
  • slave 首次连接 master
  • master 与 slave 之间的状态差异过大
• 部分重新同步Partical-ReSync
  • 网络抖动导致同步连接断开重连
  • sentinel 机制导致 master 节点发生变更

数据结构

下面看看 redisServer 中与PSYNC相关的数据结构：

struct redisServer {
    /*
     *  节点ID 与 复制偏移量
     *
     *     若当前节点是 master
     *     server.replid 就是 server.runid
     *
     *     若当前节点原本是 master，转化为 slave 节点后
     *     server.replid 与 server.master_repl_offset 会被新 master 的同步信息覆盖
     *
     *     若当前节点原本是 slave，被提升为 master 节点后
     *     rserver.eplid2 与 server.second_replid_offset 会记录当前节点作为 slave 时的同步信息
     */
    char runid[CONFIG_RUN_ID_SIZE+1];   /* 当前节点的运行时ID（每次重启都会发生变化） */
    char replid[CONFIG_RUN_ID_SIZE+1];  /* 当前 master 节点的 runid */
    char replid2[CONFIG_RUN_ID_SIZE+1]; /* 当前 master 节点作为 slave 节点时连接的 master 的 runid */
    long long master_repl_offset;   /* 当前 master 节点的复制偏移量 */
    long long second_replid_offset; /* 当前 master 节点作为 slave 节点时的同步偏移量 */

    /*
     * 复制积压缓冲
     *
     *     master 只维护一个全局的 server.repl_backlog，由所有 slave 节点共享 
     *     为了减少内存占用，server.repl_backlog 仅在 slave 节点存在时按需创建
     */
    char *repl_backlog;             /* 复制积压缓冲（环形缓冲）*/
    long long repl_backlog_size;    /* 积压缓冲大小 */
    long long repl_backlog_histlen; /* 积压数据长度 */
    long long repl_backlog_idx;     /* 积压缓冲尾部（可写位置）*/
    long long repl_backlog_off;     /* 积压缓冲首字节对应的同步偏移量（master offset）*/
}

运行ID

　无论主从，每个 Redis 服务器会在启动时生成一个长度为 40 的十六进制字符串作为运行IDrunid：

• 当 slave 首次请求同步时，会将 master 返回的server.runid保存至server.replid
• 当 slave 重新请求同步时，会将之前保存的server.replid发送给 master：
  • 如果该 ID 与当前 master 的server.runid不一致，则必须执行一次全量重新同步
  • 如果该 ID 与当前 master 的server.runid一致，则可以尝试执行部分同步操作

复制偏移量

　主从双方都会维护一个单位为字节的复制偏移量offset，通过该偏移量可以判断主从间的状态是否一致：

• master 向 slave 传播 N 字节数据后，会将自己的复制偏移量增加 N
• slave 接收到 master 传来的 N 个字节数据时，会将自己的复制偏移量增加 N

　当 master 接收到 REPLCONF ACK 中的偏移量时，可以据此判断发送给 slave 的数据是否发生了丢失，并重发丢失的数据。

积压缓冲

　master 端维护了一个定长的积压缓冲队列backlog。
　master 向 slave 传播命令时会同时将命令放入该队列，因此缓冲区里会保留一部分最新的命令。
　slave 发出同步请求时，如果 slave 的偏移量之后 (offset+1) 的数据存在于积压缓冲，master 才会执行部分同步。

同步流程

SLAVE 视角

slave 接收到SLAVEOF命令后，会调用replicaofCommand开始执行主从同步：

void replicaofCommand(client *c) {
    // ...

    if (!strcasecmp(c->argv[1]->ptr,"no") &&
        !strcasecmp(c->argv[2]->ptr,"one")) {
        if (server.masterhost) { // 如果接收到的命令是 SLAVE NO ONE 则断开主从同步
            // ...
        }
    } else { 
        if (c->flags & CLIENT_SLAVE) {
            return; // 如果已经是客户端是一个 slave 节点，则拒绝该命令
        }

        if (server.masterhost && !strcasecmp(server.masterhost,c->argv[1]->ptr) && server.masterport == port) {
            return; // 如果已经连接上 SLAVEOF 中指定的 master 节点，则直接返回
        }

        // 如果尚未连接任意 master 节点，则根据 masterhost 与 masterport 建立 TCP 连接
        // 并注册监听函数 syncWithMaster
    }
}

void syncWithMaster(connection *conn) {
    // 向 master 节点发送 PING 命令
    if (server.repl_state == REPL_STATE_CONNECTING) {
        server.repl_state = REPL_STATE_RECEIVE_PONG;
        err = sendSynchronousCommand(SYNC_CMD_WRITE,conn,"PING",NULL); // 发送 PING 命令
        // ...
    }

    // 监听到 master 对 PING 命令的响应
    if (server.repl_state == REPL_STATE_RECEIVE_PONG) {
        if (err[0] != '+' &&
            strncmp(err,"-NOAUTH",7) != 0 &&
            strncmp(err,"-NOPERM",7) != 0 &&
            strncmp(err,"-ERR operation not permitted",28) != 0)
        {
            goto error;
        }
        server.repl_state = REPL_STATE_SEND_AUTH; // 只处理 master 响应值为 PONG、NOAUTH、NOPERM 的情况
    }

    // 根据 master 对 PING 的响应值，判断是否需要授权
    if (server.repl_state == REPL_STATE_SEND_AUTH) {
        if (server.masteruser && server.masterauth) {
            err = sendSynchronousCommand(SYNC_CMD_WRITE,conn,"AUTH",
                                         server.masteruser,server.masterauth,NULL); // 发送 AUTH 命令
            // ...
            server.repl_state = REPL_STATE_RECEIVE_AUTH;
        } else {
            // 如果没有设置 server.masteruser 与 server.masterauth 授权信息，则跳过 AUTH
            server.repl_state = REPL_STATE_SEND_PORT;
        }
    }

    // 此处略过以下步骤：
    // 使用 REPLCONF listening-port 命令将 slave 的端口告知 master
    // 使用 REPLCONF ip-address 命令将 slave 的 IP 告知 master
    // 使用 REPLCONF capa eof / capa psync2 命令将 slave 兼容性（支持的特性）告知 master

     // 开始发送 PSYNC 命令
    if (server.repl_state == REPL_STATE_SEND_PSYNC) {
        if (slaveTryPartialResynchronization(conn,0) == PSYNC_WRITE_ERROR) {
            goto write_error;
        }
        server.repl_state = REPL_STATE_RECEIVE_PSYNC;
        return;
    }

    // 读取 PSYNC 命令的响应
    psync_result = slaveTryPartialResynchronization(conn,1);

    // 如果监听到 CONTINUE 响应，跳过全量同步
    if (psync_result == PSYNC_CONTINUE) return;

    // 如果返回值为 PSYNC_FULLRESYNC 或 PSYNC_NOT_SUPPORTED
    // 开始执行执行全量同步，注册 readSyncBulkPayload 监听 RDB 文件下载
    if (connSetReadHandler(conn, readSyncBulkPayload) == C_ERR) {
        // ...
        goto error;
    }

    server.repl_state = REPL_STATE_TRANSFER;

    // ...
}

int slaveTryPartialResynchronization(connection *conn, int read_reply) {
    if (!read_reply) {
        if (server.cached_master) { // server.cached_master 中存在记录，尝试执行部分同步
            psync_replid = server.cached_master->replid;
        } else {
            psync_replid = "?"; // server.cached_master 中不存在记录，只能执行全量同步
        }
        // 发起 PSYNC 命令
        reply = sendSynchronousCommand(SYNC_CMD_WRITE,conn,"PSYNC",psync_replid,psync_offset,NULL);
        // ...
        return PSYNC_WAIT_REPLY;
    }

    reply = sendSynchronousCommand(SYNC_CMD_READ,conn,NULL); // 读取 PSYNC 响应

    // 如果 master 响应 FULLRESYNC 则直接进行全量同步
    if (!strncmp(reply,"+FULLRESYNC",11)) {
        // ...
        return PSYNC_FULLRESYNC;
    }

    // 如果 master 响应 CONTINUE 则尝试执行部分同步
    if (!strncmp(reply,"+CONTINUE",9)) {
        // ...
        return PSYNC_CONTINUE;
    }

    // master 暂时无法处理 PSYNC 命令 —> PSYNC_TRY_LATER
    // master 不支持 PSYNC 命令 -> PSYNC_NOT_SUPPORTED
}

MASTER 视角

master 接收到PSYNC命令后，会调用syncCommand开启同步流程：

void syncCommand(client *c) {
    // 接收到 slave 发送的 PSYNC 命令
    if (!strcasecmp(c->argv[0]->ptr,"psync")) {
        if (masterTryPartialResynchronization(c) == C_OK) {
            return; // 无需全量同步，直接返回
        }
    }

    // 若代码运行至此处，意味着部分同步失败，需要执行全量同步
    // master 会执行 BGSAVE 命令生成快照并传输给 slave
    // 同步 RDB 快照的方式有两种：
    //     基于磁盘(Disk-backed)：在磁盘生成 RDB 快照文件，然后再传输给 slave
    //     无盘(Diskless)：直接将 RDB 快照数据写入 slave socket

}

int masterTryPartialResynchronization(client *c) {
    long long psync_offset; // 该 slave 最新的同步偏移量
    char *master_replid;    // slave 同步偏移量对应的 master 的 runid

    /*
     *  以下情况可以避免全量同步：
     *  1. slave 最近一次同步的 master 是当前实例（网络抖动）
     *  2. slave 与当前节点原本是同个 master 的从节点，且当前节点的同步偏移量 second_replid_offset 较大（维护重启、故障切换）*/

    if (strcasecmp(master_replid, server.replid) &&
       (strcasecmp(master_replid, server.replid2) ||psync_offset > server.second_replid_offset))
    {
        goto need_full_resync; // 不满足 PSYNC 条件，需要执行全量同步
    }

    /*
     *  以下情况只能执行全量同步：
     *  1. master 没有初始化积压缓冲 
     *  2. slave 的同步偏移量落后于积压缓冲 */
    if (!server.repl_backlog || 
        psync_offset < server.repl_backlog_off ||
        psync_offset > (server.repl_backlog_off + server.repl_backlog_histlen))
    {
        goto need_full_resync; // 进行全量同步
    }

    // 若代码运行至此处，意味着可以执行部分同步
    listAddNodeTail(server.slaves,c);

    // 根据客户端是否兼容 PSYNC2，返回不同的 CONTINUE 响应
    if (c->slave_capa & SLAVE_CAPA_PSYNC2) {
        buflen = snprintf(buf,sizeof(buf),"+CONTINUE %s
", server.replid);
    } else {
        buflen = snprintf(buf,sizeof(buf),"+CONTINUE
");
    }

    // CONTINUE 命令后面，紧接着就是 server.repl_backlog 的内容
    psync_len = addReplyReplicationBacklog(c,psync_offset);

    // ...

}

心跳 & 命令传播

Redis 每秒会执行一次定时任务replicationCron，其中就包含主从同步间的心跳，可以发现主从双方的心跳频率是不一致的：

void replicationCron(void) {

    // slave 定时向 master 发送 REPLCONF ACK 命令
    if (server.masterhost && server.master &&
        !(server.master->flags & CLIENT_PRE_PSYNC)) {
        addReplyArrayLen(c,3);
        addReplyBulkCString(c,"REPLCONF");
        addReplyBulkCString(c,"ACK");
        addReplyBulkLongLong(c,c->reploff);
    }

    // master 定时向 slave 发送 PING 命令
    if ((replication_cron_loops % server.repl_ping_slave_period) == 0 &&
        listLength(server.slaves))
    {
        robj *ping_argv[1];
        ping_argv[0] = createStringObject("PING",4);
        replicationFeedSlaves(server.slaves, server.slaveseldb, ping_argv, 1);
        decrRefCount(ping_argv[0]);
    }
}

master 在调用call函数执行客户端传过来的命令时，会将命令传播给 slave 并同时写入积压缓冲：

void call(client *c, int flags) {
    // ...
    if (flags & CMD_CALL_PROPAGATE && (c->flags & CLIENT_PREVENT_PROP) != CLIENT_PREVENT_PROP)
    {
        // 当前命令是否需要传播
        if (propagate_flags != PROPAGATE_NONE && !(c->cmd->flags & CMD_MODULE))
            propagate(c->cmd,c->db->id,c->argv,c->argc,propagate_flags);
    }
}

void propagate(struct redisCommand *cmd, int dbid, robj **argv, int argc,
               int flags)
{
    // ...
    if (flags & PROPAGATE_REPL)
        replicationFeedSlaves(server.slaves,dbid,argv,argc);
}

void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc) {

    // 如果当前节点没有 slave 节点或复制积压缓冲，立即返回
    if (server.repl_backlog == NULL && listLength(slaves) == 0) return;

    // 向 repl_backlog 中批量写入命令
    if (server.repl_backlog) {
        char aux[LONG_STR_SIZE+3]; // 命令缓冲，用于序列化 redis 命令

        /* 写入当前批次的命令数量 */
        aux[0] = '*';
        len = ll2string(aux+1,sizeof(aux)-1,argc);
        aux[len+1] = '
';
        aux[len+2] = '
';
        feedReplicationBacklog(aux,len+3);

        /* 逐个遍历命令，将其序列化后写入 repl_backlog */
        for (j = 0; j < argc; j++) {
            long objlen = stringObjectLen(argv[j]);
            
            aux[0] = '$';
            len = ll2string(aux+1,sizeof(aux)-1,objlen);
            aux[len+1] = '
';
            aux[len+2] = '
';
            feedReplicationBacklog(aux,len+3);
            feedReplicationBacklogWithObject(argv[j]);
            feedReplicationBacklog(aux+len+1,2);
        }
    }

    // 将命令批量传播给所有 slaves 对应的 client
    listRewind(slaves,&li);
    while((ln = listNext(&li))) {
        client *slave = ln->value;

        /* 写入当前批次的命令数量 */
        addReplyArrayLen(slave,argc);

        /* 逐个遍历命令，将传播给 slave 节点 */
        for (j = 0; j < argc; j++)
            addReplyBulk(slave,argv[j]);
    }
}

相关参数

slave-serve-stale-data

　主从节点断开时或同步未完成时，slave 如何响应客户端请求

• yes：正常响应命令，但是不保证数据质量
• no：拒绝响应命令，返回 SYNC with master in progress

repl-diskless-sync

　执行全量同步时，master 如何将 RDB 快照传输给 slave

• no：先在磁盘生成 RDB 文件再进行传输（低带宽网络）
• yes：直接将 RDB 快照写入 slave 的 socket（低速磁盘 + 高带宽网络）

repl-ping-slave-period

　master 向 slave 发送 PING 心跳的间隔，默认 10s 发送一次

repl-backlog-size

　同步积压缓冲的空间，默认值大小为 1mb。
　由于主从连接断开后，所有的命令都会积压在这里，如果该值太小会导致 PSYNC 命令会无法执行部分同步。
　如果 master 需要执行大量写命令，或者 slave 需要较长时间才能重连成功，则需要根据实际情况进行估算。

min-slaves-to-write & min-slaves-max-lag

　则当不满足下列条件时，master 会拒绝写命令直至恢复：

• 连接当前 master 的 slave 数量大于等于 min-slaves-to-write 个节点连接正常
• 连接正常的 slave 节点中不少于 min-slaves-to-write 个节点的延迟时间小于 *min-slaves-max-lag 秒

　启用这两个选项后，写命令大概率能够被复制到 min-slaves-to-write 个从节点中，减少了命令丢失的概率。


至此，对 redis 的主从同步分析完毕，后续将对 redis 的一些其他细节进行分享，感谢观看。