Redis内存管理（freeMemoryIfNeeded）

最新推荐文章于 2024-02-07 20:22:15 发布
最新推荐文章于 2024-02-07 20:22:15 发布
阅读量592 收藏
点赞数
分类专栏： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/maryfei/article/details/88081075
版权

目录

redis对象类型

空转时间计算

volatile-ttl策略

volatile-lru and allkeys-lru 策略

 

Redis占用的内存会被限定在一个固定大小。在32bit系统中，redis占用的memory不超过32GB。因此需要内存管理，将长时间未用的键值对删除（即volatile-lru and allkeys-lru策略（近似lru））；将临近过期的键值对删除（即volatile-ttl策略）。

下面以内存管理函数freeMemoryIfNeeded(void)为例进行学习。在学习该函数中，将碰到的问题记录如下：

redis对象类型

【Redis实现中用到一个基础数据结构：robj。那到底什么是robj呢？它有什么用呢？

从Redis的使用者的角度来看，一个Redis节点包含多个database（非cluster模式下默认是16个，cluster模式下只能是1个），而一个database维护了从key space到object space的映射关系。这个映射关系的key是string类型，而value可以是多种数据类型，比如：string, list, hash等。我们可以看到，key的类型固定是string，而value可能的类型是多个。】【引自http://zhangtielei.com/posts/blog-redis-robj.html  该文章对robj结构介绍的非常清楚 。】

robj结构如下：

typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* lru time (relative to server.lruclock) */
    int refcount;
    void *ptr;
} robj;

键的类型只有string类型，下面就是将一个string类型的thiskey创建为一个keyobj对象。

typedef char *sds;
sds thiskey;
robj *keyobj = createStringObject(bestkey,sdslen(bestkey));

robj *createStringObject(char *ptr, size_t len) {
    return createObject(REDIS_STRING,sdsnewlen(ptr,len));
}

robj *createObject(int type, void *ptr) {
    robj *o = zmalloc(sizeof(*o));
    o->type = type;
    o->encoding = REDIS_ENCODING_RAW;
    o->ptr = ptr;
    o->refcount = 1;

    /* Set the LRU to the current lruclock (minutes resolution). */
    o->lru = server.lruclock;
    return o;

空转时间计算

关于robj结构中lru属性，以及server.lruclock。

lru属性计录了robj最后一次被命令访问的时间。robj被访问时，会进行赋值o.lru = server.lruclock。

lruclock属性保存了服务器的lru时钟，每10秒计算一次。REDIS_LRU_CLOCK_RESOLUTION =10，server.unixtime/REDIS_LRU_CLOCK_RESOLUTION。

estimateObjectIdleTime(robj *o)函数计算robj *o的空转时间，空转时间就是server.lruclock - o.lru，在之后计算空转时间时，还需 * REDIS_LRU_CLOCK_RESOLUTION，即 return (server.lruclock - o->lru) * REDIS_LRU_CLOCK_RESOLUTION;

#define REDIS_LRU_CLOCK_RESOLUTION 10 /* LRU clock resolution in seconds */
void updateLRUClock(void) {    更新服务器LRU时间
    server.lruclock = (server.unixtime/REDIS_LRU_CLOCK_RESOLUTION) &
                                                REDIS_LRU_CLOCK_MAX;
}

server.unixtime = time(NULL);
// time_t time(time_t *timer) timer=NULL时，得到机器日历时间, =时间数值时 用于设置日历时间;

unsigned long estimateObjectIdleTime(robj *o) {
    if (server.lruclock >= o->lru) {
        return (server.lruclock - o->lru) * REDIS_LRU_CLOCK_RESOLUTION;
    } else {
        return ((REDIS_LRU_CLOCK_MAX - o->lru) + server.lruclock) *
                    REDIS_LRU_CLOCK_RESOLUTION;
    }
}

volatile-ttl策略

redisDb结构的expire字典数据库中所有建的过期时间。

expire的键是一个指针，指向键空间中某个键对象。

expire的值是一个long long整数，保存了键所指向的数据库键的过期时间，是一个毫秒精度的UNIX时间戳。（因此在涉及的计算中，可能会*1000，或者除1000）；expire数据库的值越小，意味着expire的键越临近过期。

volatile-ttl策略下，即server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_TTL时，用的就是通过expire的值大小，来计算是否过期删除。

server.maxmemory_samples是一个整数，可以是3或者5等。server.maxmemory_samples代表了一次取多少个样本来进行判断。

 if (bestkey == NULL || thisval < bestval) {

//thisval就是expire数据库的值，值最小的就是最临近过期。
                        bestkey = thiskey;
                        bestval = thisval;

 /* volatile-ttl */
else if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_TTL) {
          for (k = 0; k < server.maxmemory_samples; k++) {
                    sds thiskey;
                    long thisval;

                    de = dictGetRandomKey(dict);//随机化返回一个entry
                    thiskey = dictGetKey(de);
                    thisval = (long) dictGetVal(de);

                    /* Expire sooner (minor expire unix timestamp) is better
                     * candidate for deletion */
                    if (bestkey == NULL || thisval < bestval) {
                        bestkey = thiskey;
                        bestval = thisval;
                    }
                }
            }

volatile-lru and allkeys-lru 策略

  else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
                server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)

与上面不同的是，选出的对象需计算空转时间，thisval = estimateObjectIdleTime(o);  thisval越大，说明这个对象越久没有被访问到，越应该被删除，保存为bestval，同时记录bestkey，方便之后查找键。（这里涉及到redis数据库的设计，值和键都是以对象的形式实现。o = dictGetVal(de);取值是一个对象类型。而expire比较特殊，取值是long型 thisval = (long) dictGetVal(de); 值和键实现的数据库比较灵活，贯穿于redis的实现中）。

else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
                server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
         {
             for (k = 0; k < server.maxmemory_samples; k++) {
                    sds thiskey;
                    long thisval;
                    robj *o;

                    de = dictGetRandomKey(dict);
                    thiskey = dictGetKey(de);
                    /* When policy is volatile-lru we need an additional lookup
                     * to locate the real key, as dict is set to db->expires. */
                    if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
                        de = dictFind(db->dict, thiskey);
                    o = dictGetVal(de);
                    thisval = estimateObjectIdleTime(o);

                    /* Higher idle time is better candidate for deletion */
                    if (bestkey == NULL || thisval > bestval) {
                        bestkey = thiskey;
                        bestval = thisval;
                    }
                }
            }

int freeMemoryIfNeeded(void) {
    size_t mem_used, mem_tofree, mem_freed;
    int slaves = listLength(server.slaves);

    /* Remove the size of slaves output buffers and AOF buffer from the
     * count of used memory. */
    mem_used = zmalloc_used_memory();
    if (slaves) {
        listIter li;
        listNode *ln;

        listRewind(server.slaves,&li);
        while((ln = listNext(&li))) {
            redisClient *slave = listNodeValue(ln);
            unsigned long obuf_bytes = getClientOutputBufferMemoryUsage(slave);
            if (obuf_bytes > mem_used)
                mem_used = 0;
            else
                mem_used -= obuf_bytes;
        }
    }
    if (server.aof_state != REDIS_AOF_OFF) {
        mem_used -= sdslen(server.aof_buf);
        mem_used -= aofRewriteBufferSize();
    }

    /* Check if we are over the memory limit. */
    if (mem_used <= server.maxmemory) return REDIS_OK;

    if (server.maxmemory_policy == REDIS_MAXMEMORY_NO_EVICTION)
        return REDIS_ERR; /* We need to free memory, but policy forbids. */

    /* Compute how much memory we need to free. */
    mem_tofree = mem_used - server.maxmemory;
    mem_freed = 0;
    while (mem_freed < mem_tofree) {
        int j, k, keys_freed = 0;

        for (j = 0; j < server.dbnum; j++) {
            long bestval = 0; /* just to prevent warning */
            sds bestkey = NULL;
            struct dictEntry *de;
            redisDb *db = server.db+j;
            dict *dict;

            if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
                server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM)
            {
                dict = server.db[j].dict;
            } else {
                dict = server.db[j].expires;
            }
            if (dictSize(dict) == 0) continue;

            /* volatile-random and allkeys-random policy */
            if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_RANDOM ||
                server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_RANDOM)
            {
                de = dictGetRandomKey(dict);
                bestkey = dictGetKey(de);
            }

            /* volatile-lru and allkeys-lru policy */
            else if (server.maxmemory_policy == REDIS_MAXMEMORY_ALLKEYS_LRU ||
                server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
            {
                for (k = 0; k < server.maxmemory_samples; k++) {
                    sds thiskey;
                    long thisval;
                    robj *o;

                    de = dictGetRandomKey(dict);
                    thiskey = dictGetKey(de);
                    /* When policy is volatile-lru we need an additional lookup
                     * to locate the real key, as dict is set to db->expires. */
                    if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_LRU)
                        de = dictFind(db->dict, thiskey);
                    o = dictGetVal(de);
                    thisval = estimateObjectIdleTime(o);

                    /* Higher idle time is better candidate for deletion */
                    if (bestkey == NULL || thisval > bestval) {
                        bestkey = thiskey;
                        bestval = thisval;
                    }
                }
            }

            /* volatile-ttl */
            else if (server.maxmemory_policy == REDIS_MAXMEMORY_VOLATILE_TTL) {
                for (k = 0; k < server.maxmemory_samples; k++) {
                    sds thiskey;
                    long thisval;

                    de = dictGetRandomKey(dict);
                    thiskey = dictGetKey(de);
                    thisval = (long) dictGetVal(de);

                    /* Expire sooner (minor expire unix timestamp) is better
                     * candidate for deletion */
                    if (bestkey == NULL || thisval < bestval) {
                        bestkey = thiskey;
                        bestval = thisval;
                    }
                }
            }

            /* Finally remove the selected key. */
            if (bestkey) {
                long long delta;

                robj *keyobj = createStringObject(bestkey,sdslen(bestkey));
                propagateExpire(db,keyobj);
                /* We compute the amount of memory freed by dbDelete() alone.
                 * It is possible that actually the memory needed to propagate
                 * the DEL in AOF and replication link is greater than the one
                 * we are freeing removing the key, but we can't account for
                 * that otherwise we would never exit the loop.
                 *
                 * AOF and Output buffer memory will be freed eventually so
                 * we only care about memory used by the key space. */
                delta = (long long) zmalloc_used_memory();
                dbDelete(db,keyobj);
                delta -= (long long) zmalloc_used_memory();
                mem_freed += delta;
                server.stat_evictedkeys++;
                notifyKeyspaceEvent(REDIS_NOTIFY_EVICTED, "evicted",
                    keyobj, db->id);
                decrRefCount(keyobj);
                keys_freed++;

                /* When the memory to free starts to be big enough, we may
                 * start spending so much time here that is impossible to
                 * deliver data to the slaves fast enough, so we force the
                 * transmission here inside the loop. */
                if (slaves) flushSlavesOutputBuffers();
            }
        }
        if (!keys_freed) return REDIS_ERR; /* nothing to free... */
    }
    return REDIS_OK;
}

本文代码均来自redis2.8.2。

marytime
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis内存分析器rdr
03-25
分析key内存大小
Redis：内存淘汰机制
CRUD工程师
06-30 1万+
参考资料：《Redis的LRU缓存淘汰算法实现》《一文读懂Redis内存淘汰策略》《Redis 的过期策略和内存淘汰机制有什么区别》《Redis内存淘汰策略》写在开头：本文为学习后的总结，可能有不到位的地方，错误的地方，欢迎各位指正。目录一、内存管理二、过期策略 1、定期删除 2、惰性删除三、内存淘汰 1、LRU 2、LFU四、近似LRU Redis通过将热点数据存储到内存中实现了高效的数据读取，但是内存如果使用不当也是会造成一些问题的。
Redis源码解析(11) 内存淘汰策略
李兆龙的博客
04-04 869
文章目录引言对redis内存淘汰策略的看法最大容量究竟是多少?源码解析部分freeMemoryIfNeededevictionPoolPopulatedictGetRandomKeys 引言 内存淘汰策略是在存储数据较多,内存不够用时及其必要的一种释放内存的策略,可以使得在大量数据到来的时候服务器不至于宕机.redis中内置了六种内存淘汰机制,实现的功能都是一样的,通过某种手段找到需要删除的键,然...
深入理解Redis数据缓存的LRU实现机制
azurelaker的博客
12-26 1万+
redis
Redis系列（四）Redis内存管理之过期、淘汰策略
CountryLord的博客
10-23 502
Redis内存管理之过期、淘汰策略
Redis-数据删除策略以及逐出(淘汰)策略
CJCC白朴的博客
06-21 4930
文章目录Redis-删除策略以及逐出(淘汰)策略篇Redis简介删除策略以及逐出策略什么是过期数据？Redis提供的删除策略定时删除惰性删除|被动删除定期删除|主动删除删除策略比对逐出（淘汰）策略介绍逐出（淘汰）算法策略及其相关配置1. 检测带有时效性的数据进行淘汰（**`第i个数据库的expire空间`**）2. 检测全库的数据进行淘汰（**`第i个数据库的dict空间`**）3. 不进行淘汰--**`NO_EVICTION`** Redis-删除策略以及逐出(淘汰)策略篇 Redis简介 Redis 是
查看Redis内存信息的命令
09-08
Redis 是一个开源、高性能的Key-Value数据库，被广泛应用在服务器各种场景中。本文介绍几个查看Redis内存信息的命令，包括常用的info memory、info keyspace、bigkeys等。
RedisDesktopManager Version0.99 内存数据库管理神器
11-29
RedisDesktopManager是一款强大的图形化界面工具，专为管理和操作Redis内存数据库而设计。这款软件的Version0.99版本提供了一种直观且高效的方式，帮助IT专业人士远程监控和管理他们的Redis实例，使得日常维护和性能...
Redis可视化管理工具
最新发布
06-08
监控和指标：该工具允许用户监控 Redis 服务器的关键性能指标，如内存使用情况、每秒执行的命令数、延迟等。通过监控这些指标，用户可以及时发现潜在的性能问题并进行优化。 实时命令和日志：RedisInsight 提供实时...
nagios 监控redis内存情况脚本
04-30
redis自身的info可以读出自身的内存使用情况，通过config get可读出你所设置的内存最大值。故可通过这两点，对redis内存使用情况进行监控。以下脚本考虑了四种输出可能：正常，警告，严重警告
redis学习笔记（三）redis数据淘汰策略
刘本龙的专栏
12-16 1万+
本文讲的是 当redis设定了最大内存之后，缓存中的数据集大小超过了一定比例，实施的淘汰策略，不是删除过期键的策略，虽然两者非常相似。   redis系列文章目录 Redis 利用Hash存储节约内存 使用spring-data-redis实现incr自增 Redis学习笔记（九）redis实现时时直播列表缓存,支持分页[热点数据存储] Redis学习笔记（八）redis之lua脚...
Redis底层详解（八） LRU 算法
热门推荐
英雄哪里出来
02-11 24万+
一、LRU 算法概述 1、LRU 概述 LRU 是Least Recently Used 的缩写，即最近最少使用，是内存管理的一种页面置换算法。算法的核心是：如果一个数据在最近一段时间内没有被访问到，那么它在将来被访问的可能性也很小。换言之，当内存达到极限时，应该把内存中最久没有被访问的数据淘汰掉。 那么，如何表示这个最久呢？Redi...
Redis 之内存淘汰源码分析
TanXi的博客
08-07 277
一、前述 在上一篇文章中，介绍了一下 Redis LRU 内存淘汰、LFU 内存淘汰以及两种算法的区别：Redis 之 LRU 与 LFU 可以知道，LRU我们可以配置六种策略，LFU 同样可以配置，那么今天就来看看源码， Redis 是怎样的一个逻辑来进行内存淘汰的 二、 源码概览 int freeMemoryIfNeeded(void) { (1) i...
Redis中内存淘汰算法实现
谢谢大家的关注
02-07 1444
Redis的maxmemory支持的内存淘汰机制使得其成为一种有效的缓存方案，成为memcached的有效替代方案。当内存达到maxmemory后，Redis会按照启动淘汰策略。其中LRU(less recently used)经典淘汰算法在Redis实现中有一定优化设计，来保证内存占用与实际效果的平衡，这也体现了工程应用是空间与时间的平衡性。PS：值得注意的，在主从复制模式Replication下，从节点达到maxmemory时不会有任何异常日志信息，但现象为增量数据无法同步至从节点。
Redis系列（四）--内存淘汰机制（含单机版内存优化建议）
Jack__Frost的博客
05-22 8041
每台redis的服务器的内存都是有限的，而且也不是所有的内存都用来存储信息。而且redis的实现并没有在内存这块做太多的优化，所以实现者为了防止内存过于饱和，采取了一些措施来管控内存。 这其中就涉及内存淘汰机制，内存使用正确姿势，内存优化的注意点。
redis 设置不过期_面试时 Redis 内存淘汰总被问，但是总答不好，怎么解决？
weixin_39954682的博客
11-26 145
什么是内存淘汰内存淘汰，和平时我们设置redis key的过期时间，不是一回事；内存淘汰是说，假设我们限定redis只能使用8g内存，现在已经使用了这么多了(包括设置了过期时间的key和没设过期时间的key)，那，后续的set操作，还怎么办呢？是不是只能报错了？那不行啊，不科学吧，因为有的key，可能已经很久没人用了，可能以后也不会再用到了，那我们是不是可以把这类key给干掉呢？干掉key的过程，...
Redis之内存管理机制
猎户星座
02-20 733
简介 Redis是一个基于内存的键值对的数据库，其内存管理是非常重要的。下面从Redis的内存消耗、内存管理、内存优化三个角度对Redis的内存机制进行剖析和学习。 内存消耗 内存查看 127.0.0.1:6379> info memory 通过Redis客户端命令info memory查看内存情况 参数 含义 used_memory Redis内部存储所用的内存使用量 used_memory_human 以可读形式返回 used_memory used_mem
redis源码分析之内存淘汰策略的原理分析
永远积极向上、永远热泪盈眶、永远豪情满怀、永远坦坦荡荡
10-08 680
前言 在MySQL和redis配合使用时怎么保存redis中是热点数据的，比如:MySQL的中的有100万条数据redis中有10万条数据是热点数据呢，这个就需要配置redis的使用什么方式淘汰不是热点的数据 概论介绍: LRU:即最近最久未使用算法 LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面...
redis 内存管理源码
05-11
Redis的内存管理主要涉及以下几个模块： 1. 内存分配器：Redis使用了自己实现的内存分配器，其实现在 `src/memalloc.c` 文件中。 2. 内存回收器：Redis使用了两种内存回收机制，分别是惰性删除和定期删除。惰性删除是指当 Redis 对某个键进行操作时，如果发现该键已经过期，就将其删除；而定期删除是指 Redis 会周期性地从过期键中随机抽取一部分进行删除。其实现在 `src/expire.c` 文件中。 3. 内存压缩器：Redis的内存压缩器是一种将 Redis 内存中的数据进行整理以释放内存碎片的机制。其实现在 `src/redis.c` 文件中。 以下是 Redis 内存分配器的源码实现示例： ```c /* 内存分配器 */ void *zmalloc(size_t size) { void *ptr = malloc(size); if (!ptr) zmalloc_oom_handler(size); return ptr; } void *zcalloc(size_t size) { void *ptr = calloc(1, size); if (!ptr) zmalloc_oom_handler(size); return ptr; } void *zrealloc(void *ptr, size_t size) { void *newptr; if (ptr == NULL) return zmalloc(size); if (size == 0) { zfree(ptr); return NULL; } newptr = realloc(ptr,size); if (!newptr) zmalloc_oom_handler(size); return newptr; } void zfree(void *ptr) { if (ptr == NULL) return; free(ptr); } /* 内存分配失败处理函数 */ void zmalloc_oom_handler(size_t size) { oom("zmalloc: unable to allocate %zu bytes", size); } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值