redis replication主从复制的源码分析(2)

已于 2024-07-03 15:42:20 修改
阅读量1.4k 收藏 2
点赞数 1
分类专栏： redis redis源码 文章标签： redis redis源码分析 数据库 多进程 主从复制
于 2017-03-28 18:08:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hangbo216/article/details/67637095
版权

       前面的文章《redis replication主从复制的源码分析(1)》分析来进行主从复制的流程，现在我们来分析redis复制的实现。

      同步主要是从服务器进行主从连接时，将从服务器的数据库状态更新至主服务器的数据库状态。

1、 同步类型

       redis的同步分为部分重同步和完整重同步：

       1）完整重同步：通过主服务器创建rdb文件发送给从服务器，同时将从开始创建rdb文件后执行的写命令记录在一个缓冲区，然后在传输完rdb文件后将发送缓冲区中的记录发送给从服务器。

       2）部分重同步：主服务器将主从连接断开期间执行的写命令，发送给从服务器，从服务器执行这些命令就能保持与主服务器状态一致。

2、同步的应用场景

        同步的应用场景有两种初次同步和断线重连后同步：

       1）初次同步使用完全重同步。

       2）断线后同步由于在断开连接后，会创建master的cache用于之后断线重连以避免进行完整重同步。这样我们就需要一个变量来记录主从服务器偏差——复制偏移量，通过比对主从服务器的复制偏移量确定主从服务器状态一致性。此外，还有一个复制积压缓冲区来记录最近传播的命令，并且复制积压缓冲区的每个字节记录相应的偏移量，这样的设计主要是为了部分重同步。根据判断从服务器的偏移量是否在积压缓冲区内决定部分重同步还是完整重同步。

3、同步的实现

slave部分的实现

         1）发送psync给master，psync runid offset;

         2）根据master的reply，进行部分重同步或者完整重同步；

与master进行同步

void syncWithMaster(aeEventLoop *el, int fd, void *privdata, int mask) {
    ……
    if (server.repl_state == REPL_STATE_SEND_PSYNC) {
        //发送psync命令给master
        if (slaveTryPartialResynchronization(fd,0) == PSYNC_WRITE_ERROR) {
        ……    }
    ……//读取master对于psync的reply
    psync_result = slaveTryPartialResynchronization(fd,1);
    if (psync_result == PSYNC_CONTINUE) {
        //进行部分重同步
        return;
    }
    ……//完整重同步，创建rdb文件用来接收master发送过来的rdb文件
    while(maxtries--) {
        snprintf(tmpfile,256,"temp-%d.%ld.rdb",(int)server.unixtime,(long int)getpid());
        dfd = open(tmpfile,O_CREAT|O_WRONLY|O_EXCL,0644);
    }
    //设置接受mester的rdb文件的处理函数readSyncBulkPayload
    if (aeCreateFileEvent(server.el,fd, AE_READABLE,readSyncBulkPayload,NULL)== AE_ERR)
    {……}
    server.repl_state = REPL_STATE_TRANSFER;
    ……
    return;
    ……
}

slave发送psync尝试部分重同步

int slaveTryPartialResynchronization(int fd, int read_reply) {
     ……/* 发送psync命令给master*/
    if (!read_reply) {
        server.master_initial_offset = -1;
        if (server.cached_master) {
        //有cached_master,断线重连，获取复制偏移量
            psync_replid = server.cached_master->replid;
            snprintf(psync_offset,sizeof(psync_offset),"%lld", server.cached_master->reploff+1);
        } else {//初次同步
            psync_replid = "?";
            memcpy(psync_offset,"-1",3);
        }//发送PSYNC给master  psync runid  offset
        reply = sendSynchronousCommand(SYNC_CMD_WRITE,fd,"PSYNC",psync_replid,psync_offset,NULL);
        if (reply != NULL) {
            return PSYNC_WRITE_ERROR;
        }
        return PSYNC_WAIT_REPLY;
    }
    /* 读取master对于psync的reply，完整重同步or部分重同步 */
    reply = sendSynchronousCommand(SYNC_CMD_READ,fd,NULL);
    if (sdslen(reply) == 0) {
        return PSYNC_WAIT_REPLY;
    }
    if (!strncmp(reply,"+FULLRESYNC",11)) {
        ……//从服务器进行完整重同步
        replicationDiscardCachedMaster();//断线重连，丢弃cached_master
        return PSYNC_FULLRESYNC;
    }
    if (!strncmp(reply,"+CONTINUE",9)) {
        ……//进行部分重同步
        replicationResurrectCachedMaster(fd);//复活master
        return PSYNC_CONTINUE;
    }
    ……
}

slave复活master，接收master的backlog，进行部分重同步

void replicationResurrectCachedMaster(int newfd) {
    server.master = server.cached_master;
    server.cached_master = NULL;
    server.master->fd = newfd;
    server.master->flags &= ~(CLIENT_CLOSE_AFTER_REPLY|CLIENT_CLOSE_ASAP);
    server.master->authenticated = 1;
    server.master->lastinteraction = server.unixtime;
    server.repl_state = REPL_STATE_CONNECTED;
    listAddNodeTail(server.clients,server.master);
    //等待读取master发送过来的写命令
    if (aeCreateFileEvent(server.el, newfd, AE_READABLE,
                  readQueryFromClient, server.master)) {
        freeClientAsync(server.master); /* Close ASAP. */
    }
    if (clientHasPendingReplies(server.master)) {
        if (aeCreateFileEvent(server.el, newfd, AE_WRITABLE,
                          sendReplyToClient, server.master)) {
            freeClientAsync(server.master); /* Close ASAP. */
        }
    }
}

slave接收rdb，载入rdb进行完整重同步，创建master

void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
    ……
    //接收master的rdb
    nread = read(fd,buf,readlen);
    ……
    server.repl_transfer_lastio = server.unixtime;
    //master的rdb写入到本地的同步rdb
    if (write(server.repl_transfer_fd,buf,nread) != nread) {
        goto error;
    }
    ……    
    /* Check if the transfer is now complete */
    if (!usemark) {
        if (server.repl_transfer_read == server.repl_transfer_size)
            eof_reached = 1;
    }
    if (eof_reached) {
        ……//本地的同步rdb导入到内存
        if (rdbLoad(server.rdb_filename,&rsi) != C_OK) {
            return;
        }
        replicationCreateMasterClient(server.repl_transfer_s,rsi.repl_stream_db);
        server.repl_state = REPL_STATE_CONNECTED;
        ……
    }
    return;
}

master部分的实现

      1）根据runid和offset使用完整重同步和部分重同步，返回+CONTINUE或者+FULLRESYNC；

      2）如果部分重同步，master发送backlog中offset后面的写命令给slave进行同步；如果是完整重同步，master就进行bgsave创建rdb文件然后发送给slave进行完整重同步，完整重同步期间master执行的写命令会通过命令传播写到slave的output buffer，完整重同步完成后，将output buffer的数据发送给slave实现主从一致；

      3）replstate为SLAVE_STATE_ONLINE表示同步完成后，进入命令传播阶段，通过命令传播来保持主从服务器的数据库状态一致性；

//同步命令处理函数
void syncCommand(client *c) ；；{
    ……
    if (!strcasecmp(c->argv[0]->ptr,"psync")) {
        if (masterTryPartialResynchronization(c) == C_OK) {
            return; /* No full resync needed, return. */
        } else {
            char *master_replid = c->argv[1]->ptr;
            if (master_replid[0] != '?') server.stat_sync_partial_err++;
        }
    } 
    c->replstate = SLAVE_STATE_WAIT_BGSAVE_START;
    ……
    c->flags |= CLIENT_SLAVE;//标记client为CLIENT_SLAVE
    listAddNodeTail(server.slaves,c);
    //创建rdb文件
    /* CASE 1: BGSAVE is in progress, with disk target. */
    if (server.rdb_child_pid != -1 &&server.rdb_child_type == RDB_CHILD_TYPE_DISK)
    {
        ……//寻找正在bgsave的slave
        listRewind(server.slaves,&li);
        while((ln = listNext(&li))) {
            slave = ln->value;
            if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_END) break;
        }//判断是否具备正在bgsave的slave的capa
        if (ln && ((c->slave_capa & slave->slave_capa) == slave->slave_capa)) {
            //将该slave的output buffer复制到c的output buffer
            copyClientOutputBuffer(c,slave);
            // 设置c为完整重同步
            replicationSetupSlaveForFullResync(c,slave->psync_initial_offset);
        } else {
            //不能利用正在进行的bgsave，等待下一个bgsave
        }
    /* CASE 2: BGSAVE is in progress, with socket target. */
    } else if (server.rdb_child_pid != -1 &&server.rdb_child_type == RDB_CHILD_TYPE_SOCKET)
    {
        serverLog(LL_NOTICE,"Current BGSAVE has socket target. Waiting for next BGSAVE for SYNC");
    /* CASE 3: There is no BGSAVE is progress. */
    } else {
        if (server.repl_diskless_sync && (c->slave_capa & SLAVE_CAPA_EOF)) {
            /* 等待更多的slave，在replictioncron中调用startBgsaveForReplication
            将rdb直接写到slaves的socket*/
            if (server.repl_diskless_sync_delay)
                serverLog(LL_NOTICE,"Delay next BGSAVE for diskless SYNC");
        } else {
            if (server.aof_child_pid == -1) {
                //创建rdb，写入到rdb文件
                startBgsaveForReplication(c->slave_capa); 
            } 
        }
    }
    return;
}

master处理psync runid offset，进行同步

//根据slave的命令中的runid和offset进行相应的同步
int masterTryPartialResynchronization(client *c) {
    ……
    char *master_replid = c->argv[1]->ptr;
    //psync_offset参数解析失败
    if (getLongLongFromObjectOrReply(c,c->argv[2],&psync_offset,NULL) !=
       C_OK) goto need_full_resync;
    //slave发送的runid和master的runid
    if (strcasecmp(master_replid, server.replid) &&
        (strcasecmp(master_replid, server.replid2) ||
         psync_offset > server.second_replid_offset))
    {
        ……//runid不一致完整重同步
        goto need_full_resync;
    }
    /* We still have the data our slave is asking for? */
    if (!server.repl_backlog ||
        psync_offset < server.repl_backlog_off ||
        psync_offset > (server.repl_backlog_off + server.repl_backlog_histlen))
    {
        ……/*1、master没有repl_backlog（复制积压缓冲区）
            2、从服务器的偏移量不在repl_backlog的范围内*/
        goto need_full_resync;
    }
    //进行部分重同步
    c->flags |= CLIENT_SLAVE;
    c->replstate = SLAVE_STATE_ONLINE;//slave上线
    c->repl_ack_time = server.unixtime;
    c->repl_put_online_on_ack = 0;
    listAddNodeTail(server.slaves,c);
    //发送reply给slave
    if (c->slave_capa & SLAVE_CAPA_PSYNC2) {
        buflen = snprintf(buf,sizeof(buf),"+CONTINUE %s\r\n", server.replid);
    } else {
        buflen = snprintf(buf,sizeof(buf),"+CONTINUE\r\n");
    }
    if (write(c->fd,buf,buflen) != buflen) {
        freeClientAsync(c);
        return C_OK;
    }
    //将复制积压缓冲区psync_offset到结束的缓冲全部写到client的outbuffer中,
    //然后发送给client就完成了部分重同步
    psync_len = addReplyReplicationBacklog(c,psync_offset);
    refreshGoodSlavesCount();//增加master的goodslaves的数量
    return C_OK; //表示不需要完整重同步
need_full_resync:
    return C_ERR;//表示需要完整重同步
}

master进行部分重同步发送积压缓冲区的命令记录给slave

//将backlog中offset开始的命令发送给slave
long long addReplyReplicationBacklog(client *c, long long offset) {
    skip = offset - server.repl_backlog_off;
    j = (server.repl_backlog_idx +
        (server.repl_backlog_size-server.repl_backlog_histlen)) %
        server.repl_backlog_size;
    j = (j + skip) % server.repl_backlog_size;
    len = server.repl_backlog_histlen - skip;
    while(len) {
        long long thislen =
            ((server.repl_backlog_size - j) < len) ?
            (server.repl_backlog_size - j) : len;
        addReplySds(c,sdsnewlen(server.repl_backlog + j, thislen));
        len -= thislen;
        j = 0;
    }
    return server.repl_backlog_histlen - skip;
}

master进行完整重同步的bgsave，然后发送rdb文件给slave

//为同步进行bgsave
int startBgsaveForReplication(int mincapa) {
    int socket_target = server.repl_diskless_sync && (mincapa & SLAVE_CAPA_EOF);
    …… //两种bgsave，1、rdb生成直接发给slavesocke；2、持久化到disk
    if (socket_target)
        retval = rdbSaveToSlavesSockets(&rsi);
    else
        retval = rdbSaveBackground(server.rdb_filename,&rsi);
    if (retval == C_ERR) {
        serverLog(LL_WARNING,"BGSAVE for replication failed");
        ……
        return retval;
    }// 设置c为完整重同步
    if (!socket_target) {
        listRewind(server.slaves,&li);
        while((ln = listNext(&li))) {
            client *slave = ln->value;
            if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) {
                    replicationSetupSlaveForFullResync(slave,
                            getPsyncInitialOffset());
            }
        }
    }
    ……
    return retval;
}
int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
    ……//检查bgsave是否完成
    if (pid == server.rdb_child_pid) {
        backgroundSaveDoneHandler(exitcode,bysignal);
    } 
    ……
}
void backgroundSaveDoneHandler(int exitcode, int bysignal) {
    switch(server.rdb_child_type) {
    case RDB_CHILD_TYPE_DISK:
        backgroundSaveDoneHandlerDisk(exitcode,bysignal);
        break;
    case RDB_CHILD_TYPE_SOCKET:
        backgroundSaveDoneHandlerSocket(exitcode,bysignal);
        break;
    }
}
void backgroundSaveDoneHandlerDisk(int exitcode, int bysignal) {
    ……
    updateSlavesWaitingBgsave((!bysignal && exitcode == 0) ? C_OK : C_ERR, RDB_CHILD_TYPE_DISK);
}
void backgroundSaveDoneHandlerSocket(int exitcode, int bysignal) {
    ……
    updateSlavesWaitingBgsave((!bysignal && exitcode == 0) ? C_OK : C_ERR, RDB_CHILD_TYPE_DISK);
}
//完成bgsave的更新slave
void updateSlavesWaitingBgsave(int bgsaveerr, int type) {
    ……
    listRewind(server.slaves,&li);
    while((ln = listNext(&li))) {
        client *slave = ln->value;
        if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) {
            startbgsave = 1;
            mincapa = (mincapa == -1) ? slave->slave_capa :
                                        (mincapa & slave->slave_capa);
        } else if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_END) {
            struct redis_stat buf;
            if (type == RDB_CHILD_TYPE_SOCKET) {
                //rdb文件已经全部传输到socket的缓冲区
                slave->replstate = SLAVE_STATE_ONLINE;//slave上线
                slave->repl_put_online_on_ack = 1;
                slave->repl_ack_time = server.unixtime; /* Timeout otherwise. */
            } else {
                ……//rdb创建完成，发送rdb给client
                slave->repldboff = 0;
                slave->repldbsize = buf.st_size;
                slave->replstate = SLAVE_STATE_SEND_BULK;
                slave->replpreamble = sdscatprintf(sdsempty(),"$%lld\r\n",
                    (unsigned long long) slave->repldbsize);
                aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE);
                if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE, sendBulkToSlave, slave) == AE_ERR) {
                    freeClient(slave);
                    continue;
                }
            }
        }
    }
    if (startbgsave) startBgsaveForReplication(mincapa);
}

发送生成的rdb文件给slave

void sendBulkToSlave(aeEventLoop *el, int fd, void *privdata, int mask) {
    ……//rdb文件的文件描述符，读取rdb文件
    buflen = read(slave->repldbfd,buf,PROTO_IOBUF_LEN);
    // 写入到slave的socket fd
    if ((nwritten = write(fd,buf,buflen)) == -1) {
        if (errno != EAGAIN) {
            freeClient(slave);
        }
        return;
    }
    slave->repldboff += nwritten;
    server.stat_net_output_bytes += nwritten;
    if (slave->repldboff == slave->repldbsize) {
        //rdb全部写入到socket fd的缓冲区
        aeDeleteFileEvent(server.el,slave->fd,AE_WRITABLE);
        putSlaveOnline(slave);//
    }
}
void putSlaveOnline(client *slave) {
    slave->replstate = SLAVE_STATE_ONLINE;//slave上线
    slave->repl_put_online_on_ack = 0;
    slave->repl_ack_time = server.unixtime; /* 发送fd缓冲区的数据到slave */
    if (aeCreateFileEvent(server.el, slave->fd, AE_WRITABLE,
        sendReplyToClient, slave) == AE_ERR) {
        freeClient(slave);
        return;
    }
    refreshGoodSlavesCount();
}

命令传播

      命令传播则是主从同步完成后，在主服务器的数据库状态被修改，将相应的修改操作传播给从服务器，让从服务器与主服务器保持数据状态一致。

cmd执行函数

void call(client *c, int flags) {
    /* Propagate the command into the AOF and replication link */
    if (flags & CMD_CALL_PROPAGATE &&
        (c->flags & CLIENT_PREVENT_PROP) != CLIENT_PREVENT_PROP)
    {
        ……
        if (propagate_flags != PROPAGATE_NONE)
            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 (server.aof_state != AOF_OFF && flags & PROPAGATE_AOF)
        feedAppendOnlyFile(cmd,dbid,argv,argc);
    if (flags & PROPAGATE_REPL)
        replicationFeedSlaves(server.slaves,dbid,argv,argc);
}

传播写命令给slaves

void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc) {
    /* Send SELECT command to every slave if needed. */
    if (server.slaveseldb != dictid) {
        robj *selectcmd;
        /* For a few DBs we have pre-computed SELECT command. */
        if (dictid >= 0 && dictid < PROTO_SHARED_SELECT_CMDS) {
            selectcmd = shared.select[dictid];
        } else {
            int dictid_len;

            dictid_len = ll2string(llstr,sizeof(llstr),dictid);
            selectcmd = createObject(OBJ_STRING,
                sdscatprintf(sdsempty(),
                "*2\r\n$6\r\nSELECT\r\n$%d\r\n%s\r\n",
                dictid_len, llstr));
        }
        /* Send it to slaves. */
        listRewind(slaves,&li);
        while((ln = listNext(&li))) {
            client *slave = ln->value;
            if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) continue;
            addReply(slave,selectcmd);
        }
        if (dictid < 0 || dictid >= PROTO_SHARED_SELECT_CMDS)
            decrRefCount(selectcmd);
    }
    server.slaveseldb = dictid;
    listRewind(slaves,&li);
    while((ln = listNext(&li))) {
        client *slave = ln->value;
        /* 对已经开始bgsave的slave进行命令传播，保证将期间master执行的写命令
        在完整重同步完成后同步到slave*/
        if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) continue;
        /* 添加命令到slave的output buffer*/
        addReplyMultiBulkLen(slave,argc);
        for (j = 0; j < argc; j++)
            addReplyBulk(slave,argv[j]);
    }
}

要点分析     

1、部分重同步

问题：部分重同步时，会不会出现写请求过来不断增量到backlog，导致backlog无限传输？

答：不会。redis是单线程，只能串行的处理命令，而部分重同步时，redis处于处理psync命令中，只有完成部分重同步即将backlog中的写到slave的output buffer中才会处理后续命令。这么看来redis单线程的设计保证了部分重同步的一致性。

2、完全重同步

问题：完全重同步时，进行bgsave创建rdb文件时，并不阻塞写请求，那么会不会redis的dict不断增加，导致创建rdb文件时的循环一直执行下去。
答：不会。bgsave是主进程fork出来的子进程执行的，主进程接收写请求修改的是主进程内存中的dict，而子进程内存中的dict不会随着主进程接收写请求而变化。这么看来redis不用创建线程来执行bgsave而用子进程是为了保证在持久化的dict不变。
wade1991
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis源码分析（8）——replication
架构师专栏
07-31 5428
从源码级别介绍redis的主从同步的实现机制
Redis（九）：主从复制的设计与实现解析
Java后端架构V
01-03 734
前面几篇我们已经完全理解了redis的基本功能的实现了。 　　但单靠基本功能实现，往往还是称不上优秀的项目的。毕竟，我们现在面对的都是复杂的环境，高并发的场景，大数据量的可能。 　　简而言之，现在的系统一般都需要支持分布式部署，不存在单点问题，才算是一个合格的系统。 　　而redis作为一个存储系统，单点问题肯定是不行的。 　　最简单的，就是起码得支持读写分离功能，因为我们面临的许多问题，一般是面对大量的查询问题。而要做到读写分离功能，就是要把主节点的数据同步到从节点上。从而可以让从节点接受读请求，
Redis 源码解析 - Redis 主从复制
最新发布
qq_33240556的博客
05-06 229
Redis 主从复制是其高可用性和数据冗余的关键特性之一，允许数据从一个主节点（Master）自动复制到一个或多个从节点（Slave）。
redis源码阅读-持久化之RDB
yxkong的专栏
03-16 1177
通过本文希望大家能够了解redis的rdb流程
redis源码阅读笔记-主从复制
qq_35475714的博客
07-08 304
1、从节点B-client 终端发起slaveof 192.168.1.1 6379命令 2、节点B-server对slaveof命令响应操作，对节点B进行初始化设置，清空所有之前可能已主从复制占用的空间。slaveofCommand。 节点B的状态就以下三种情况讨论: 状态1：B节点是个单机节点，未与其他节点建立主从关系 状态2：B节点已建立/正在建立主从关系，B是主节点 状态3：B节点已建立/正在建立主从关系，B是从节点 replicationSetMaster，初始化B-server节点。 设置
redis主从复制解析
对方正在输入。。。
04-16 1040
redis主从复制解析建立主从关系 建立主从关系 redis主从复制的前提是给master节点创建相应的slave，方法有以下几种： 直接修改需要增加的从节点的redis.conf配置，增加slaveof ip port 连接从节点的客户端，执行命令slaveof ip port slave节点启动时直接指定从节点，启动时加参数–slaveof ...
Redis源码分析（十九）--- replication主从数据复制的实现
走在前往架构师的路上
10-25 8121
replication的英文单词的原意是“复制”的意思,replication文件作为我在Data目录下的分析的最后一个文件，足以说明他的重要性，代码量1800+，的确非常难啃。只能说个我看代码下来的大致印象吧，要我画个结构图好好理理这里面各个API的关系图，这个我目前还真做不到。说到主从复制，这个是实现读写分离的最好手段了，也很常见，当用户数达到一定量，当一个服务器承受不了达到上千万的pv时，采
redis源码分析
04-04
Redis支持主从复制，`replication.c`实现了复制功能。主服务器通过` replicationFeedSlaves()`将命令传播给从服务器，而从服务器在`slave.c`中接收并执行这些命令。 九、模块系统 Redis 3.0引入了模块系统，允许...
redis-5.0.14.源码
12-11
6. **复制**：Redis 5.0 引入了流式复制（Stream-based Replication），提高了主从复制的效率和可靠性。`replication.c` 文件中包含了复制相关的代码。 7. **模块系统**：Redis 从 5.0 版本开始引入模块系统，允许...
redis-unstable_Redis数据库源码_
09-30
源码分析有助于深入理解其工作原理，这对于开发者优化应用性能、排查问题或进行二次开发具有重要意义。以下是对Redis数据库源码的一些核心知识点的详细说明： 1. 数据结构： Redis使用多种自定义的数据结构来存储...
redis 学习 基础知识 源码
02-24
**Redis 学习基础知识 源码分析** Redis 是一个高性能的键值对数据库，它以其丰富的数据结构、高效的性能以及广泛的应用场景而备受青睐。本文将深入探讨 Redis 的基础知识，包括其核心概念、数据类型、命令操作以及...
redis-1.2.6:redis-1.2.6源码分析
03-24
另外，Redis支持主从复制，这在`replication.c`中实现。主服务器会将所有写操作发送给从服务器，确保数据的一致性。同时，Redis还提供了一种部分同步机制，允许在断开连接后快速恢复复制。 Redis的内存管理是一个...
从源码角度解析如何生成和解读RDB文件
子冉冰清的博客
01-23 1470
如何生成和解读RDB文件 好，那么今天这篇文章，我们就先从 RDB 文件的生成开始学起。下面呢，我先带你来了解下 RDB 创建的入口函数，以及调用这些函数的地方。 RDB 创建的入口函数和触发时机 Redis 源码中用来创建 RDB 文件的函数有三个，它们都是在rdb.c文件中实现的，接下来我就带你具体了解下。 rdbSave 函数 这是 Redis server 在本地磁盘创建 RDB 文件的入口函数。它对应了 Redis 的 save 命令，会在 save 命令的实现函数 saveCommand（在 r
Redis源码解读（二十一）——命令传播
yh88623131的博客
05-29 674
主从同步—命令传播的实现
Redis单节点、主从、哨兵、去中心化集群部署
weixin_68170314的博客
06-06 1523
redis是一个key-value。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list()、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。
关于Redis详解和相关主要机制
huanggangmijuan的博客
07-22 196
Redis数据库里面的每个键值对都是由对象组成的，其中：1、数据库键总是一个字符串对象2、数据库键的值可以是字符串对象、列表对象、哈希对象、集合对象、有序集合对象这五种中的任意一种Redis服务器将所有数据库都保存在服务器状态redis.h/redisServer结构的db数组中，db数组的每个项都是一个redis.h/redisDb结构，每个redisDb结构代表一个数据库；而数据库的数量则由redisServer.dbnum属性保存。
Redis
java后端攻城狮
08-11 251
网站的用户群的增加，访问量的上升，传统数据库出现性能瓶颈，web程序不饿能专注功能上，同时要追求性能。NOSQL数据库应运而生，具体解决以下三高问题。High Scalabilitv && High Availabilitv 对数据库的高可扩展和高可用的需求。Huge Storagfe 海量数据的高效率存储和访问需求。NOSQL（NotOnly SQL）泛指非关系型数据库。High performance 数据库高并发读写需求。为什么需要NOSQL。.............................
Redis 主从复制--replication 代码分析
andyhuabing的专栏
11-14 3767
源码版本：redis-3.2.3 1、redis的主从复制实现简单却功能强大，其具有以下特点： 1. 一个master支持多个slave连接，slave可以接受其他slave的连接 2. 主从同步时，master和slave都是非阻塞的 2、redis主从复制可以用来： 1. data redundancy  2. slave作为master的扩展，提供一些read-only的
Redis源码解析：16Resis主从复制之主节点的完全重同步流程
weixin_30565199的博客
04-25 191
主从复制过程中，主节点根据从节点发来的命令执行相应的操作。结合上一章中讲解的从节点在主从复制中的流程，本章以及下一篇文章讲解一下主节点在主从复制过程中的流程。 本章主要介绍完全重同步流程。 一：从节点建链和握手 从节点在向主节点发起TCP建链，以及复制握手过程中，主节点一直把从节点当成一个普通的客户端处理。也就是说，不为从节点保存状态，...
redis的主从复制的主从配置
05-01
Redis的主从复制是一种常见的数据制和高可用方案，它通过将一个Redis实例（主节点）的数据复制到其他Redis实例（从节点）来实现数据的备份和读写分离。 主从配置的步骤如下： 1. 配置主节点：在主节点的配置文件(redis.conf)中，设置`slaveof`参数为空，表示该节点为主节点。 2. 配置从节点：在从节点的配置文件(redis.conf)中，设置`slaveof`参数为主节点的IP地址和端口号，例如`slaveof 192.168.0.1 6379`，表示该节点为从节点，并将数据复制自主节点。 3. 启动主节点和从节点：分别启动主节点和从节点的Redis服务。 4. 验证主从复制：可以通过命令`info replication`查看主从节点的复制状态，如果显示`role:master`表示主节点，如果显示`role:slave`表示从节点。 需要注意的是，主从复制是异步的，即主节点的数据变化会异步地复制到从节点。此外，主从复制还支持链式复制，即一个从节点可以作为另一个从节点的主节点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值