【Redis】底层数据结构

已于 2022-10-24 11:24:52 修改
阅读量123 收藏
点赞数
分类专栏： Redis 文章标签： redis 1024程序员节
于 2022-05-24 16:43:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Qy1997/article/details/124949763
版权

1.动态字符串SDS

由于C语言字符串存在如下的一些问题：

  • 获取字符串长度需要通过运算
  • 非二进制安全
  • 不可修改

Redis构建了一种新的字符串结构，称为简单动态字符串（Simple Dynamic String），简称SDS

SDS的源码如下：

需要注意的是，redis6.0版本之前没有alloc这个属性，而是使用的free属性，表示未使用的字节数，两者相差不大，都能通过计算得到对方。

struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len; /* buf已保存的字符串字节数，不包含结束标示*/
    uint8_t alloc; /* buf申请的总的字节数，不包含结束标示*/
    unsigned char flags; /* 不同SDS的头类型，用来控制SDS的头大小
    char buf[];
};

一个包含字符串“name”的sds结构如下：
在这里插入图片描述

下面详细介绍一下SDS的一些特性。

1.1.常数复杂度获取字符串长度

因为C字符串并不记录自身的长度信息，所以为了获取一个C字符串的长度，程序必须遍历整个字符串，对遇到的每个字符进行计数，直到遇到代表字符串结尾的空字符为止，这个操作的复杂度为O（N）。

而对于如图1-1所示的SDS结构而言，只需要访问字符串的len属性，就可以以O（1）的复杂度知道字符串的长度。

其中，设置和更新SDS长度的工作是由SDS的API在执行时自动完成的，使用SDS无须进行任何手动修改长度的工作。

1.2.杜绝缓冲区溢出

SDS的空间分配策略完全杜绝了发生缓冲区溢出的可能性：当SDS API需要对SDS进行修改时，API会先检查SDS的空间是否满足修改所需的要求，如果不满足的话，API会自动将SDS的空间扩展至执行修改所需的大小，然后才执行实际的修改操作，所以使用SDS既不需要手动修改SDS的空间大小，也不会出现前面所说的缓冲区溢出问题。

1.3.SDS的内存分配策略

SDS通过申请的空间解除了字符串长度和底层数组长度之间的关联：在SDS中，buf数组的长度不一定就是字符数量加一，数组里面可以包含未使用的字节，即alloc>len。通过这一特性，SDS实现了空间预分配和惰性空间释放两种优化策略。

空间预分配

SDS通过未使用空间解除了字符串长度和底层数组长度之间的关联：在SDS中，buf数组的长度不一定就是字符数量加一，数组里面可以包含未使用的字节，而这些字节的数量就由SDS的free属性记录。通过未使用空间，SDS实现了空间预分配和惰性空间释放两种优化策略。

  • 如果对SDS进行修改之后，SDS的长度（也即是len属性的值）将小于1MB，那么程序分配和len属性同样大小的未使用空间，这时SDS的alloc属性为2倍的len属性。
  • 如果对SDS进行修改之后，SDS的长度将大于等于1MB，那么程序会分配1MB的未使用空间。

通过空间预分配策略，Redis可以减少连续执行字符串增长操作所需的内存重分配次数，将连续增长N次字符串所需的内存重分配次数从必定N次降低为最多N次。

惰性空间释放

惰性空间释放用于优化SDS的字符串缩短操作：当SDS的API需要缩短SDS保存的字符串时，程序并不立即使用内存重分配来回收缩短后多出来的字节。

通过惰性空间释放策略，SDS避免了缩短字符串时所需的内存重分配操作，并为将来可能有的增长操作提供了优化。

与此同时，SDS也提供了相应的API，让我们可以在有需要时，真正地释放SDS的未使用空间，所以不用担心惰性空间释放策略会造成内存浪费。

1.4.二进制安全

C字符串中的字符必须符合某种编码（比如ASCII），并且除了字符串的末尾之外，字符串里面不能包含空字符，否则最先被程序读入的空字符将被误认为是字符串结尾，这些限制使得C字符串只能保存文本数据，而不能保存像图片、音频、视频、压缩文件这样的二进制数据。

使用SDS来保存之前提到的特殊数据格式就没有任何问题，因为SDS使用len属性的值而不是空字符来判断字符串是否结束

2.整数集合IntSet

IntSet是Redis中set集合的一种实现方式，基于整数数组来实现，并且具备长度可变、有序等特征。
结构如下：

typedef struct intset {
    uint32_t encoding; /* 编码方式，支持存放16位、32位、64位整数*/
    uint32_t length; /* 元素个数 */
    int8_t contents[]; /* 整数数组，保存集合数据*/
} intset;

其中的encoding包含三种模式，表示存储的整数大小不同：

/* Note that these encodings are ordered, so:
* INTSET_ENC_INT16 < INTSET_ENC_INT32 < INTSET_ENC_INT64. */
#define INTSET_ENC_INT16 (sizeof(int16_t)) /* 2字节整数，范围类似java的short*/
#define INTSET_ENC_INT32 (sizeof(int32_t)) /* 4字节整数，范围类似java的int */
#define INTSET_ENC_INT64 (sizeof(int64_t)) /* 8字节整数，范围类似java的long */

contents数组是整数集合的底层实现：整数集合的每个元素都是contents数组的一个数组项（item），各个项在数组中按值的大小从小到大有序地排列，并且数组中不包含任何重复项。

length属性记录了整数集合包含的元素数量，也即是contents数组的长度。

2.1.IntSet升级

现在，假设有一个intset，元素为{5,10，20}，采用的编码是INTSET_ENC_INT16，则每个整数占2字节：
在这里插入图片描述

我们向该其中添加一个数字：50000，这个数字超出了int16_t的范围，intset会自动升级编码方式到合适的大小。
以当前案例来说流程如下：
① 升级编码为INTSET_ENC_INT32, 每个整数占4字节，并按照新的编码方式及元素个数扩容数组
② 倒序依次将数组中的元素拷贝到扩容后的正确位置
③ 将待添加的元素放入数组末尾
④ 最后，将inset的encoding属性改为INTSET_ENC_INT32，将length属性改为4
在这里插入图片描述

因为引发升级的新元素的长度总是比整数集合现有所有元素的长度都大，所以这个新元素的值要么就大于所有现有元素，要么就小于所有现有元素：

  • 在新元素小于所有现有元素的情况下，新元素会被放置在底层数组的最开头（索引0）；
  • 在新元素大于所有现有元素的情况下，新元素会被放置在底层数组的最末尾（索引length-1）

整数集合的升级策略有两个好处，一个是提升整数集合的灵活性，另一个是尽可能地节约内存。

整数集合不支持降级操作，一旦对数组进行了升级，编码就会一直保持升级后的状态。

新增流程源码：

intset *intsetAdd(intset *is, int64_t value, uint8_t *success) {
    uint8_t valenc = _intsetValueEncoding(value);// 获取当前值编码
    uint32_t pos; // 要插入的位置
    if (success) *success = 1;
    // 判断编码是不是超过了当前intset的编码
    if (valenc > intrev32ifbe(is->encoding)) {
        // 超出编码，需要升级
        return intsetUpgradeAndAdd(is,value);
    } else {
        // 在当前intset中查找值与value一样的元素的角标pos
        if (intsetSearch(is,value,&pos)) {
            if (success) *success = 0; //如果找到了，则无需插入，直接结束并返回失败
            return is;
        }
        // 数组扩容
        is = intsetResize(is,intrev32ifbe(is->length)+1);
        // 移动数组中pos之后的元素到pos+1，给新元素腾出空间
        if (pos < intrev32ifbe(is->length)) intsetMoveTail(is,pos,pos+1);
    }
    // 插入新元素
    _intsetSet(is,pos,value);
    // 重置元素长度
    is->length = intrev32ifbe(intrev32ifbe(is->length)+1);
    return is;
}

升级流程源码：

static intset *intsetUpgradeAndAdd(intset *is, int64_t value) {
    // 获取当前intset编码
    uint8_t curenc = intrev32ifbe(is->encoding);
    // 获取新编码
    uint8_t newenc = _intsetValueEncoding(value);
    // 获取元素个数
    int length = intrev32ifbe(is->length); 
    // 判断新元素是大于0还是小于0 ，小于0插入队首、大于0插入队尾
    int prepend = value < 0 ? 1 : 0;
    // 重置编码为新编码
    is->encoding = intrev32ifbe(newenc);
    // 重置数组大小
    is = intsetResize(is,intrev32ifbe(is->length)+1);
    // 倒序遍历，逐个搬运元素到新的位置，_intsetGetEncoded按照旧编码方式查找旧元素
    while(length--) // _intsetSet按照新编码方式插入新元素
        _intsetSet(is,length+prepend,_intsetGetEncoded(is,length,curenc));
    /* 插入新元素，prepend决定是队首还是队尾*/
    if (prepend)
        _intsetSet(is,0,value);
    else
        _intsetSet(is,intrev32ifbe(is->length),value);
    // 修改数组长度
    is->length = intrev32ifbe(intrev32ifbe(is->length)+1);
    return is;
}

3.字典Dict

Dict由三部分组成，分别是：字典（Dict）、哈希表（DictHashTable）、哈希节点（DictEntry）

Dict：

typedef struct dict {
    dictType *type; // dict类型，内置不同的hash函数
    void *privdata; // 私有数据，在做特殊hash运算时用
    dictht ht[2]; // 一个Dict包含两个哈希表，其中一个是当前数据，另一个一般是空，rehash时使用
    long rehashidx; // rehash的进度，-1表示未进行
    int16_t pauserehash; // rehash是否暂停，1则暂停，0则继续
} dict;

DictHashTable：

typedef struct dictht {
    // entry数组
    // 数组中保存的是指向entry的指针
    dictEntry **table;
    // 哈希表大小
    unsigned long size;
    // 哈希表大小的掩码，总等于size - 1
    unsigned long sizemask;
    // entry个数
    unsigned long used; 
} dictht;

DictEntry：

typedef struct dictEntry {
    void *key; // 键
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v; // 值
    // 下一个Entry的指针
    struct dictEntry *next;
} dictEntry;

3.1.哈希算法

当要将一个新的键值对添加到字典里面时，程序需要先根据键值对的键计算出哈希值和索引值，然后再根据索引值，将包含新键值对的哈希表节点放到哈希表数组的指定索引上面。

MurmurHash算法最初由Austin Appleby于2008年发明，这种算法的优点在于，即使输入的键是有规律的，算法仍能给出一个很好的随机分布性，并且算法的计算速度也非常快。
MurmurHash算法目前的最新版本为MurmurHash3，而Redis使用的是MurmurHash2，关于MurmurHash算法的更多信息可以参考该算法的主页：http://code.google.com/p/smhasher/。

3.2.哈希冲突

当有两个或以上数量的键被分配到了哈希表数组的同一个索引上面时，我们称这些键发生了冲突（collision）。

Redis的哈希表使用链地址法（separate chaining）来解决键冲突，每个哈希表节点都有一个next指针，多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这个单向链表连接起来，这就解决了键冲突的问题。

3.3.rehash

扩容

Dict中的HashTable就是数组结合单向链表的实现，当集合中元素较多时，必然导致哈希冲突增多，链表过长，则查询效率会大大降低。
Dict在每次新增键值对时都会检查负载因子（LoadFactor = used/size） ，满足以下两种情况时会触发哈希表扩容：

  • 哈希表的 LoadFactor >= 1，并且服务器没有执行 BGSAVE 或者 BGREWRITEAOF 等后台进程；
  • 哈希表的 LoadFactor > 5 ；
static int _dictExpandIfNeeded(dict *d){
    // 如果正在rehash，则返回ok
    if (dictIsRehashing(d)) return DICT_OK;
    // 如果哈希表为空，则初始化哈希表为默认大小：4
    if (d->ht[0].size == 0) return dictExpand(d, DICT_HT_INITIAL_SIZE);
    // 当负载因子（used/size）达到1以上，并且当前没有进行bgrewrite等子进程操作
    // 或者负载因子超过5，则进行 dictExpand ，也就是扩容
    if (d->ht[0].used >= d->ht[0].size &&
        (dict_can_resize || d->ht[0].used/d->ht[0].size > dict_force_resize_ratio){
        // 扩容大小为used + 1，底层会对扩容大小做判断，实际上找的是第一个大于等于 used+1 的 2^n
        return dictExpand(d, d->ht[0].used + 1);
    }
    return DICT_OK;
}

收缩

Dict除了扩容以外，每次删除元素时，也会对负载因子做检查，当LoadFactor < 0.1 时，会做哈希表收缩：

rehash

Dict的rehash并不是一次性完成的。试想一下，如果Dict中包含数百万的entry，要在一次rehash完成，极有可能导致主线程阻塞。因此Dict的rehash是分多次、渐进式的完成，因此称为渐进式rehash。流程如下：

  • 计算新hash表的size，值取决于当前要做的是扩容还是收缩：

    • 如果是扩容，则新size为第一个大于等于dict.ht[0].used + 1的2𝑛

    • 如果是收缩，则新size为第一个大于等于dict.ht[0].used的2𝑛 （不得小于4）

  • ② 按照新的size申请内存空间，创建dictht，并赋值给dict.ht[1]

  • ③ 设置dict.rehashidx = 0，标示开始rehash

  • ④ 每次执行新增、查询、修改、删除操作时，都检查一下dict.rehashidx是否大于-1，如果是则将dict.ht[0].table[rehashidx]的entry链表rehash到dict.ht[1]，并且将rehashidx++。直至dict.ht[0]的所有数据都rehash到dict.ht[1]

  • ⑤ 将dict.ht[1]赋值给dict.ht[0]，给dict.ht[1]初始化为空哈希表，释放原来的dict.ht[0]的内存

  • ⑥ 将rehashidx赋值为-1，代表rehash结束

  • ⑦ 在rehash过程中，新增操作，则直接写入ht[1]，查询、修改和删除则会在dict.ht[0]和dict.ht[1]依次查找并执行。这样可以确保ht[0]的数据只减不增，随着rehash最终为空

4.压缩列表ZipList

压缩列表是Redis为了节约内存而开发的，是由一系列特殊编码的连续内存块组成的顺序型（sequential）数据结构。一个压缩列表可以包含任意多个节点（entry），每个节点可以保存一个字节数组或者一个整数值。

在这里插入图片描述

4.1.entry

ZipList 中的Entry并不像普通链表那样记录前后节点的指针，因为记录两个指针要占用16个字节，浪费内存。而是采用了下面的结构：

在这里插入图片描述

  • previous_entry_length：前一节点的长度，占1个或5个字节。

    • 如果前一节点的长度小于254字节，则采用1个字节来保存这个长度值
    • 如果前一节点的长度大于254字节，则采用5个字节来保存这个长度值，第一个字节为0xfe，后四个字节才是真实长度数据

  • encoding：编码属性，记录content的数据类型（字符串还是整数）以及长度，占用1个、2个或5个字节

  • contents：负责保存节点的数据，可以是字符串或整数

encoding

ZipListEntry中的encoding编码分为字符串和整数两种：

  • 字符串：如果encoding是以“00”、“01”或者“10”开头，则证明content是字符串
    在这里插入图片描述

  • 整数：如果encoding是以“11”开始，则证明content是整数，且encoding固定只占用1个字节
    在这里插入图片描述

4.2.连锁更新问题

连锁更新问题的关键就在于previous_entry_length这个字段的变换，如果所有的entry都在临界点，前面有一个entry更新之后使得previous_entry_length由一个字节转为五个字节，或者由5个字节转为一个字节，就会引发连锁更新问题。

5.快速链表QuickList

Redis在3.2版本引入了新的数据结构QuickList，它是一个双端链表，只不过链表中的每个节点都是一个ZipList。

为了避免QuickList中的每个ZipList中entry过多，Redis提供了一个配置项：list-max-ziplist-size来限制。

  • 如果值为正，则代表ZipList的允许的entry个数的最大值

  • 如果值为负，则代表ZipList的最大内存大小，分5种情况：

    • -1：每个ZipList的内存占用不能超过4kb
    • -2：每个ZipList的内存占用不能超过8kb
    • -3：每个ZipList的内存占用不能超过16kb
    • -4：每个ZipList的内存占用不能超过32kb
    • -5：每个ZipList的内存占用不能超过64kb
    • 其默认值为 -2：

除了控制ZipList的大小，QuickList还可以对节点的ZipList做压缩。通过配置项list-compress-depth来控制。因为链
表一般都是从首尾访问较多，所以首尾是不压缩的。这个参数是控制首尾不压缩的节点个数：

  • 0：特殊值，代表不压缩
  • 1：标示QuickList的首尾各有1个节点不压缩，中间节点压缩
  • 2：标示QuickList的首尾各有2个节点不压缩，中间节点压缩
  • 以此类推

6.跳表SkipList

SkipList（跳表）首先是链表，但与传统链表相比有几点差异：

  • 元素按照升序排列存储
  • 节点可能包含多个指针，指针跨度不同。
// t_zset.c
typedef struct zskiplist {
    // 头尾节点指针
    struct zskiplistNode *header, *tail;
    // 节点数量
    unsigned long length;
    // 最大的索引层级，默认是1
    int level;
} zskiplist;

// t_zset.c
typedef struct zskiplistNode {
    sds ele; // 节点存储的值
    double score;// 节点分数，排序、查找用
    struct zskiplistNode *backward; // 前一个节点指针
    struct zskiplistLevel {
        struct zskiplistNode *forward; // 下一个节点指针
        unsigned long span; // 索引跨度
    } level[]; // 多级索引数组
} zskiplistNode;

7.RedisObject

Redis中的任意数据类型的键和值都会被封装为一个RedisObject，也叫做Redis对象，源码如下：
在这里插入图片描述

Redis中会根据存储的数据类型不同，选择不同的编码方式，共包含11种不同类型：
在这里插入图片描述

思惘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis中的压缩列表（连锁更新）
weixin_45729809的博客
03-28 1556
压缩列表的应用 压缩列表（ziplist）是列表键和哈希键的底层实现之一。当一个列表键只包含少量列表项，并且每个列表项要么就是小整数值，要么就是长度比较短的字符串，那么redis就会使用压缩列表来做列表键的底层实现。 redis> RPUSH lst 1 3 5 10086 "hello" "world" (integer)6 redis> OBJECT ENCODING lst "ziplist" 另外，当一个哈希键只包含少量键值对，并且每个键值对的键和值要么就是小整数值，要么就是长度较短
redis底层数据模型与数据结构
08-12
redis底层数据模型与数据结构，讲解redis的底层模型，以及数据存储格式
Redis源码学习：ziplist的数据结构和连锁更新问题
专注于分享个人学习工作沉淀内容，不做网络搬运工
06-22 747
虽然ziplist对头尾的操作可以很快，但是，当要查找列表中间的元素时，ziplist 就得从列表头或列表尾遍历才行。由于ziplist 必须使用一块连续的内存空间来保存数据，所以当新插入一个元素时，ziplist 就需要计算其所需的空间大小，并申请相应的内存空间，假设有N个小于255字节的Entry，每一个Entry的。ziplist 是 Redis 中一种紧凑型的列表结构，专门用来存储元素数量少且每个元素较小的数据。都可以用1个字节存储，现在要在中间插入新的Entry，长度大于254，此时。
Redis数据结构——QuickList、SkipList、RedisObjective
TiankkTT的博客
05-21 490
是一个节点为ZipList的双端链表。节点采用ZipList，解决了传统链表的内存占用问题。控制了ZipList大小，解决连续内存空间申请效率问题。中间节点可以压缩，进一步节省了内存。跳跃表是一个双向链表，每个节点都包含score和ele值。节点按照score值排序，score值一样则按照ele字典排序。每个节点都可以包含多层指针，层数是1到32之间的随机数。不同层指针到下一个节点的跨度不同，层级越高，跨度越大。增删改查效率与红黑树基本一致，实现却更简单。
Redis数据结构-ZipList的连锁更新问题2
qq_28770419的博客
05-15 285
1.7 Redis数据结构-SkipList。我们接下来用一段流程图来描述当前的这个结构。节点可能包含多个指针，指针跨度不同。节点可能包含多个指针，指针跨度不同。节点可能包含多个指针，指针跨度不同。元素按照升序排列存储。元素按照升序排列存储。元素按照升序排列存储。
listpack如何遍历？如何解决ziplist连锁更新问题？(五)
小派师兄
08-28 1390
listpack如何遍历？，如何解决ziplist连锁更新问题？(五)
redis底层数据结构
青鱼入云的博客
10-18 579
详细介绍redis五种数据结构对应下的底层数据结构实现
Redis底层数据结构
War_wick的博客
03-02 1072
Redis 是一个数据结构服务器。Redis 的核心是提供一组原生数据类型，可帮助您解决各种各样的问题，从缓存到队列再到事件处理。下面是每种数据类型的简短描述，以及更广泛的概述。
源码级别讲解 redis 底层数据结构
热门推荐
LoveSummer
05-10 4万+
Redis作为Key-Value存储系统，数据结构如下：Redis没有表的概念，Redis实例所对应的db以编号区分，db本身就是key的命名空间。比如：user:1000作为key值，表示在user这个命名空间下id为1000的元素，类似于user表的id=1000的 行。
redis底层数据结构之ziplist
xiong_tai的博客
04-21 1075
一种连续内存空间存储的顺序数据结构，每个元素可以是字符串或整数。优点:节省内存空间。适用于存储小规模的列表或有序集合。缺点:修改操作可能引发连锁更新，影响性能。使用场景: 在列表键元素较少或元素都是小整数时使用。
Redis底层数据结构和原理
浮尘笔记
05-09 440
Redis 的基本对象结构 RedisObject，因为 Redis 键值对中的每一个值都是用 RedisObject 保存的。RedisObject 包括元数据和指针。其中元数据的一个功能就是用来区分不同的数据类型，指针用来指向具体的数据类型的值。RedisObject 的内部组成包括了 type,、encoding,、lru 和 refcount 4 个元数据，以及 1个*ptr指针。redis的底层数据结构一共有 6 种，分别是简单动态字符串、双向链表、压缩列表、哈希表、跳表和整数数组。
Redis底层数据结构之Dict
xiong_tai的博客
04-23 2769
Redis 的 Dict 是一个高效的键值对映射数据结构，采用双哈希表实现以支持无锁的渐进式 Rehash，确保扩容或缩容时的高效性能。它通过哈希表节点以链表形式解决哈希冲突，允许快速的查找、插入和删除操作，是实现 Redis 各种数据类型和高级功能的基础架构之一。
20200918_redis底层数据结构.pptx
10-13
自己整理的redis底层源码，非常的详细，需要的可以下载，谢谢大家的支持，我花费了很长时间才总结出来的精华
Redis 数据结构1
08-03
7. Redis 对象和数据结构：Redis 提供的列表、哈希、集合和有序集合等对象，根据数据规模和特性，可能使用不同的底层实现，如ziplist适用于小数据量场景，而大列表可能使用链表或跳跃表，哈希可能用字典，有序集合...
redis基础数据结构讲解
08-10
本文主要介绍redis的几种数据类型和适用场景。会列出简单例子，具体的redis函数不会一一介绍。不过这些简单的例子基本上满足80%以上的项目。
Redis核心数据结构与高性能原理.zip
05-24
Redis是一款高性能的键值对数据库，它以其丰富的数据结构、高效的性能和广泛的应用场景而备受开发者喜爱。在Redis中，核心的数据结构是实现其高效功能的基础。本篇将深入探讨Redis中的主要数据结构以及如何利用这些...
Redisson分布式锁使用详解
2301_76166241的博客
07-24 1054
通常我们都会将redisson实例注入到方法类里面，然后调用加锁方法进行加锁，如果其他业务方法也需要加锁执行，将会产生很多重复代码，由此采用AOP切面的方式，只需要通过注解的方式就能将方法进行加锁处理。自定义注解@InheritedString errorDesc() default "系统正常处理，请稍后提交";切面类实现@Aspect@Component@Autowiredtry {if (!lock) {
Redisson中的RHyperLogLog几个常用的使用场景及去重例子
最新发布
qq_40592590的博客
07-25 539
redis
Redis常见的数据类型及操作方式
weixin_74261199的博客
07-24 1143
9）令key对应的value值加step（value可以是整数，也可以是浮点数，step可以是负数）9）在指定的时间内（单位s）阻塞式等待一个列表的出现，如果有这个列表出现则删除，否则返回null。8）令key对应的value值加step（value必须是整数，step可以是负数）11）令key对应的value值减step（value必须是整数）10）令key对应的value值减1（value必须是整数）7）令key对应的value值加1（value必须是整数）2）如果不存在value，则设置这个键值对。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值