redis数据结构(一)-前言

时间  2020-01-05
标签 redis 数据 结构 前言 栏目 Redis 繁體版
原文   原文链接
 基于redis5.0的版本。

前言

  • 假设咱们如今须要本身写个缓存，常见的就是用HashMap<String, String>存储。
  • 若是为了方便统计、回收、或者其余缘由，要记录下缓存的最近访问时间、建立时间等等，须要将值包装成ValueObject，里面包含了额外的扩展信息。
  • 若是缓存值不止是字符串，也多是List、Set等等，须要个标识字段来标识数据类型。 

  • 若是要给缓存加上过时时间：html

    1. 方式一：在ValueObject上加上过时时间字段。

    2. 方式二：再建一个对应的过时时间Map，Map的值为过时时间。redis

      • 优势：检查过时缓存时，能够更快的遍历全部的内容；由于Map里不会存在没有设置过时时间的内容，且因为值只有一个字段，能够更快的完成遍历。
      • 缺点：占用更多的空间，可是可让两个Map共用key来节省部分空间。

RedisServer

在redis系统内部，有一个redisServer结构体的全局变量server，server保存了redis服务端全部的信息，包括当前进程的PID、服务器的端口号、数据库个数、统计信息等等。固然，它也包含了数据库信息，包括数据库的个数、以及一个redisDb数组。每个redisDb互相独立，互不干扰。算法

struct redisServer {
    ……
    redisDb *db; 
    int dbnum; // Total number of configured DBs 
    ……
}

/* Redis database representation. There are multiple databases identified
 * by integers from 0 (the default database) up to the max configured
 * database. The database number is the 'id' field in the structure. */
typedef struct redisDb {
    dict *dict; /* The keyspace for this DB */
    dict *expires; /* Timeout of keys with a timeout set */
    dict *blocking_keys; /* Keys with clients waiting for data (BLPOP)*/
    dict *ready_keys; /* Blocked keys that received a PUSH */
    dict *watched_keys; /* WATCHED keys for MULTI/EXEC CAS */
    int id; /* Database ID */
    long long avg_ttl; /* Average TTL, just for stats */
    list *defrag_later; /* List of key names to attempt to defrag one by one, gradually. */
} redisDb;

SDS

redis并无直接使用c语言传统的字符串，而是本身构建了SDS（simple dynamic string）。为何不直接使用c语言的字符串？数据库

  1. c语言字符串并不记录自身的长度，若是要获取字符串长度，须要遍历整个字符串。
  2. 每次增加/缩短字符串时，都须要对字符串数组进行一次内存操做（申请/释放内存），而光是执行内存重分配的时间，就会占去修改字符串所用时间中的一大部分，对性能形成影响。
  3. c语言字符串以‘\0’字符结尾，若是存储的数据字节自己包含‘\0’，就会对结果形成影响。
// sds.h
// 五种header类型，flags取值为0~4
define SDS_TYPE_5 0
define SDS_TYPE_8 1
define SDS_TYPE_16 2
define SDS_TYPE_32 3
define SDS_TYPE_64 4
    
/* 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__ ((__packed__)) sdshdr5 {
    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len; /* buf数组已使用的长度，不包含最后的结束符'\0' */
    uint8_t alloc; /* buf数组最大容量，不包含最后的结束符'\0' */
    unsigned char flags; /* 老是占用一个字节，其中的最低3个bit用来表示header的类型。 */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr16 {
    uint16_t len; /* used */
    uint16_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr32 {
    uint32_t len; /* used */
    uint32_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};
struct __attribute__ ((__packed__)) sdshdr64 {
    uint64_t len; /* used */
    uint64_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};

一个sds字符串的完整结构，由在内存地址上先后相邻的两部分组成：数组

  1. 一个header。一般包含字符串的长度(len)、最大容量(alloc)和flags。sdshdr5有所不一样。
  2. 一个字符数组。这个字符数组的长度等于最大容量+1。真正有效的字符串数据，其长度一般小于最大容量。在真正的字符串数据以后，是空余未用的字节（通常以字节0填充），容许在不从新分配内存的前提下让字符串数据向后作有限的扩展。在真正的字符串数据以后，还有一个NULL结束符，即ASCII码为0的'\0'字符。这是为了和传统C字符串兼容。之因此字符数组的长度比最大容量多1个字节，就是为了在字符串长度达到最大容量时仍然有1个字节存放NULL结束。
    63484167.png

上图是sds的一个内部结构的例子。图中展现了两个sds字符串s1和s2的内存结构，一个使用sdshdr8类型的header，另外一个使用sdshdr16类型的header。但它们都表达了一样的一个长度为6的字符串的值："tielei"。
sds的字符指针（s1和s2）就是指向真正的数据（字符数组）开始的位置，而header位于内存地址较低的方向。在sds.h中有一些跟解析header有关的宏定义。缓存

// sds.h
define SDS_TYPE_MASK 7
define SDS_TYPE_BITS 3
define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (void*)((s)-(sizeof(struct sdshdr##T)));
define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)

sds sdsnewlen(const void *init, size_t initlen) {
    void *sh;
    sds s;
    char type = sdsReqType(initlen);
    /* Empty strings are usually created in order to append. Use type 8
     * since type 5 is not good at this. */
    if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
    int hdrlen = sdsHdrSize(type);
    unsigned char *fp; /* flags pointer. */

    sh = s_malloc(hdrlen+initlen+1); // 额外的一个结束符字节
    if (init==SDS_NOINIT)
        init = NULL;
    else if (!init)
        memset(sh, 0, hdrlen+initlen+1);
    if (sh == NULL) return NULL;
    s = (char*)sh+hdrlen;
    fp = ((unsigned char*)s)-1;
    switch(type) {
        case SDS_TYPE_5: {
            *fp = type | (initlen << SDS_TYPE_BITS);
            break;
        }
        case SDS_TYPE_8: {
            SDS_HDR_VAR(8,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
        case SDS_TYPE_16: {
            SDS_HDR_VAR(16,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
        case SDS_TYPE_32: {
            SDS_HDR_VAR(32,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
        case SDS_TYPE_64: {
            SDS_HDR_VAR(64,s);
            sh->len = initlen;
            sh->alloc = initlen;
            *fp = type;
            break;
        }
    }
    if (initlen && init)
        memcpy(s, init, initlen);
    s[initlen] = '\0';
    return s;
}    

/* Create an empty (zero length) sds string. Even in this case the string
 * always has an implicit null term. */
sds sdsempty(void) {
    return sdsnewlen("",0);
}

/* Create a new sds string starting from a null terminated C string. */
sds sdsnew(const char *init) {
    size_t initlen = (init == NULL) ? 0 : strlen(init);
    return sdsnewlen(init, initlen);
}

/* Duplicate an sds string. */
sds sdsdup(const sds s) {
    return sdsnewlen(s, sdslen(s));
}

static inline size_t sdslen(const sds s) {
    unsigned char flags = s[-1];
    switch(flags&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            return SDS_TYPE_5_LEN(flags);
        case SDS_TYPE_8:
            return SDS_HDR(8,s)->len;
        case SDS_TYPE_16:
            return SDS_HDR(16,s)->len;
        case SDS_TYPE_32:
            return SDS_HDR(32,s)->len;
        case SDS_TYPE_64:
            return SDS_HDR(64,s)->len;
    }
    return 0;
}

/* Free an sds string. No operation is performed if 's' is NULL. */
void sdsfree(sds s) {
    if (s == NULL) return;
    s_free((char*)s-sdsHdrSize(s[-1]));
}

// sds.c
static inline int sdsHdrSize(char type) {
    switch(type&SDS_TYPE_MASK) {
        case SDS_TYPE_5:
            return sizeof(struct sdshdr5);
        case SDS_TYPE_8:
            return sizeof(struct sdshdr8);
        case SDS_TYPE_16:
            return sizeof(struct sdshdr16);
        case SDS_TYPE_32:
            return sizeof(struct sdshdr32);
        case SDS_TYPE_64:
            return sizeof(struct sdshdr64);
    }
    return 0;
}

static inline char sdsReqType(size_t string_size) {
    if (string_size < 1<<5) // 32
        return SDS_TYPE_5;
    if (string_size < 1<<8) // 256
        return SDS_TYPE_8;
    if (string_size < 1<<16) // 64K
        return SDS_TYPE_16;
#if (LONG_MAX == LLONG_MAX)
    if (string_size < 1ll<<32) // 4GB
        return SDS_TYPE_32;
    return SDS_TYPE_64;
#else
    return SDS_TYPE_32;
#endif

其中SDS_HDR用来从sds字符串得到header起始位置的指针，好比SDS_HDR(8, s1)表示s1的header指针，SDS_HDR(16, s2)表示s2的header指针。服务器

sdsnewlen建立一个长度为initlen的sds字符串，并使用init指向的字符数组（任意二进制数据）来初始化数据。若是init为NULL，那么使用全0来初始化数据。它的实现中，咱们须要注意的是：数据结构

  • 若是要建立一个长度为0的空字符串，那么不使用SDS_TYPE_5类型的header，而是转而使用SDS_TYPE_8类型的header。这是由于建立的空字符串通常接下来的操做极可能是追加数据，但SDS_TYPE_5类型的sds字符串不适合追加数据（会引起内存从新分配）。
  • 须要的内存空间一次性进行分配，其中包含三部分：header、数据、最后的多余字节（hdrlen+initlen+1）。
  • 初始化的sds字符串数据最后会追加一个NULL结束符（s[initlen] = ‘\0’）。  

固然，使用SDS_HDR以前咱们必须先知道究竟是哪种header，这样咱们才知道SDS_HDR第1个参数应该传什么。由sds字符指针得到header类型的方法是，先向低地址方向偏移1个字节的位置，获得flags字段。好比，s1[-1]和s2[-1]分别得到了s1和s2的flags的值。而后取flags的最低3个bit获得header的类型。app

  • 因为s1[-1] == 0x01 == SDS_TYPE_8，所以s1的header类型是sdshdr8。
  • 因为s2[-1] == 0x02 == SDS_TYPE_16，所以s2的header类型是sdshdr16。   

有了header指针，就能很快定位到它的len和alloc字段：ide

  • s1的header中，len的值为0x06，表示字符串数据长度为6；alloc的值为0x80，表示字符数组最大容量为128。
  • s2的header中，len的值为0x0006，表示字符串数据长度为6；alloc的值为0x03E8，表示字符数组最大容量为1000。（注意：图中是按小端地址构成）    

在各个header的类型定义中，还有几个须要咱们注意的地方：

  • 在各个header的定义中使用了__attribute__ ((packed))，是为了让编译器以紧凑模式来分配内存（按实际占用字节数进行对齐）。若是没有这个属性，编译器可能会为struct的字段作优化对齐，在其中填充空字节。那样的话，就不能保证header和sds的数据部分牢牢先后相邻，也不能按照固定向低地址方向偏移1个字节的方式来获取flags字段了。
  • 在各个header的定义中最后有一个char buf[]。咱们注意到这是一个没有指明长度的字符数组，这是C语言中定义字符数组的一种特殊写法，称为柔性数组（flexible array member），只能定义在一个结构体的最后一个字段上。它在这里只是起到一个标记的做用，表示在flags字段后面就是一个字符数组，或者说，它指明了紧跟在flags字段后面的这个字符数组在结构体中的偏移位置。而程序在为header分配的内存的时候，它并不占用内存空间。若是计算sizeof(struct sdshdr16)的值，那么结果是5个字节，其中没有buf字段。
  • sdshdr5与其它几个header结构不一样，它不包含alloc字段，而长度使用flags的高5位来存储。所以，它不能为字符串分配空余空间。若是字符串须要动态增加，那么它就必然要从新分配内存才行。因此说，这种类型的sds字符串更适合存储静态的短字符串（长度小于32）。    

至此，咱们很是清楚地看到了：sds字符串的header，其实隐藏在真正的字符串数据的前面（低地址方向/小端）。这样的一个定义，有以下几个好处：

  • header和数据相邻，而不用分红两块内存空间来单独分配。这有利于减小内存碎片，提升存储效率（memory efficiency）。
  • 虽然header有多个类型，但sds能够用统一的char *来表达。且它与传统的C语言字符串保持类型兼容。若是一个sds里面存储的是可打印字符串，那么咱们能够直接把它传给C函数，好比使用strcmp比较字符串大小，或者使用printf进行打印。

sds相对c语言字符串的优势：

  1. SDS能够经过len快速得到字符串长度，便于统计。
  2. SDS能够经过len判断字符串是否结束，虽然数据库通常用于保存稳步数据，但保存二进制的常见也很多见，若是二进制数据中也存在'\0'字符，用c语言字符串就会出现异常问题（只能取到第一个'\0'以前的字符）。
  3. SDS会兼容部分c语言函数，因此同样遵循以'\0'字符结尾对惯例，为了让SDS可用重用部分<string.h>库定义对函数。

  4. 当SDS API须要对SDS进行修改时，API会先检查SDS的空间是否知足修改所需的要求，若是不知足，API会自动将SDS的空间扩展至执行所需的大小，而后才执行实际的修改：

    • 若是对SDS进行修改以后，SDS的长度（len属性值）小于1MB，那么程序会分配和len属性一样大小的未使用空间。这时候SDS的len属性将和free属性同样，buf数组实际的长度将是len+free+1字节。
    • 若是对SDS进行修改以后，SDS的长度大于等于1MB，那么程序会分配1MB的未使用空间。
    • 惰性空间释放：当SDS的API须要缩短SDS保存的字符串时，程序并不当即回收缩短后多出来的字节，避免了缩短字符串时所需的内存从新分配操做，并为未来可能有的增加操做提供了优化。与此同时，SDS也提供了相应的API，让咱们能够在有须要的时候，真正的释放空闲的内存，因此不用担忧惰性空间释放会形成内存浪费。
// sds.h
define SDS_MAX_PREALLOC (1024*1024)

// sds.c
/* Enlarge the free space at the end of the sds string so that the caller
 * is sure that after calling this function can overwrite up to addlen
 * bytes after the end of the string, plus one more byte for nul term.
 *
 * Note: this does not change the *length* of the sds string as returned
 * by sdslen(), but only the free buffer space we have. */
sds sdsMakeRoomFor(sds s, size_t addlen) {
    void *sh, *newsh;
    size_t avail = sdsavail(s);
    size_t len, newlen;
    char type, oldtype = s[-1] & SDS_TYPE_MASK;
    int hdrlen;

    /* Return ASAP if there is enough space left. */
    if (avail >= addlen) return s;

    len = sdslen(s);
    sh = (char*)s-sdsHdrSize(oldtype);
    newlen = (len+addlen);
    if (newlen < SDS_MAX_PREALLOC) /* 小于1M */
        newlen *= 2;
    else
        newlen += SDS_MAX_PREALLOC;

    type = sdsReqType(newlen);

    /* Don't use type 5: the user is appending to the string and type 5 is
     * not able to remember empty space, so sdsMakeRoomFor() must be called
     * at every appending operation. */
    if (type == SDS_TYPE_5) type = SDS_TYPE_8;

    hdrlen = sdsHdrSize(type);
    if (oldtype==type) {
        newsh = s_realloc(sh, hdrlen+newlen+1);
        if (newsh == NULL) return NULL;
        s = (char*)newsh+hdrlen;
    } else {
        /* Since the header size changes, need to move the string forward,
         * and can't use realloc */
        newsh = s_malloc(hdrlen+newlen+1);
        if (newsh == NULL) return NULL;
        memcpy((char*)newsh+hdrlen, s, len+1);
        s_free(sh);
        s = (char*)newsh+hdrlen;
        s[-1] = type;
        sdssetlen(s, len);
    }
    sdssetalloc(s, newlen);
    return s;
}

sdsMakeRoomFor是sds实现中很重要的一个函数。关于它的实现代码，咱们须要注意的是：

  • 若是原来字符串中的空余空间够用（avail >= addlen），那么它什么也不作，直接返回。
  • 若是须要分配空间，它会比实际请求的要多分配一些，以防备接下来继续追加。它在字符串已经比较长的状况下至多分配SDS_MAX_PREALLOC个字节，这个常量在sds.h中定义为(1024*1024)=1MB。
  • 按分配后的空间大小，可能须要更换header类型（原来header的alloc字段过短，表达不了增长后的容量）。
  • 若是须要更换header，那么整个字符串空间（包括header）都须要从新分配（s_malloc），并拷贝原来的数据到新的位置。
  • 若是不须要更换header（原来的header够用），那么调用一个比较特殊的s_realloc，试图在原来的地址上从新分配空间。s_realloc的具体实现得看Redis编译的时候选用了哪一个allocator（在Linux上默认使用jemalloc）。但无论是哪一个realloc的实现，它所表达的含义基本是相同的：它尽可能在原来分配好的地址位置从新分配，若是原来的地址位置有足够的空余空间完成从新分配，那么它返回的新地址与传入的旧地址相同；不然，它分配新的地址块，并进行数据搬迁。

RedisObject

一个database内的这个映射关系是用一个dict来维护的。dict的key固定用一种数据结构来表达就够了，这就是动态字符串sds。而value则比较复杂，为了在同一个dict内可以存储不一样类型的value，这就须要一个通用的数据结构，这个通用的数据结构就是redisObject。

// server.h
// type
#define OBJ_STRING 0 /* String object. */
#define OBJ_LIST 1 /* List object. */
#define OBJ_SET 2 /* Set object. */
#define OBJ_ZSET 3 /* Sorted set object. */
#define OBJ_HASH 4 /* Hash object. */
// encoding
#define OBJ_ENCODING_RAW 0 /* Raw representation */
#define OBJ_ENCODING_INT 1 /* Encoded as integer */
#define OBJ_ENCODING_HT 2 /* Encoded as hash table */
#define OBJ_ENCODING_ZIPMAP 3 /* Encoded as zipmap */
#define OBJ_ENCODING_LINKEDLIST 4 /* No longer used: old list encoding. */
#define OBJ_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
#define OBJ_ENCODING_INTSET 6 /* Encoded as intset */
#define OBJ_ENCODING_SKIPLIST 7 /* Encoded as skiplist */
#define OBJ_ENCODING_EMBSTR 8 /* Embedded sds string encoding */
#define OBJ_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists */
#define OBJ_ENCODING_STREAM 10 /* Encoded as a radix tree of listpacks */

struct redisObject {
    unsigned type:4; // 4bit，对象类型，值包括string,hash,list,set,zset等，能够用type {key}命令查看
    unsigned encoding:4; // 4bit，编码类型，如字符串类型的OBJ_ENCODING_RAW，OBJ_ENCODING_INT，OBJ_ENCODING_EMBSTR，能够用object encoding {key}命令查看
    unsigned lru:LRU_BITS; // LRU_BITS 占24bit，记录对象最后一次被访问的时间，作LRU替换算法用，能够用object idletime {key}命令查看
    int refcount; // 记录当前对象被引用数，用于经过引用数回收内存，能够用object refcount {key}命令查看
    void *ptr; // 数据指针。指向真正的数据。好比，一个表明string的robj，它的ptr可能指向一个sds结构；一个表明list的robj，它的ptr可能指向一个quicklist。
};

refcount

  • 对象回收：C语言并不具有自动内存回收功能，Redis在本身的对象系统中构建了一个引用计数技术实现的内存回收机制，经过这一机制，程序能够经过跟踪对象的引用计数信息，在适当的时候自动释放对象并进行内存回收。每一个对象的引用计数信息由redis对象结构的refcount属性记录，建立一个新对象时，引用计数值会初始化为1；对象被一个新程序使用时，它的引用计数值会被增1；再也不被一个程序使用时减1；引用计数值变为0，对象所占用的内存会被释放。Redis的del命令就依赖decrRefCount操做将value释放。
// object.c
void decrRefCount(robj *o) {
    if (o->refcount == 1) {
        switch(o->type) {
        case OBJ_STRING: freeStringObject(o); break;
        case OBJ_LIST: freeListObject(o); break;
        case OBJ_SET: freeSetObject(o); break;
        case OBJ_ZSET: freeZsetObject(o); break;
        case OBJ_HASH: freeHashObject(o); break;
        case OBJ_MODULE: freeModuleObject(o); break;
        case OBJ_STREAM: freeStreamObject(o); break;
        default: serverPanic("Unknown object type"); break;
        }
        zfree(o);
    } else {
        if (o->refcount <= 0) serverPanic("decrRefCount against refcount <= 0");
        if (o->refcount != OBJ_SHARED_REFCOUNT) o->refcount--;
    }
}

  • 对象共享：对象的引用计数属性还带有对象共享的做用。

    • 在string对象中，在建立一个数字时，会判断是否在shared.integers（默认0-9999）的范围中（实际上，生产的数字的引用次数refcount固定为2147483647），若是命中就不进行对象建立，直接使用对应的共享对象，并将引用计数加一。
    • 如图展现了包含整数值100的字符串对象同时被键A和键B共享以后的样子，能够看到，除了对象的引用计数从以前的1变成了2以外， 其余属性都没有变化（理论上是这样，但因为数字的引用次数固定，因此实际上计数并不会有这样的变化）。
      a263f699-b26c-45d5-8b4b-c1ae18001188.png

    • Redis为何只对包含整数值得字符串对象进行共享？

      • 当服务器考虑将一个共享对象设置为键的值对象时，程序须要先检查给定的共享对象和键想建立的目标对象是否彻底相同。一个共享对象保存的值越复杂，验证共享对象和目标对象是否相同所需的复杂度就会越高，消耗的CPU时间也会越多。
      • 若是共享对象是保存整数值的字符串对象，验证操做的复杂度O(1)。
      • 若是共享对象是保存字符串值的字符串对象，验证操做的复杂度O(N)。
      • 若是共享对象是包含多个值（好比列表对象或者哈希对象）对象，验证操做的复杂度O(N2)。·
      • 所以，尽管共享更复杂的对象能够节约更多的内存，但受到CPU时间的限制，Redis只对包含整数值得字符串对象进行共享。

    • 须要提醒的是，append和setbit命令会解除对象的共享状态，例如：

      • 执行set testref 1命令以后，再经过object debug testref， 能够看到refcount:2147483647。
      • 执行append testref 1命令以后，再经过object debug testref， 能够看到refcount:1。
// server.h
#define OBJ_SHARED_REFCOUNT INT_MAX
#define OBJ_SHARED_INTEGERS 10000
// object.c
robj *makeObjectShared(robj *o) {
    serverAssert(o->refcount == 1);
    o->refcount = OBJ_SHARED_REFCOUNT;
    return o;
}
// server.c
void createSharedObjects(void) {
 ……
    for (j = 0; j < OBJ_SHARED_INTEGERS; j++) {
        shared.integers[j] =
            makeObjectShared(createObject(OBJ_STRING,(void*)(long)j));
        shared.integers[j]->encoding = OBJ_ENCODING_INT;
    }    
    ……    
}    
// t_string.c
void appendCommand(client *c) {
    ……
   o = dbUnshareStringValue(c->db,c->argv[1],o);
   ……
}
// db.c
robj *dbUnshareStringValue(redisDb *db, robj *key, robj *o) {
    serverAssert(o->type == OBJ_STRING);
    if (o->refcount != 1 || o->encoding != OBJ_ENCODING_RAW) {
        robj *decoded = getDecodedObject(o);
        o = createRawStringObject(decoded->ptr, sdslen(decoded->ptr));
        decrRefCount(decoded);
        dbOverwrite(db,key,o);
    }
    return o;
}

redisObject的结构与对象类型、编码、内存回收、共享对象都有关系；一个redisObject对象的大小为16字节：4bit+4bit+24bit+4Byte+8Byte=16Byte。

以上内容参考自：
《redis设计与实现》
《 Redis源码剖析系列》
《 Redis内部数据结构详解系列》
《 多是目前最详细的Redis内存模型及应用解读》
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程