深入了解Redis【二】对象及数据结构综述

引言

Redis中每个键值对都是由对象组成:

  • 键总是一个字符串对象（string）
  • 值可以是字符串对象（string）、列表对象（list）、哈希对象（hash）、集合对象（set）、有序集合对象（zset）。

介绍

redis官方网站中对其数据类型的简单介绍:
An introduction to Redis data types and abstractions
摘抄一段关于redis key的介绍：

Redis keys
Redis keys are binary safe, this means that you can use any binary sequence as a key, from a string like "foo" to the content of a JPEG file. The empty string is also a valid key.
A few other rules about keys:

  • Very long keys are not a good idea. For instance a key of 1024 bytes is a bad idea not only memory-wise, but also because the lookup of the key in the dataset may require several costly key-comparisons. Even when the task at hand is to match the existence of a large value, hashing it (for example with SHA1) is a better idea, especially from the perspective of memory and bandwidth.
  • Very short keys are often not a good idea. There is little point in writing "u1000flw" as a key if you can instead write "user:1000:followers". The latter is more readable and the added space is minor compared to the space used by the key object itself and the value object. While short keys will obviously consume a bit less memory, your job is to find the right balance.
  • Try to stick with a schema. For instance "object-type:id" is a good idea, as in "user:1000". Dots or dashes are often used for multi-word fields, as in "comment??reply.to" or "comment??reply-to".
  • The maximum allowed key size is 512 MB.

源码中的对象数据结构

在redis源码中，对象的数据结构定义在redis.h文件中

#define REDIS_LRU_BITS 24
typedef struct redisObject {
    // 类型
    unsigned type:4;
    // 编码
    unsigned encoding:4;
    // 对象最后一次被访问的时间
    unsigned lru:REDIS_LRU_BITS; /* lru time (relative to server.lruclock) */
    // 引用计数
    int refcount;
    // 指向实际值的指针
    void *ptr;
}

下面分别介绍以下对象中定义的属性定义：

  • type
    type是指对象的5中基本类型：string、hash、list、set、zset。
// 对象类型
#define REDIS_STRING 0
#define REDIS_LIST 1
#define REDIS_SET 2
#define REDIS_ZSET 3
#define REDIS_HASH 4
  • encoding
    表示对象的底层编码实现，有简单动态字符串、链表、字典、跳跃表、整数集合、压缩列表。
// 对象编码
#define REDIS_ENCODING_RAW 0     /* Raw representation */
#define REDIS_ENCODING_INT 1     /* Encoded as integer */
#define REDIS_ENCODING_HT 2      /* Encoded as hash table */
#define REDIS_ENCODING_ZIPMAP 3  /* Encoded as zipmap */
#define REDIS_ENCODING_LINKEDLIST 4 /* Encoded as regular linked list */
#define REDIS_ENCODING_ZIPLIST 5 /* Encoded as ziplist */
#define REDIS_ENCODING_INTSET 6  /* Encoded as intset */
#define REDIS_ENCODING_SKIPLIST 7  /* Encoded as skiplist */
#define REDIS_ENCODING_EMBSTR 8  /* Embedded sds string encoding */
  • lru
    最后一次访问对象的时间，用来处理键的过期策略。
  • refcount
    对象引用的指针，不同key的相同对象引用同一个对象，减少内存分配即对象共享。也用于内存释放。
  • *ptr
    指向底层数据结构的指针。

基本类型type与底层数据结构的对应关系

盗取一张图(懒的画图)：

各种对象的创建可以参考redis源码中的object.c文件，如：
根据传入的整数型，创建一个字符串：

/*
 * 根据传入的整数值，创建一个字符串对象
 *
 * 这个字符串的对象保存的可以是 INT 编码的 long 值，
 * 也可以是 RAW 编码的、被转换成字符串的 long long 值。
 */
robj *createStringObjectFromLongLong(long long value) {

    robj *o;

    // value 的大小符合 REDIS 共享整数的范围
    // 那么返回一个共享对象
    if (value >= 0 && value < REDIS_SHARED_INTEGERS) {
        incrRefCount(shared.integers[value]);
        o = shared.integers[value];

    // 不符合共享范围，创建一个新的整数对象
    } else {
        // 值可以用 long 类型保存，
        // 创建一个 REDIS_ENCODING_INT 编码的字符串对象
        if (value >= LONG_MIN && value <= LONG_MAX) {
            o = createObject(REDIS_STRING, NULL);
            o->encoding = REDIS_ENCODING_INT;
            o->ptr = (void*)((long)value);

        // 值不能用 long 类型保存（long long 类型），将值转换为字符串，
        // 并创建一个 REDIS_ENCODING_RAW 的字符串对象来保存值
        } else {
            o = createObject(REDIS_STRING,sdsfromlonglong(value));
        }
    }

    return o;
}

线面简单看看基本类型type对应的底层数据结构：

string

sting在redis底层对应三种编码方式，两种数据结构。
如果一个字符串内容可以转成long,那么编码方式为int,底层数据结构为int.
如果普通字符串对象的长度小于39字节，就用embstr对象。否则用的raw对象,底层数据结构为简单动态字符串。

/* Create a string object with EMBSTR encoding if it is smaller than
 * REIDS_ENCODING_EMBSTR_SIZE_LIMIT, otherwise the RAW encoding is
 * used.
 *
 * The current limit of 39 is chosen so that the biggest string object
 * we allocate as EMBSTR will still fit into the 64 byte arena of jemalloc. */
#define REDIS_ENCODING_EMBSTR_SIZE_LIMIT 39
robj *createStringObject(char *ptr, size_t len) {
    if (len <= REDIS_ENCODING_EMBSTR_SIZE_LIMIT)
        return createEmbeddedStringObject(ptr,len);
    else
        return createRawStringObject(ptr,len);
}
SDS

简单动态字符串(simple dynamic string)的数据结构为：

/*
 * 保存字符串对象的结构
 */
struct sdshdr {
    // buf 中已占用空间的长度
    int len;
    // buf 中剩余可用空间的长度
    int free;
    // 数据空间
    char buf[];
};

list

有两种编码实现，链表linkedlist和压缩列表ziplist，当当list元素少且元素内容长度不大时，使用ziplist，否则使用linkedlist.

/* Use a real list when there are too many entries
         *
         * 根据节点数，创建对象的编码
         */
        if (len > server.list_max_ziplist_entries) {
            o = createListObject();
        } else {
            o = createZiplistObject();
        }
/*
 * 创建一个 LINKEDLIST 编码的列表对象
 */
robj *createListObject(void) {

    list *l = listCreate();

    robj *o = createObject(REDIS_LIST,l);

    listSetFreeMethod(l,decrRefCountVoid);

    o->encoding = REDIS_ENCODING_LINKEDLIST;

    return o;
}

/*
 * 创建一个 ZIPLIST 编码的列表对象
 */
robj *createZiplistObject(void) {

    unsigned char *zl = ziplistNew();

    robj *o = createObject(REDIS_LIST,zl);

    o->encoding = REDIS_ENCODING_ZIPLIST;

    return o;
}
链表linkedlist

其底层数据结构list位于adlist.h中：

/*
 * 双端链表节点
 */
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;
压缩列表ziplist

类似数组，但是每个节点存储的数据大小不同，节点上有length属性。

hash

有两种数据结构实现，压缩列表ziplist和字典dict.

字典dict

相当于java中的HashMap。解决hash冲突使用的是链表法，好像没有上升到红黑树。

set

如果是整数类型，直接使用整数集合intset，如果不是，就用字典，和java的set一样。

zset

有序的set,元素个数少且不大，就用压缩列表ziplist，否则就用跳跃表skiplist.

跳跃表skiplist

跳跃表（skiplist）是一种有序数据结构，它通过在每个节点中维持多个指向其他节点的指针，从而达到快速访问节点的目的。
跳跃表是一种随机化的数据,跳跃表以有序的方式在层次化的链表中保存元素。
定义位于redis.h中。


/* ZSETs use a specialized version of Skiplists */
/*
 * 跳跃表节点
 */
typedef struct zskiplistNode {

    // 成员对象
    robj *obj;

    // 分值
    double score;

    // 后退指针
    struct zskiplistNode *backward;

    // 层
    struct zskiplistLevel {

        // 前进指针
        struct zskiplistNode *forward;

        // 跨度
        unsigned int span;

    } level[];

} zskiplistNode;

/*
 * 跳跃表
 */
typedef struct zskiplist {

    // 表头节点和表尾节点
    struct zskiplistNode *header, *tail;

    // 表中节点的数量
    unsigned long length;

    // 表中层数最大的节点的层数
    int level;

} zskiplist;

参考文档

深入浅出Redis-redis底层数据结构（上）
深入浅出Redis-redis底层数据结构（下）
Redis基本类型及其数据结构
Redis的五种对象类型及其底层实现
Redis-基本数据类型与内部存储结构
redis的五种基本数据类型及其内部实现
《Redis设计与实现》黄健宏

原文地址：https://www.cnblogs.com/clawhub/p/12019847.html

时间： 2024-10-09 06:19:11

深入了解Redis【二】对象及数据结构综述的相关文章

Redis系列(二)：Redis的5种数据结构及其常用命令

上一篇博客,我们讲解了什么是Redis以及在Windows和Linux环境下安装Redis的方法, 没看过的同学可以点击以下链接查看: Redis系列(一):Redis简介及环境安装. 本篇博客我们来讲解下Redis的5种数据结构及其常用命令,5种数据结构分别为: 字符串String 列表List 集合Set 散列Hash 有序集合ZSet 注意事项:Redis可以存储键(key)值(value)对的映射,其中键(key)一直是String,而值可以是上面提到的5种数据结构中的一种. 1. 字符

Redis第二讲【Redis基本命令和五大数据结构】

[二.Redis基本命令和五大数据结构] redis的基础知识和命令 redis 是一个单进程(包装epoll函数来对读写事件进行相应) 默认有16个数据库,初始使用的数据库为0号库 默认端口为6379 select :切换数据库 dbsize:查看当前库的key的个数 flushdb:清空当前库 flushall:清空所有库 redis的五大数据类型 key键 keys *:查看当前所有库的key 127.0.0.1:6379> keys * 1) "k1" 2) "

Redis 中 5 种数据结构的使用场景介绍

这篇文章主要介绍了Redis中5种数据结构的使用场景介绍,本文对Redis中的5种数据类型String.Hash.List.Set.Sorted Set做了讲解,需要的朋友可以参考下 一.redis 数据结构使用场景 原来看过 redisbook 这本书,对 redis 的基本功能都已经熟悉了,从上周开始看 redis 的源码.目前目标是吃透 redis 的数据结构.我们都知道,在 redis 中一共有5种数据结构,那每种数据结构的使用场景都是什么呢? String——字符串 Hash——字典

redis中5种数据结构的使用

一.redis 数据结构使用场景 原来看过 redisbook 这本书,对 redis 的基本功能都已经熟悉了,从上周开始看 redis 的源码.目前目标是吃透 redis 的数据结构.我们都知道,在 redis 中一共有5种数据结构,那每种数据结构的使用场景都是什么呢? String——字符串Hash——字典List——列表Set——集合Sorted Set——有序集合 下面我们就来简单说明一下它们各自的使用场景: 1. String——字符串 String 数据结构是简单的 key-valu

Redis中5种数据结构的使用场景

一.redis 数据结构使用场景 原来看过 redisbook 这本书,对 redis 的基本功能都已经熟悉了,从上周开始看 redis 的源码.目前目标是吃透 redis 的数据结构.我们都知道,在 redis 中一共有5种数据结构,那每种数据结构的使用场景都是什么呢? String--字符串Hash--字典List--列表Set--集合Sorted Set--有序集合 下面我们就来简单说明一下它们各自的使用场景: 1. String--字符串 String 数据结构是简单的 key-valu

Redis 概念以及底层数据结构

Redis 简介REmote DIctionary Server(Redis) 是一个由SalvatoreSanfilippo写的key-value存储系统. Redis是一个开源的使用ANSI C语言编写.遵守BSD协议.支持网络.可基于内存亦可持久化的日志型.Key-Value数据库,并提供多种语言的API. 它通常被称为数据结构服务器,因为值(value)可以是字符串(String), 哈希(Map), 列表(list), 集合(sets) 和有序集合(sorted sets)等类型. R

redis的对象类型及其相应的编码类型

1.redis的对象类型 Redis 使用对象来表示数据库中的键和值, 每次当我们在 Redis 的数据库中新创建一个键值对时, 我们至少会创建两个对象, 一个对象用作键值对的键(键对象), 另一个对象用作键值对的值(值对象). 键对象总是字符串对象类型,值对象则有以下类型 对象 对象 type 属性的值 TYPE 命令的输出 字符串对象 REDIS_STRING "string" 列表对象 REDIS_LIST "list" 哈希对象 REDIS_HASH &qu

redis存储对象与对象序列化详解

redis主要存储类型最常用的五种数据类型: String Hash List Set Sorted set redis存储对象序列化和反序列化 首先来了解一下为什么要实现序列化 为什么要实现序列化接口 当一个类实现了Serializable接口(该接口仅为标记接口,不包含任何方法定义),表示该类可以序列化.序列化的目的是将一个实现了Serializable接口的对象转换成一个字节序列,可以. 把该字节序列保存起来(例如:保存在一个文件里),以后可以随时将该字节序列恢复为原来的对象.甚至可以将该

Liunx下Redis集群的安装与测试，以及项目中的应用(redis中对象和集合的储存)。

Liunx下Redis集群的安装与测试,以及项目中的应用. 首先准备ruby和redis接口: redis-3.0.0.gem和 去https://redis.io/下载 1.使用ruby脚本搭建集群.需要ruby的运行环境. 安装ruby yum install ruby yum install rubygems 1.1安装ruby脚本运行使用的包. [[email protected] ~]# gem install redis-3.0.0.gem Successfully installe