引言

Redis是一个高性能的内存数据库，它可以存储不同类型的数据结构，如字符串、哈希、列表、集合和有序集合。但是，Redis的内存模型并不是简单地将数据放入内存中，而是涉及到一些复杂的细节，如内存分配器、对象编码、内存碎片等。本文将介绍Redis的内存模型的基本原理和应用，帮助读者更好地理解和使用Redis。

Redis内存统计

要了解Redis占用了多少内存，可以使用info memory命令，它会返回一些关于内存使用情况的参数，如下所示：

# Memory
used_memory:1048576
used_memory_human:1.00M
used_memory_rss:2097152
used_memory_rss_human:2.00M
used_memory_peak:1048576
used_memory_peak_human:1.00M
used_memory_peak_perc:100.00%
used_memory_overhead:0
used_memory_startup:0
used_memory_dataset:1048576
used_memory_dataset_perc:100.00%
allocator_allocated:1048576
allocator_active:2097152
allocator_resident:2097152
total_system_memory:8589934592
total_system_memory_human:8.00G
used_memory_lua:37888
used_memory_lua_human:37.00K
used_memory_scripts:0
used_memory_scripts_human:0B
number_of_cached_scripts:0
maxmemory:0
maxmemory_human:0B
maxmemory_policy:noeviction
allocator_frag_ratio:2.00
allocator_frag_bytes:1048576
allocator_rss_ratio:1.00
allocator_rss_bytes:0
rss_overhead_ratio:1.00
rss_overhead_bytes:0
mem_fragmentation_ratio:2.00
mem_fragmentation_bytes:1048576
mem_not_counted_for_evict:0
mem_replication_backlog:0
mem_clients_slaves:0
mem_clients_normal:49694
mem_aof_buffer:0
mem_allocator:jemalloc-5.1.0
active_defrag_running:0
lazyfree_pending_objects:0

其中，比较重要的几个参数的含义如下：

• used_memory：Redis分配器分配的内存总量（单位是字节），包括使用的虚拟内存（即swap）。Redis分配器可以是libc、jemalloc或者tcmalloc，默认是jemalloc。
• used_memory_rss：Redis进程占据操作系统的内存（单位是字节），与top及ps命令看到的值是一致的。除了分配器分配的内存之外，还包括进程运行本身需要的内存、内存碎片等，但是不包括虚拟内存。
• mem_fragmentation_ratio：内存碎片比率，该值是used_memory_rss / used_memory的比值。该值一般大于1，且越大表示内存碎片比例越大。如果该值小于1，说明Redis使用了虚拟内存，这会降低Redis的性能，应该及时排查原因并处理。
• mem_allocator：Redis使用的内存分配器，在编译时指定。jemalloc在控制内存碎片方面做得比较好。

Redis内存划分

Redis作为一个内存数据库，在内存中存储的内容主要是数据（键值对）。但是，除了数据以外，Redis还有其他部分也会占用内存。Redis的内存占用主要可以划分为以下几个部分：

• 数据：作为数据库，数据是最主要的部分。这部分占用的内存会统计在used_memory中。Redis使用键值对存储数据，其中的值（对象）包括5种类型，即字符串、哈希、列表、集合和有序集合。这5种类型是Redis对外提供的，实际上，在Redis内部，每种类型可能有2种或更多的内部编码实现。此外，Redis在存储对象时，并不是直接将数据放入内存，而是会对对象进行各种包装：如redisObject、SDS等。这些细节将在后面介绍。
• 进程本身运行需要的内存：Redis主进程本身运行肯定需要占用内存，如代码、常量池等等。这部分内存大约几兆，在大多数生产环境中与Redis数据占用的内存相比可以忽略。这部分内存不是由jemalloc分配，因此不会统计在used_memory中。除了主进程外，Redis创建的子进程运行也会占用内存，如Redis执行AOF、RDB重写时创建的子进程。当然，这部分内存不属于Redis进程，也不会统计在used_memory和used_memory_rss中。
• 缓冲内存：缓冲内存包括客户端缓冲区、复制积压缓冲区、AOF缓冲区等。其中，客户端缓冲区存储客户端连接的输入输出缓冲；复制积压缓冲区用于部分复制功能；AOF缓冲区用于在进行AOF重写时，保存最近的写入命令。这部分内存由jemalloc分配，因此会统计在used_memory中。
• 内存碎片：内存碎片是Redis在分配、回收物理内存过程中产生的。例如，如果对数据的更改频繁，而且数据之间的大小相差很大，可能导致Redis释放的空间在物理内存中并没有释放，但Redis又无法有效利用，这就形成了内存碎片。内存碎片不会统计在used_memory中。内存碎片的产生与对数据进行的操作、数据的特点等都有关；此外，与使用的内存分配器也有关系：如果内存分配器设计合理，可以尽可能的减少内存碎片的产生。jemalloc便在控制内存碎片方面做得很好。如果Redis服务器中的内存碎片已经很大，可以通过安全重启的方式减小内存碎片：因为重启之后，Redis重新从备份文件中读取数据，在内存中进行重排，为每个数据重新选择合适的内存单元，减小内存碎片。

Redis数据结构及编码

redisObject

redisObject是Redis中最基本的对象类型，它是一个结构体，定义如下：

typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
                            * LFU data (least significant 8 bits frequency
                            * and most significant 16 bits access time). */
    int refcount;
    void *ptr;
} robj;

其中：

• type字段表示对象的类型，可以是字符串（REDIS_STRING）、哈希（REDIS_HASH）、列表（REDIS_LIST）、集合（REDIS_SET）或有序集合（REDIS_ZSET）。
• encoding字段表示对象的编码方式，即对象在底层实际使用什么样的数据结构来保存数据。例如，字符串对象可以使用简单动态字符串（SDS）或整数来编码；列表对象可以使用链表或压缩列表来编码；哈希对象可以使用字典或压缩列表来编码；集合对象可以使用字典或整数集合来编码；有序集合对象可以使用跳跃表或压缩列表来编码。
• lru字段表示对象最近一次被访问的时间戳（相对于全局LRU时钟），用于实现LRU算法；或者表示对象的访问频率和最近一次被访问的时间戳（最低8位为频率，最高16位为时间），用于实现LFU算法。这两种算法都是Redis用于淘汰内存中的对象的方法，它们各有优劣，具体如下：
  • LRU算法是最近最少使用算法，它根据对象的最近访问时间来决定对象的淘汰顺序，即越久没有被访问的对象越容易被淘汰。这种算法可以保证热点数据（经常被访问的数据）不会被淘汰，但是也可能导致冷数据（不经常被访问的数据）被过早地淘汰，从而降低缓存命中率。
  • LFU算法是最不经常使用算法，它根据对象的访问频率和最近访问时间来决定对象的淘汰顺序，即访问频率越低且最近访问时间越早的对象越容易被淘汰。这种算法可以保证热点数据和冷数据都有一定的保留机会，但是也可能导致一些突发流量（短时间内被大量访问的数据）占用过多的内存，从而影响内存利用率。

struct sdshdr {
    int len;
    int free;
    char buf[];
};

typedef struct listNode {
    struct listNode *prev;
    struct listNode *next;
    void *value;
} listNode;

typedef struct list {
    listNode *head;
    listNode *tail;
    void *(*dup)(void *ptr);
    void (*free)(void *ptr);
    int (*match)(void *ptr, void *key);
    unsigned long len;
} list;

typedef struct ziplist {
    uint32_t zlbytes; /* Total number of bytes in the ziplist */
    uint32_t zltail; /* Offset of the last entry */
    uint16_t zllen; /* Number of entries */
    unsigned char *zlend; /* End of ziplist marker */
    unsigned char *zldata; /* Pointer to the first entry */
} ziplist;

typedef struct dict {
    dictType *type;
    void *privdata;
    dictht ht[2];
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
    unsigned long iterators; /* number of iterators currently running */
} dict;

typedef struct dictht {
    dictEntry **table;
    unsigned long size;
    unsigned long sizemask;
    unsigned long used;
} dictht;

typedef struct dictEntry {
    void *key;
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;
    struct dictEntry *next;
} dictEntry;

typedef struct intset {
    uint32_t encoding; /* The encoding used for the elements */
    uint32_t length; /* The number of elements in the intset */
    int8_t contents[]; /* The actual elements, in sorted order */
} intset;

typedef struct zskiplistNode {
    struct zskiplistLevel {
        struct zskiplistNode *forward; /* Pointer to the next node */
        unsigned int span; /* The number of nodes between the current node and the next node */
    } level[]; /* The level array, variable length */
    struct zskiplistNode *backward; /* Pointer to the previous node */
    double score; /* The score of the element, used for sorting */
    robj *obj; /* The element object */
} zskiplistNode;

typedef struct zskiplist {
    struct zskiplistNode *header; /* The header node of the skiplist */
    struct zskiplistNode *tail; /* The tail node of the skiplist */
    unsigned long length; /* The number of elements in the skiplist */
    int level; /* The current level of the skiplist */
} zskiplist;