首页 / REDIS / Redis Sentinel源码分析（二）

Redis Sentinel源码分析（二）

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Redis Sentinel源码分析（二），小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含11371字，纯文字阅读大概需要17分钟。

内容图文

原文链接：https://my.oschina.net/zipu888/blog/549570
接Redis Sentinel源码分析（一）
sentinelTimer函数周期性运行，第一次在服务启动后1ms执行，后续执行周期1000/server.hz（sentinelTimer函数会修改server.hz的值）
sentinelTimer内部包含sentinel模式需要定期执行的操作，包括check master、slave、sentinel的状态，并根据配置的条件判断是否需要fail over。

void sentinelTimer(void) {
	//check是否需要进入TITL模式
	sentinelCheckTiltCondition(); 
	//执行定期操作（检查redis-server状态，和其他sentinel节点交互等） 
	sentinelHandleDictOfRedisInstances(sentinel.masters); 
	//运行等待执行的脚本 
	sentinelRunPendingScripts(); 
	//清理已执行完毕脚本 
	sentinelCollectTerminatedScripts(); 
	//杀死超时运行的脚本 
	sentinelKillTimedoutScripts(); 
	//修改hz值（影响sentinel相关操作执行频率），引入随机值，尽量避免所有sentinel节点持续性的同一时间发起投票请求 
	server.hz = REDIS_DEFAULT_HZ + rand() % REDIS_DEFAULT_HZ;
}



 sentinelCheckTiltCondition函数会check是否进入TITL模式，所谓TITL模式即只收集数据，而不做fail-over 

 进入TITL模式的原因可能是： 

 1）sentinel的部分操作被阻塞（可能是系统负载导致） 

 2）系统时钟异常 

 进入条件，两次进入sentinelCheckTiltCondition时间差值<0或者>2s 

 进入TITL模式的原因是为了避免错误的进行fail-over 

void sentinelCheckTiltCondition(void) {
    mstime_t now = mstime();
    mstime_t delta = now - sentinel.previous_time;
    //两次执行时间<0或者大于2s，则进入TITL模式
    if (delta < 0 || delta > SENTINEL_TILT_TRIGGER) {
        sentinel.tilt = 1;
        sentinel.tilt_start_time = mstime();
        sentinelEvent(REDIS_WARNING,"+tilt",NULL,"#tilt mode entered");
    }
    sentinel.previous_time = mstime();
}


 sentinelHandleDictOfRedisInstances包含遍历所有instance，执行周期性操作 

void sentinelHandleDictOfRedisInstances(dict *instances) {
    dictIterator *di;
    dictEntry *de;
    sentinelRedisInstance *switch_to_promoted = NULL;
    //遍历获取所有master结点
    di = dictGetIterator(instances);
    while((de = dictNext(di)) != NULL) {
        sentinelRedisInstance *ri = dictGetVal(de);
        //执行结点的周期性操作
        sentinelHandleRedisInstance(ri);
        // 如果被遍历的是master，则遍历和该master关联的所有slave&sentinel
        if (ri->flags & SRI_MASTER) {
            sentinelHandleDictOfRedisInstances(ri->slaves);
            sentinelHandleDictOfRedisInstances(ri->sentinels);
            //如果master的状态为SENTINEL_FAILOVER_STATE_UPDATE_CONFIG，则准备执行failover
            if (ri->failover_state == SENTINEL_FAILOVER_STATE_UPDATE_CONFIG) {
                switch_to_promoted = ri;
            }
        }
    }
    //执行failover
    if (switch_to_promoted)
        sentinelFailoverSwitchToPromotedSlave(switch_to_promoted);
    dictReleaseIterator(di);
}


 sentinelHandleRedisInstance包含了具体的周期性操作，包括针对sentinel、slave、master实例的操作 

void sentinelHandleRedisInstance(sentinelRedisInstance *ri) {
    /* 以下为所有实例都需要执行的操作 */
    //连接及订阅管理
    sentinelReconnectInstance(ri);
    //和instance交流（PING/INFO/PUBLISH）
    sentinelPingInstance(ri);
    //如果仍然处于TILT模式，啥也不干
    if (sentinel.tilt) {
        if (mstime()-sentinel.tilt_start_time < SENTINEL_TILT_PERIOD) return;
        sentinel.tilt = 0;
        sentinelEvent(REDIS_WARNING,"-tilt",NULL,"#tilt mode exited");
    }	
    //判断instance是否下线（sdown）
    sentinelCheckSubjectivelyDown(ri);
    ......
    /* 以下操作只针对master instance*/
    if (ri->flags & SRI_MASTER) {
        //check master是否为odown（满足用户配置的quorum节点数判断master为sdown）
        sentinelCheckObjectivelyDown(ri);
        //check是否需要做fail over，如果确认需要，则调用sentinelStartFailover修改自身状态
        if (sentinelStartFailoverIfNeeded(ri))
            //发送SENTINEL is-master-down-by-addr给其他的sentinel，并注册毁掉函数
            sentinelAskMasterStateToOtherSentinels(ri,SENTINEL_ASK_FORCED);
        //执行故障转移
        sentinelFailoverStateMachine(ri);
        sentinelAskMasterStateToOtherSentinels(ri,SENTINEL_NO_FLAGS);
    }
}


 sentinelReconnectInstance函数负责建立连接、重连，包括和各个instance建立连接，针对master instance，订阅其“__sentinel__:hello”频道 

void sentinelReconnectInstance(sentinelRedisInstance *ri) {
    if (!(ri->flags & SRI_DISCONNECTED)) return;
    //和master/slave/sentinel instance建立连接
    if (ri->cc == NULL) {
       ......
    }
    //针对master/slave，订阅其“__sentinel__:hello”频道
    if ((ri->flags & (SRI_MASTER|SRI_SLAVE)) && ri->pc == NULL) {
       ......
	retval = redisAsyncCommand(ri->pc,
			sentinelReceiveHelloMessages, NULL, "SUBSCRIBE %s",
				SENTINEL_HELLO_CHANNEL); 
        ......
    }
    ......
}


 sentinelPingInstance会根据instance状况，向其发送命令，可能是INFO/PING/PUBLISH 

void sentinelPingInstance(sentinelRedisInstance *ri) {
    //假如instance处于不可连接状态或者过多的命令（100）还没有发送出去，直接返回
    if (ri->flags & SRI_DISCONNECTED) return;
    if (ri->pending_commands >= SENTINEL_MAX_PENDING_COMMANDS) return;
    //对于slave instance，如果其master处于异常状态（SRI_O_DOWN|SRI_FAILOVER_IN_PROGRESS），则向该slave发送info的频率从10s一发提高到1s一发
    if ((ri->flags & SRI_SLAVE) &&
        (ri->master->flags & (SRI_O_DOWN|SRI_FAILOVER_IN_PROGRESS))) {
        info_period = 1000;
    } else {
        info_period = SENTINEL_INFO_PERIOD;
    }
    //对于mastere/slave instance，每隔info_period时间，向其发送info命令，注册info命令的回调函数为sentinelInfoReplyCallback
    //sentinelInfoReplyCallback会根据从master/slave所得到的回复中分析出相关信息，并更新sentinelRedisInstance的当前状态
    if ((ri->flags & SRI_SENTINEL) == 0 &&
        (ri->info_refresh == 0 ||
        (now - ri->info_refresh) > info_period))
    {
        /* Send INFO to masters and slaves, not sentinels. */
        retval = redisAsyncCommand(ri->cc,
            sentinelInfoReplyCallback, NULL, "INFO");
        if (retval != REDIS_OK) return;
        ri->pending_commands++;
    } 
    //对于所有类型的instance，都定时向其发送PING命令（1s）,注册ping命令的回调函数为sentinelPingReplyCallback
    //sentinelPingReplyCallback根据PING命令的返回值判断instance当前状态
	else if ((now - ri->last_pong_time) > SENTINEL_PING_PERIOD) {
        retval = redisAsyncCommand(ri->cc,
            sentinelPingReplyCallback, NULL, "PING");
        if (retval != REDIS_OK) return;
        ri->pending_commands++;
    //每隔2s向master/slave的“__sentinel__:hello”频道发布消息
    //消息内容为：ip,port,runid,current_epoch, master->name,master->ip,master->port
    } else if ((ri->flags & SRI_SENTINEL) == 0 &&
               (now - ri->last_pub_time) > SENTINEL_PUBLISH_PERIOD)
    {
        sentinelSendHello(ri);
    }
}


 sentinelCheckObjectivelyDown函数确认是否将master状态从sdown改为odown 

void sentinelCheckObjectivelyDown(sentinelRedisInstance *master) {
    ......
    //假如本身的状态为sdown，则开始判断是否可以判断为odown
    if (master->flags & SRI_S_DOWN) {
        quorum = 1; 
        di = dictGetIterator(master->sentinels);
        //遍历sentinel字典，查看其是否将master状态职位sdown
        while((de = dictNext(di)) != NULL) {
            sentinelRedisInstance *ri = dictGetVal(de);
            if (ri->flags & SRI_MASTER_DOWN) quorum++;
        }
        dictReleaseIterator(di);
        //假如sentinel flag状态为SRI_MASTER_DOWN的sentinel个数达到用户定义的quorum个数，则将master状态置为odown
        if (quorum >= master->quorum) odown = 1;
    }
	......
}


 sentinelStartFailoverIfNeeded函数heck是否需要做fail over，如果确认需要，则调用sentinelStartFailover修改自身状态 

int sentinelStartFailoverIfNeeded(sentinelRedisInstance *master) {
    //确认master状态为odown
    if (!(master->flags & SRI_O_DOWN)) return 0;
    //确认failover没有在运行
    if (master->flags & SRI_FAILOVER_IN_PROGRESS) return 0;
    //确认在超时时间*2内没有failover在运行
    if (mstime() - master->failover_start_time <
        master->failover_timeout*2) return 0;
    sentinelStartFailover(master);
    return 1;
}


 在确认要进行failover后，调用sentinelStartFailover修改相关状态数据 

void sentinelStartFailover(sentinelRedisInstance *master) {
    redisAssert(master->flags & SRI_MASTER);
    // 设置 failover 状态
    master->failover_state = SENTINEL_FAILOVER_STATE_WAIT_START;
    // 设置master当前状态
    master->flags |= SRI_FAILOVER_IN_PROGRESS;
    // 设置failover_epoch
    master->failover_epoch = ++sentinel.current_epoch;
    // 设置fail over开始时间
    master->failover_start_time = mstime()+rand()%s;
    master->failover_state_change_time = mstime();
}
sentinelAskMasterStateToOtherSentinels是在检测到master状态为sdown后，sentinel向其它sentinel节点发送sentinel is-master-down-by-addr消息
void sentinelAskMasterStateToOtherSentinels(sentinelRedisInstance *master, int flags) {
    //遍历关注该master的sentinel节点
    while((de = dictNext(di)) != NULL) {
        //向其它sentinle发送消息SENTINEL is-master-down-by-addr master_ip master_port current_epoch runid/*
        //如果本身已经开始了failover进程，则向其他sentinel节点发送自己的runid，否则发送*
        //注册回调函数sentinelReceiveIsMasterDownReply接受回复的信息
        string(port,sizeof(port),master->addr->port);
        retval = redisAsyncCommand(ri->cc,
                    sentinelReceiveIsMasterDownReply, NULL,
                    "SENTINEL is-master-down-by-addr %s %s %llu %s",
                    master->addr->ip, port,
                    sentinel.current_epoch,
                    (master->failover_state > SENTINEL_FAILOVER_STATE_NONE) ?
                    server.runid : "*");
        if (retval == REDIS_OK) ri->pending_commands++;
    }
    dictReleaseIterator(di);
}


 其他sentinel节点接受到sentinel is-master-down-by-addr消息，调用sentinelCommand处理 

void sentinelCommand(redisClient *c) {
    ......
    //处理sentinel is-master-down-by-addr消息
    } else if (!strcasecmp(c->argv[1]->ptr,"is-master-down-by-addr")) {
        /* SENTINEL IS-MASTER-DOWN-BY-ADDR <ip> <port> <current-epoch> <runid>*/
        ......
        //根据其它sentinel传送过来的消息
        ri = getSentinelRedisInstanceByAddrAndRunID(sentinel.masters,
            c->argv[2]->ptr,port,NULL);
        /* It exists? Is actually a master? Is subjectively down? It's down.
         * Note: if we are in tilt mode we always reply with "0". */
        if (!sentinel.tilt && ri && (ri->flags & SRI_S_DOWN) &&
                                    (ri->flags & SRI_MASTER))
            isdown = 1;
        //假如发过来的信息中包含请求来源sentinel的runid，则开始进行投票
        if (ri && ri->flags & SRI_MASTER && strcasecmp(c->argv[5]->ptr,"*")) {
            leader = sentinelVoteLeader(ri,(uint64_t)req_epoch,
                                            c->argv[5]->ptr,
                                            &leader_epoch);
        }
        //回复信息，包括isdown，leader，leader_epoch
        addReplyMultiBulkLen(c,3);
        addReply(c, isdown ? shared.cone : shared.czero);
        addReplyBulkCString(c, leader ? leader : "*");
        addReplyLongLong(c, (long long)leader_epoch);
        if (leader) sdsfree(leader);
 }


 sentinelReceiveIsMasterDownReply函数处理发送的给其他sentinel的消息”SENTINEL is-master-down-by-addr“的回复 

void sentinelReceiveIsMasterDownReply(redisAsyncContext *c, void *reply, void *privdata) {
	......
	//根据返回值，判断是否将对应sentinel的状态置为SRI_MASTER_DOWN
	if (r->element[0]->integer == 1) {
		ri->flags |= SRI_MASTER_DOWN;
	} else {
		ri->flags &= ~SRI_MASTER_DOWN;
	}
	//如果sentinel返回了其选举的leader，则更新自己的leader和leader_epoch
	if (strcmp(r->element[1]->str,"*")) {
		sdsfree(ri->leader);
		if (ri->leader_epoch != r->element[2]->integer)
			redisLog(REDIS_WARNING,
				"%s voted for %s %llu", ri->name,
				r->element[1]->str,
				(unsigned long long) r->element[2]->integer);
		ri->leader = sdsnew(r->element[1]->str);
		ri->leader_epoch = r->element[2]->integer;
	}
}


 sentinelFailoverStateMachine函数为故障转移状态机，其负责执行故障转移 

void sentinelFailoverStateMachine(sentinelRedisInstance *ri) {
	//master节点&正处于failover状态则继续
	redisAssert(ri->flags & SRI_MASTER);
	if (!(ri->flags & SRI_FAILOVER_IN_PROGRESS)) return;
	switch(ri->failover_state) {
		//等待故障转移开始，如果自己为leader，置状态为SENTINEL_FAILOVER_STATE_SELECT_SLAVE，开始下一步操作，否则，不变更状态，等待fail-over完成/超时
		case SENTINEL_FAILOVER_STATE_WAIT_START:
			sentinelFailoverWaitStart(ri);
			break;
		//从slave中选择一个master，置状态为SENTINEL_FAILOVER_STATE_SEND_SLAVEOF_NOONE
		case SENTINEL_FAILOVER_STATE_SELECT_SLAVE: sentinelFailoverSelectSlave(ri); break;
		//升级被选中的从服务器为新主服务器，置状态为SENTINEL_FAILOVER_STATE_WAIT_PROMOTION
		case SENTINEL_FAILOVER_STATE_SEND_SLAVEOF_NOONE: sentinelFailoverSendSlaveOfNoOne(ri); break;
		//等待fail over生效，info语句的回调函数sentinelRefreshInstanceInfo会更新当前状态SENTINEL_FAILOVER_STATE_RECONF_SLAVES
		case SENTINEL_FAILOVER_STATE_WAIT_PROMOTION: sentinelFailoverWaitPromotion(ri); break;
		//令其它从服务器同步新主服务器
		case SENTINEL_FAILOVER_STATE_RECONF_SLAVES: sentinelFailoverReconfNextSlave(ri); break; 
	}
}



转载于:https://my.oschina.net/zipu888/blog/549570 


	

                
                
                内容总结
                
                    
                        以上是互联网集市为您收集整理的Redis Sentinel源码分析（二）全部内容，希望文章能够帮你解决Redis Sentinel源码分析（二）所遇到的程序开发问题。
                        如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
                    
                
                内容备注
                
                    
                        版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
                    
                
                内容手机端
                
                    
                    
                        扫描二维码推送至手机访问。
                        本文链接：https://qyyshop.com/info/890367.html
                    
                
                
                
                来源：【匿名】


        


    
    【上一篇】Redis数据库(一)【下一篇】redis可以做什么？

            
                
                    更多 ► 
                    【Redis Sentinel源码分析（二）】教程文章相关的互联网学习教程文章
                
                

Redis5设计与源码分析读后感（二）简单动态字符串SDS【图】
一、引言　　学习之前先了解几个概念：　　SDS定义：简单动态字符串，Redis的基本数据结构之一，用于储存字符串和整型数据。二进制安全：C语言中用"\0"表示字符串结束，如果字符串本身就有这个字符，那么此字符串会被阶段，此时为非二进制安全；若通过某种机制保证读写字符串时不损害其内容，则称为二进制安全。字节对齐：字节按照一定规则在空间上排列。（不按规则排列有些架构CPU进行访问时会引起错误或者影响读取效率）。PS：如...
分布式缓存技术之Redis_Redis集群连接及底层源码分析【代码】
目录
1. Jedis 单点连接
2. Jedis 基于sentinel连接
基本使用
源码分析本次源码分析基于: jedis-3.0.1 
1. Jedis 单点连接
? 当是单点服务时，Java 连接Redis的客户端:Jedis jedis = null;try {jedis = new Jedis("192.168.237.130", 6379);jedis.hset("hashzz", "k1", "v1");} catch (Exception e) {System.out.println(e);e.printStackTrace();} finally {if (null != jedis) {jedis.disconnect();}}
?或者JedisPool pool = null...
redis源码分析之十八Lua脚本【代码】【图】
一、Lua和Redis
这篇其实和Redis本身的源码关系不是太大了，主要是看一下对REDIS的支持。Lua可能好多人都没有听说过，但是如果搞过网游的人，估计都用过，做为一种胶水语言，Lua对C/C++的支持非常友好，这是一般的脚本语言都没有做到的。它很小很轻量，所以非常容易与其它程序集成。在魔兽和仙剑等游戏中都广泛使用。 Lua的缺点也很明显，对开发支持的力度不大，功能也少，功能少，就意味着如果搞复杂或者大的东西需要自己实现轮子...
Redis学习之ziplist压缩列表源码分析【代码】
一.压缩列表ziplist在redis中的应用1.做列表键当一个列表键只包含少量列表项，并且每个列表项要么是小整数，要么是短字符串，那么redis会使用压缩列表作为列表键的底层实现2.哈希键当一个哈希键只包含少量的键值对，并且每个键值对的键和值要么是小整数，要么是短字符串，那么redis会使用压缩列表作为哈希键的底层实现二.压缩列表的定义：压缩列表ziplist是redis为了节约内存而开发的，是由一些了特殊编码的连续内存块组成的顺序数...
redis字符串源码分析sds【代码】【图】
前言
分析的为redis现在的最新版 6.2.3
源码链接：
sds.h: https://github.com/redis/redis/blob/unstable/src/sds.h
sds.c: https://github.com/redis/redis/blob/unstable/src/sds.c
sds结构体的定义
// sds的定义
typedef char *sds;/* Note: sdshdr5 is never used, we just access the flags byte directly.* However is here to document the layout of type 5 SDS strings. */
// 不会被用到
struct __attribute__ ((__pack...
redis源码分析(三)--rdb持久化【代码】
Defines related to the dump file format. To store 32 bits lengths for short* keys requires a lot of space, so we check the most significant 2 bits of* the first byte to interpreter the length:** 00|XXXXXX => if the two MSB are 00 the len is the 6 bits of this byte* 01|XXXXXX XXXXXXXX =>  01, the len is 14 byes, 6 bits + 8 bits of next byte* 10|000000 [32 bit integer] => A full 32 bit len in net by...
Redis源码分析：dict.c和dict.h【图】
哈希表是 redis 的核心结构之一，在 redis 的源码中， dict.c 和 dict.h 就定义了 redis 所使用的哈希结构，在这篇文章中，我们将 简介
哈希表是 redis 的核心结构之一，在 redis 的源码中， dict.c 和 dict.h 就定义了 redis 所使用的哈希结构，在这篇文章中，我们将对 dict.c 和 dict.h 进行注解和分析，籍此加深对 redis 的理解。
因为 dict.c 中使用的 separate chaining 哈希表实现可以在任何一本算法书上找到，因此，在本文中...
Redis源码分析（二十八）---object创建和释放redisObject对象
今天的学习效率比较高，把Rio分析完了，又顺便学习了其中的RedisObject的文件，只要讲的就是RedisObject的一些转换和创建。里面的大多数方法都是非常类似的。列出里面长长的API列表: /* ------------ API --------------------- */robj *createObject(int ty今天的学习效率比较高，把Rio分析完了，又顺便学习了其中的RedisObject的文件，只要讲的就是RedisObject的一些转换和创建。里面的大多数方法都是非常类似的。列出里面长长的...
Redis源码分析（十七）---multi事务操作
redis作为一非关系型数据库，竟然同样拥有与RDBMS的事务操作，不免让我觉得比较惊讶。在redis就专门有文件就是执行事务的相关操作的。也可以让我们领略一下，在Redis的代码中是如何实现事务操作。首先亮出mulic.c下面的一些API。 /* =======================redis作为一非关系型数据库，竟然同样拥有与RDBMS的事务操作，不免让我觉得比较惊讶。在redis就专门有文件就是执行事务的相关操作的。也可以让我们领略一下，在Redis的代码中...
Redis源码分析（十三）---redis-benchmark性能测试
今天讲的这个是用来给redis数据库做性能测试的，说到性能测试，感觉这必然是高大上的操作了，redis性能测试，测的到底是哪方面的性能，如何测试，通过什么指标反映此次测试的性能好坏呢，下面我通过源码给大家做一一解答。 redis做的性能测试时对立面的基本今天讲的这个是用来给redis数据库做性能测试的，说到性能测试，感觉这必然是高大上的操作了，redis性能测试，测的到底是哪方面的性能，如何测试，通过什么指标反映此次测试的...
Redis源码分析（八）---t_hash哈希转换
在上次的zipmap分析完之后，其实关于redis源代码结构体部分的内容其实已经全部结束了，因为下面还有几个和结构体相关的操作类，就页把他们归并到struct包下了。这类的文件有：t_hash.c,z_list,z_set.c,t_string.c,t_zset.c,这些文件的功能其实都差不多，就是在上次的zipmap分析完之后，其实关于redis源代码结构体部分的内容其实已经全部结束了，因为下面还有几个和结构体相关的操作类，就页把他们归并到struct包下了。这类的文件有...
Redis源码分析（六）---ziplist压缩列表
ziplist和之前我解析过的adlist列表名字看上去的很像，但是作用却完全不同。之前的adlist主要针对的是普通的数据链表操作。而今天的ziplist指的是压缩链表，为什么叫压缩链表呢，因为链表中我们一般常用pre，next来指明当前的结点的前一个指针或当前的结点的ziplist和之前我解析过的adlist列表名字看上去的很像，但是作用却完全不同。之前的adlist主要针对的是普通的数据链表操作。而今天的ziplist指的是压缩链表，为什么叫压缩链表...
Redis源码分析（七）---zipmap压缩图
如果有看过之前我分析的ziplist压缩列表的分析的话，理解这个我觉得不是什么特别的难题。ziplist压缩列表和zipmap都采用了动态分配字节的做法表示长度，比如通过固定的字节表示节省了不少的空间。同样带来的问题就是复杂的指针移动，和字符位置移动。但总的如果有看过之前我分析的ziplist压缩列表的分析的话，理解这个我觉得不是什么特别的难题。ziplist压缩列表和zipmap都采用了动态分配字节的做法表示长度，比如通过固定的字节表...
Redis源码分析（五）---sparkline微线图
sparkline这个单词，我第一次看的时候，也不知道这什么意思啊，以前根本没听过啊，但是这真真实实的出现在了redis的代码中了，刚刚开始以为这也是属于普通的队列嘛，就把他分在了struct包里了。好来分析完了，与原本我所想的差太大了。sparkline英文中的意思sparkline这个单词，我第一次看的时候，也不知道这什么意思啊，以前根本没听过啊，但是这真真实实的出现在了redis的代码中了，刚刚开始以为这也是属于普通的队列嘛，就把他分...
redis源码分析(一)内存管理
一，redis内存管理介绍 redis是一个基于内存的key-value的数据库，其内存管理是非常重要的，为了屏蔽不同平台之间的差异，以及统计内存占用量等，redis对内存分配函数进行了一层封装，程序中统一使用zmalloc，zfree一系列函数，其对应的源码在src/zmalloc.h一，redis内存管理介绍
redis是一个基于内存的key-value的数据库，其内存管理是非常重要的，为了屏蔽不同平台之间的差异，以及统计内存占用量等，redis对内存分配函数进行了一...


    

REDIS - 相关标签
redisdesktopmanagerredissonredistredis安装redis安装教程redis版本redis常用命令redis持久化redis的数据类型redis端口

    
        REDIS - 技术教程分类
        
            
                    
                        Redis 教程
                                        
                        Redis 简介
                                        
                        Redis 安装
                                        
                        Redis 配置
                                        
                        Redis 数据类型
                                        
                        Redis 命令
                                        
                        Redis 键(key)
                                        
                        Redis 字符串(String)
                                        
                        Redis 哈希(Hash)
                                        
                        Redis 列表(List)
                                        
                        Redis 集合(Set)
                                        
                        Redis 有序集合(sorted set)
                                        
                        Redis HyperLogLog
                                        
                        Redis 发布订阅
                                        
                        Redis 事务
                                        
                        Redis 脚本
                                        
                        Redis 连接
                                        
                        Redis 服务器
                                        
                        Redis GEO
                                        
                        Redis Stream
                                        
                        Redis 数据备份与恢复
                                        
                        Redis 安全
                                        
                        Redis 性能测试
                                        
                        Redis 客户端连接
                                        
                        Redis 分区
                                    
                    Redis 全部
                
            
        
    



    
        REDIS - 最新教程
    
redis持久化java中对于redis的简单操作NoSQL之Redis---持久化（persistence）...Centos中Docker容器中程序访问宿主机Re...SpringBoot集成Redis缓存mongoDB与redisredis安装后修改三个地方利用redis完成自动补全搜索功能（二）分布式系统--封装Redis分布式锁解决跨进...redis的五种数据类型



    REDIS - 最热教程
    redis中批量删除key的方法redis设置密码，取消密码node.js利用redis数据库缓存数据PHP swoole和redis异步任务实现方法分析Laravel使用Redis共享Session步骤详解mac下卸载干净redis如何通过命令行修改redis的配置使用Port Forwarding连接k8s集群的pod（...Redis入门（七）——Redis发布订阅Redis学习笔记2-常用数据类型