Redis知识点总结（一）

最新推荐文章于 2024-10-19 14:10:31 发布
最新推荐文章于 2024-10-19 14:10:31 发布
阅读量1.1k 收藏
点赞数
分类专栏： Redis 文章标签： redis 面试 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/More_speed/article/details/117249560
版权

文章目录

Redis简介

Redis是一个高性能键值对（key-value）的内存数据库，可以用作数据库、缓存、消息中间件等。它是一种NoSQL（not-only sql，泛指非关系型数据库）的数据库。

Redis为什么这么快？

  1. 完全基于内存，绝大部分请求是纯粹的内存操作，非常快速。
  2. 数据结构简单，对数据操作也简单，Redis中的数据结构是专门进行设计的；
  3. 采用单线程，避免了不必要的上下文切换和竞争条件，也不存在多进程或者多线程导致的切换而消耗 CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗；
  4. 使用多路I/O复用模型，非阻塞IO；

数据类型

string

  1. 介绍 ：string 数据结构是简单的 key-value 类型。虽然 Redis 是用 C 语言写的，但是 Redis 并没有使用 C 的字符串表示，而是自己构建了一种 简单动态字符串（simple dynamic string，SDS）。相比于 C 的原生字符串，Redis 的 SDS 不光可以保存文本数据还可以保存二进制数据，并且获取字符串长度复杂度为 O(1)（C 字符串为 O(N)）,除此之外,Redis 的 SDS API 是安全的，不会造成缓冲区溢出。
  2. 常用命令: set,get,strlen,exists,dect,incr,setex 等等。
  3. 应用场景 ：一般常用在需要计数的场景，比如用户的访问次数、热点文章的点赞转发数量等等。

普通字符串的基本操作:

127.0.0.1:6379> set key value #设置 key-value 类型的值
OK
127.0.0.1:6379> get key # 根据 key 获得对应的 value
"value"
127.0.0.1:6379> exists key  # 判断某个 key 是否存在
(integer) 1
127.0.0.1:6379> strlen key # 返回 key 所储存的字符串值的长度。
(integer) 5
127.0.0.1:6379> del key # 删除某个 key 对应的值
(integer) 1
127.0.0.1:6379> get key
(nil)

批量设置 :

127.0.0.1:6379> mset key1 value1 key2 value2 # 批量设置 key-value 类型的值
OK
127.0.0.1:6379> mget key1 key2 # 批量获取多个 key 对应的 value
1) "value1"
2) "value2"

计数器（字符串的内容为整数的时候可以使用）:

127.0.0.1:6379> set number 1
OK
127.0.0.1:6379> incr number # 将 key 中储存的数字值增一
(integer) 2
127.0.0.1:6379> get number
"2"
127.0.0.1:6379> decr number # 将 key 中储存的数字值减一
(integer) 1
127.0.0.1:6379> get number
"1"

过期：

127.0.0.1:6379> expire key  60 # 数据在 60s 后过期
(integer) 1
127.0.0.1:6379> setex key 60 value # 数据在 60s 后过期 (setex:[set] + [ex]pire)
OK
127.0.0.1:6379> ttl key # 查看数据还有多久过期
(integer) 56

list

  1. 介绍 ：list 即是 链表。链表是一种非常常见的数据结构，特点是易于数据元素的插入和删除并且且可以灵活调整链表长度，但是链表的随机访问困难。许多高级编程语言都内置了链表的实现比如 Java 中的 LinkedList，但是 C 语言并没有实现链表，所以 Redis 实现了自己的链表数据结构。Redis 的 list 的实现为一个 双向链表，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销。
  2. 常用命令: rpush,lpop,lpush,rpop,lrange、llen 等。
  3. 应用场景: 发布与订阅或者说消息队列、慢查询。

通过 rpush/lpop 实现队列：

127.0.0.1:6379> rpush myList value1 # 向 list 的头部（右边）添加元素
(integer) 1
127.0.0.1:6379> rpush myList value2 value3 # 向list的头部（最右边）添加多个元素
(integer) 3
127.0.0.1:6379> lpop myList # 将 list的尾部(最左边)元素取出
"value1"
127.0.0.1:6379> lrange myList 0 1 # 查看对应下标的list列表， 0 为 start,1为 end
1) "value2"
2) "value3"
127.0.0.1:6379> lrange myList 0 -1 # 查看列表中的所有元素，-1表示倒数第一
1) "value2"
2) "value3"

通过 rpush/rpop 实现栈：

127.0.0.1:6379> rpush myList2 value1 value2 value3
(integer) 3
127.0.0.1:6379> rpop myList2 # 将 list的头部(最右边)元素取出
"value3"

image-20210519164232930

通过 lrange 查看对应下标范围的列表元素：

127.0.0.1:6379> rpush myList value1 value2 value3
(integer) 3
127.0.0.1:6379> lrange myList 0 1 # 查看对应下标的list列表， 0 为 start,1为 end
1) "value1"
2) "value2"
127.0.0.1:6379> lrange myList 0 -1 # 查看列表中的所有元素，-1表示倒数第一
1) "value1"
2) "value2"
3) "value3"

通过 lrange 命令，你可以基于 list 实现分页查询，性能非常高！

通过 llen 查看链表长度：

127.0.0.1:6379> llen myList
(integer) 3

set

  1. 介绍 ： set 类似于 Java 中的 HashSet 。Redis 中的 set 类型是一种无序集合，集合中的元素没有先后顺序。当你需要存储一个列表数据，又不希望出现重复数据时，set 是一个很好的选择，并且 set 提供了判断某个成员是否在一个 set 集合内的重要接口，这个也是 list 所不能提供的。可以基于 set 轻易实现交集、并集、差集的操作。比如：你可以将一个用户所有的关注人存在一个集合中，将其所有粉丝存在一个集合。Redis 可以非常方便的实现如共同关注、共同粉丝、共同喜好等功能。这个过程也就是求交集的过程。
  2. 常用命令： sadd,spop,smembers,sismember,scard,sinterstore,sunion 等。
  3. 应用场景: 需要存放的数据不能重复以及需要获取多个数据源交集和并集等场景
127.0.0.1:6379> sadd mySet value1 value2 # 添加元素进去
(integer) 2
127.0.0.1:6379> sadd mySet value1 # 不允许有重复元素
(integer) 0
127.0.0.1:6379> smembers mySet # 查看 set 中所有的元素
1) "value1"
2) "value2"
127.0.0.1:6379> scard mySet # 查看 set 的长度
(integer) 2
127.0.0.1:6379> sismember mySet value1 # 检查某个元素是否存在set 中，只能接收单个元素
(integer) 1
127.0.0.1:6379> sadd mySet2 value2 value3
(integer) 2
127.0.0.1:6379> sinterstore mySet3 mySet mySet2 # 获取 mySet 和 mySet2 的交集并存放在 mySet3 中
(integer) 1
127.0.0.1:6379> smembers mySet3
1) "value2"

hash

  1. 介绍 ：hash 类似于 JDK1.8 前的 HashMap，内部实现也差不多(数组 + 链表)。不过，Redis 的 hash 做了更多优化。另外，hash 是一个 string 类型的 field 和 value 的映射表，特别适合用于存储对象，后续操作的时候，你可以直接仅仅修改这个对象中的某个字段的值。 比如我们可以 hash 数据结构来存储用户信息，商品信息等等。
  2. 常用命令： hset,hmset,hexists,hget,hgetall,hkeys,hvals 等。
  3. 应用场景: 系统中对象数据的存储。
127.0.0.1:6379> hset userInfoKey name "xiaowang" description "dev" age "22"
OK
127.0.0.1:6379> hexists userInfoKey name # 查看 key 对应的 value中指定的字段是否存在。
(integer) 1
127.0.0.1:6379> hget userInfoKey name # 获取存储在哈希表中指定字段的值。
"xiaowang"
127.0.0.1:6379> hget userInfoKey age
"22"
127.0.0.1:6379> hgetall userInfoKey # 获取在哈希表中指定 key 的所有字段和值
1) "name"
2) "xiaowang"
3) "description"
4) "dev"
5) "age"
6) "22"
127.0.0.1:6379> hkeys userInfoKey # 获取 key 列表
1) "name"
2) "description"
3) "age"
127.0.0.1:6379> hvals userInfoKey # 获取 value 列表
1) "xiaowang"
2) "dev"
3) "22"
127.0.0.1:6379> hset userInfoKey name "xiaoliang" # 修改某个字段对应的值
127.0.0.1:6379> hget userInfoKey name
"xiaoliang"

zset

  1. 介绍： 和 set 相比，zset 增加了一个权重参数 score，使得集合中的元素能够按 score 进行有序排列，还可以通过 score 的范围来获取元素的列表。有点像是 Java 中 HashMap 和 TreeSet 的结合体。
  2. 常用命令： zadd,zcard,zscore,zrange,zrevrange,zrem 等。
  3. 应用场景： 需要对数据根据某个权重进行排序的场景。比如在直播系统中，实时排行信息包含直播间在线用户列表，各种礼物排行榜，弹幕消息（可以理解为按消息维度的消息排行榜）等信息。
127.0.0.1:6379> zadd myZset 3.0 value1 # 添加元素到 sorted set 中 3.0 为权重
(integer) 1
127.0.0.1:6379> zadd myZset 2.0 value2 1.0 value3 # 一次添加多个元素
(integer) 2
127.0.0.1:6379> zcard myZset # 查看 zset 中的元素数量
(integer) 3
127.0.0.1:6379> zscore myZset value1 # 查看某个 value 的权重
"3"
127.0.0.1:6379> zrange  myZset 0 -1 # 顺序输出某个范围区间的元素，0 -1 表示输出所有元素
1) "value3"
2) "value2"
3) "value1"
127.0.0.1:6379> zrange  myZset 0 1 # 顺序输出某个范围区间的元素，0 为 start  1 为 stop
1) "value3"
2) "value2"
127.0.0.1:6379> zrevrange  myZset 0 1 # 逆序输出某个范围区间的元素，0 为 start  1 为 stop
1) "value1"
2) "value2"

数据结构

字典

dict是 Redis 服务器中出现最为频繁的复合型数据结构，除了 hash 结构的数据会用到字典外，整个 Redis 数据库的所有 key 和 value 也组成了一个全局字典，还有带过期时间的 key 集合也是一个字典。zset 集合中存储 value 和 score 值的映射关系也是通过 dict 结构实现的。

哈希表和哈希表节点
typedef struct dictht {
    //哈希表数组
    dictEntry **table;
    //哈希表大小
    unsigned long size;
    //哈希表大小掩码，用于计算索引值，总是等于size-1
    unsigned long sizemask;
    //哈希表已有节点数量
    unsigned long used;
} dictht;

typedef struct dictEntry {
    //键
    void *key;
    //值
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
    } v;
    //指向下一个哈希表节点，形成链表
    struct dictEntry *next;
} dictEntry;

next属性指向另一个哈希表节点的指针，这个指针可以将多个哈希值相同的键值对连接在一起，解决哈希冲突的问题。

字典
typedef struct dict {
    //类型特定函数
    dictType *type;
    //私有数据
    void *privdata;
    //两个哈希表
    dictht ht[2];
    //rehash索引，当rehash没进行的时候，值为-1
    long rehashidx; /* rehashing not in progress if rehashidx == -1 */
} dict;

type属性和privdata属性是针对不同类型的键值对，为创建多态字典而设置的:

  • type属性是一个指向dictType结构的指针，每个dictType结构保存了一簇用于操作特定类型键值对的函数，Redis 会为用途不同的字典设置不同的类型特定函数。
  • 而privdata属性则保存了需要传给那些类型特定函数的可选参数。

ht属性是一个包含两个项的数组，数组中的每个项都是一个dictht哈希表，一般情况下, 字典只使用ht[0]哈希表，ht[1]哈希表只会在对ht [0]哈希表进行rehash时使用。

和rehash有关的属性就是rehashidx，它记录了rehash目前的进度，如果目前没有在进行rehash,那么它的值为-1。

哈希算法

Redis计算哈希值和索引值的方法如下:

  1. 使用字典设置的哈希函数，计算键key的哈希值
    hash=dict->type->hashFunction (key) ;
  2. 使用哈希表的sizemask属性和哈希值，计算出索引值，根据情况不同，ht[x]可以是ht[0]或者ht[1]
    index = hash & dict->ht[x].sizemask;
rehash

哈希表的扩展和收缩都需要进行rehash操作，rehash的步骤如下：

  1. 为字典的ht[1]哈希表分配空间，这个哈希表的空间大小取决于要执行的操作，以及ht[0]当前包含的键值对数量(也即是ht[0].used属性的值):
    • 如果执行的是扩展操作，那么ht[1]的大小为第一个大于等于ht[0].used*2的2"(2的n次方幂);
    • 如果执行的是收缩操作，那么ht[1]的大小为第一个大于等于 ht[0].used的2"。
  2. 将保存在ht[0]中的所有键值对rehash到ht[1]上面: rehash指的是重新计算键的哈希值和索引值.然后将键值对放置到ht[1]哈希表的指定位置上。
  3. 当ht[0]包含的所有键值对都迁移到了ht[1]之后(ht[0]变为空表)，释放ht[0]，将ht[1]设置为ht[0],并在ht[1]新创建一个空白哈希表，为下一次rehash做准备。
渐进式rehash

大字典的扩容是比较耗时间的，需要重新申请新的数组，然后将旧字典所有链表中的元素重新挂接到新的数组下面，这是一个 O(n)级别的操作，作为单线程的 Redis 表示很难承受这样耗时的过程。步子迈大了会扯着蛋，所以 Redis 使用渐进式 rehash 小步搬迁。虽然慢一点，但是肯定可以搬完。

以下是哈希表渐进式rehash的详细步骤:

  1. 为ht[1]分配空间，让字典同时持有ht[0]和ht[1]两个哈希表。
  2. 在字典中维持一个索引计数器变量rehashidx,并将它的值设置为0,表示rehash工作正式开始。
  3. 在rehash进行期间，每次对字典执行添加、删除、查找或者更新操作时，程序除了执行指定的操作以外，还会顺带将ht[0]哈希表在rehashidx索引上的所有键值对rehash到ht[1],当rehash工作完成之后，程序将rehashidx属性的值增1。
  4. 随着字典操作的不断执行，最终在某个时间点上，ht[0]的所有键值对都会被rehash至ht[1],这时程序将rehashidx属性的值设为-1,表示rehash操作已完成。

因为在进行渐进式rehash的过程中，字典会同时使用ht[0]和ht[1]两个哈希表,所以在渐进式rehash进行期间，字典的删除( delete)、查找( find)、更新( update)等操作会在两个哈希表上进行。例如，要在字典里面查找一个键的话，程序会先在ht[0]里面进行查找，如果没找到的话，就会继续到ht[1]里面进行查找，诸如此类。
另外，在渐进式rehash执行期间,新添加到字典的键值对一律会被保存到ht[1]里面,而ht[0]则不再进行任何添加操作，这一措施保证了ht[0]包含的键值对数量会只减不增，并随着rehash操作的执行而最终变成空表。

跳表

Redis 的zset是一个复合结构，一方面它需要一个hash结构来存储 value 和 score 的 对应关系，另一方面需要提供按照 score 来排序的功能，还需要能够指定 score 的范围来获取 value 列表的功能，这就需要另外一个结构「跳跃列表」。zset的内部实现是一个hash字典加一个跳跃列表 (skiplist)。

基本结构

image-20210524161231576

上图就是跳跃列表的示意图，图中只画了四层，Redis 的跳跃表共有 64 层，意味着最 多可以容纳 2^64 次方个元素。每一个 kv 块对应的结构如下面的代码中的 zslnode 结构，kv header 也是这个结构，只不过 value 字段是 null 值——无效的，score 是 Double.MIN_VALUE，用来垫底的。kv 之间使用指针串起来形成了双向链表结构，它们是有序排列的，从小到大。不同的 kv 层高可能不一样，层数越高的 kv 越少。同一层的 kv 会使用指针串起来。每一个层元素的遍历都是从 kv header 出发。

struct zslnode {
    string value;
    double score;
    zslnode*[] forwards; // 多层连接指针
    zslnode* backward; // 回溯指针
}

struct zsl {
 	zslnode* header; // 跳跃列表头指针
 	int maxLevel; // 跳跃列表当前的最高层
 	map<string, zslnode*> ht; // hash 结构的所有键值对
}
查找过程

image-20210524162311224

如图所示，我们要定位到那个紫色的 kv，需要从 header 的最高层开始遍历找到第一个节点 (最后一个比「我」小的元素)，然后从这个节点开始降一层再遍历找到第二个节点 (最后一个比「我」小的元素)，然后一直降到最底层进行遍历就找到了期望的节点 (最底层的最后一个比我「小」的元素)。

我们将中间经过的一系列节点称之为「搜索路径」，它是从最高层一直到最底层的每一层最后一个比「我」小的元素节点列表。 有了这个搜索路径，我们就可以插入这个新节点了。不过这个插入过程也不是特别简单。因为新插入的节点到底有多少层，得有个算法来分配一下，跳跃列表使用的是随机算法。

随机层数

对于每一个新插入的节点，都需要调用一个随机算法给它分配一个合理的层数。直观上期望的目标是 50% 的 Level1，25% 的 Level2，12.5% 的 Level3，一直到最顶层 ，因为这里每一层的晋升概率是 50%。

int zslRandomLevel(void) {
 	int level = 1;
 	while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))
	level += 1;
	return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;
}

不过 Redis 标准源码中的晋升概率只有 25%，也就是代码中的 ZSKIPLIST_P的值。所以官方的跳跃列表更加的扁平化，层高相对较低，在单个层上需要遍历的节点数量会稍多一 点。

也正是因为层数一般不高，所以遍历的时候从顶层开始往下遍历会非常浪费。跳跃列表会记录一下当前的最高层数 maxLevel，遍历时从这个 maxLevel 开始遍历性能就会提高很多。

插入过程
zskiplistNode *zslInsert(zskiplist *zsl, double score, sds ele) {
    // 存储搜索路径
    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;
    // 存储经过的节点跨度
    unsigned int rank[ZSKIPLIST_MAXLEVEL];
 	int i, level;
    
 	serverAssert(!isnan(score));
 	x = zsl->header;
 	// 逐步降级寻找目标节点，得到「搜索路径」
 	for (i = zsl->level-1; i >= 0; i--) {
 		/* store rank that is crossed to reach the insert position */
 		rank[i] = i == (zsl->level-1) ? 0 : rank[i+1];
 		// 如果 score 相等，还需要比较 value
 		while (x->level[i].forward &&
 			(x->level[i].forward->score < score ||
 				(x->level[i].forward->score == score &&
 				sdscmp(x->level[i].forward->ele,ele) < 0)))
 		{
 			rank[i] += x->level[i].span;
 			x = x->level[i].forward;
 		}
 		update[i] = x;
 	}
    // 正式进入插入过程
    /* we assume the element is not already inside, since we allow duplicated
     * scores, reinserting the same element should never happen since the
     * caller of zslInsert() should test in the hash table if the element is
     * already inside or not. */
    // 随机一个层数
 	level = zslRandomLevel();
 	// 填充跨度
 	if (level > zsl->level) {
 		for (i = zsl->level; i < level; i++) {
 			rank[i] = 0;
 			update[i] = zsl->header;
 			update[i]->level[i].span = zsl->length;
 		}
 		// 更新跳跃列表的层高
 		zsl->level = level;
 	}
 	// 创建新节点
 	x = zslCreateNode(level,score,ele);
	// 重排一下前向指针
 	for (i = 0; i < level; i++) {
 		x->level[i].forward = update[i]->level[i].forward;
 		update[i]->level[i].forward = x;
 		/* update span covered by update[i] as x is inserted here */
		x->level[i].span = update[i]->level[i].span - (rank[0] - rank[i]);
 		update[i]->level[i].span = (rank[0] - rank[i]) + 1;
 	}
 	/* increment span for untouched levels */
 	for (i = level; i < zsl->level; i++) {
 		update[i]->level[i].span++;
 	}
 	// 重排一下后向指针
 	x->backward = (update[0] == zsl->header) ? NULL : update[0];
 	if (x->level[0].forward)
 		x->level[0].forward->backward = x;
 	else
 		zsl->tail = x;
 	zsl->length++;
 	return x;
}

首先我们在搜索合适插入点的过程中将「搜索路径」摸出来了，然后就可以开始创建新 节点了，创建的时候需要给这个节点随机分配一个层数，再将搜索路径上的节点和这个新节 点通过前向后向指针串起来。如果分配的新节点的高度高于当前跳跃列表的最大高度，就需 要更新一下跳跃列表的最大高度。

压缩列表

Redis 为了节约内存空间使用，zset 和 hash 容器对象在元素个数较少的时候，采用压缩列表 (ziplist) 进行存储。压缩列表是一块连续的内存空间，元素之间紧挨着存储，没有任何冗余空隙。

> zadd programmings 1.0 go 2.0 python 3.0 java
(integer) 3
> debug object programmings
Value at:0x7fec2de00020 refcount:1 encoding:ziplist serializedlength:36 lru:6022374 lru_seconds_idle:6
> hmset books go fast python slow java fast
OK
> debug object books
Value at:0x7fec2de000c0 refcount:1 encoding:ziplist serializedlength:48 lru:6022478 lru_seconds_idle:1

这里，注意观察 debug object 输出的 encoding 字段都是 ziplist，这就表示内部采用压缩列表结构进行存储。

ziplist结构
struct ziplist<T> {
   int32 zlbytes; // 整个压缩列表占用字节数
   int32 zltail_offset; // 最后一个元素距离压缩列表起始位置的偏移量，用于快速定位到最后一个节点
   int16 zllength; // 元素个数
   T[] entries; // 元素内容列表，挨个挨个紧凑存储
   int8 zlend; // 标志压缩列表的结束，值恒为 0xFF
}

image-20210525094621811

压缩列表为了支持双向遍历，所以才会有 zltail_offset 这个字段，用来快速定位到最后一个元素，然后倒着遍历。

entry结构
struct entry {
   int<var> prevlen; // 前一个 entry 的字节长度
   int<var> encoding; // 元素类型编码
   optional byte[] content; // 元素内容
}

prevlen 字段表示前一个 entry 的字节长度，当压缩列表倒着遍历时，需要通过这个字段来快速定位到下一个元素的位置。它是一个变长的整数，当字符串长度小于 254(0xFE) 时，使用一个字节表示；如果达到或超出 254(0xFE) 那就使用 5 个字节来表 示。第一个字节是 0xFE(254)，剩余四个字节表示字符串长度。

encoding字段存储了元素内容的编码类型信息，ziplist 通过这个字段来决定后面的 content 内容的形式。

content 字段在结构体中定义为 optional 类型，表示这个字段是可选的，对于很小的整数而言，它的内容已经内联到 encoding 字段的尾部了。

级联更新

每个 entry 都会有一个 prevlen 字段存储前一个 entry 的长度。如果内容小于 254 字节，prevlen 用 1 字节存储，否则就是 5 字节。这意味着如果某个 entry 经过了修改操作从 253 字节变成了 254 字节，那么它的下一个 entry 的 prevlen 字段就要更新，从 1 个字节扩展到 5 个字节；如果这个 entry 的长度本来也是 253 字节，那么后面 entry 的 prevlen 字段还得继续更新。如果 ziplist 里面每个 entry 恰好都存储了 253 字节的内容，那么第一个 entry 内容的 修改就会导致后续所有 entry 的级联更新，这就是一个比较耗费计算资源的操作。

小望没烦恼
关注
专栏目录
Redis知识点总结归纳
悟已往之不谏，知来者之可追
01-26 481
Redis Redis 一、概述 二、数据类型 STRING LIST SET HASH ZSET 三、数据结构 字典 跳跃表 四、使用场景 计数器 缓存 查找表 消息队列 会话缓存 分布式锁实现 其它 五、Redis 与 Memcached 数据类型 数据持久化 分布式 内存管理机制 六、键的过期时间 七、数据淘汰策略 八、持久化 RDB 持久化 AOF 持久化 九、事务 十、事件 文件事件 时间事件 事件的调度与执行 十一、复制 连接过程 主从链 十二、S
Redis知识点总结
weixin_49199646的博客
08-11 1336
一、什么是Redis redis是一个使用C语言编写的、基于内存的且可持久化的key-value数据库。 redis有以下特点： 1、性能高。 Redis 能读的速度是 110000 次/s,写的速度是 81000 次/s 。 2、数据结构丰富。Redis支持string、 list，set，zset，hash等数据结构的存储。 3、原子性。Redis的所有操作是支持原子性的，要么成功，要么失败。 4、持久化存储。Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候再次加载进行使用。 二、
Visual Studio内存泄漏调试
csyanbin的专栏
03-13 2400
在可能泄漏的文件头部加入下面几行（保证malloc和new的泄漏都可以检测到） #define _CRTDBG_MAP_ALLOC #include  #ifdef _DEBUG //重载new运算符 #define new  new(_NORMAL_BLOCK, __FILE__, __LINE__)   #endif   然后在程序中加入下面代码 程序
C++学习（一零零）WOW64
hankern的专栏
06-28 195
WOW64 (Windows-on-Windows 64-bit)是一个Windows操作系统的子系统, 它为现有的 32 位应用程序提供了 32 位的模拟，可以使大多数 32 位应用程序在无需修改的情况下运行在 Windows 64 位版本上。 WOW64 是在用户模式下实现的，作为 ntdll.dll 和内核之间的层。WOW64 及其支持的一些 DLL 仅仅是可以加载到 32 位进程中的 64 位的 DLL。对于所有其他情况，进程保持为纯进程。32 位的进程无法加载 64 位的 DLL，反之亦然。
java命令+eclipse.exe,我运行exe时Eclipse无法启动？
weixin_36143786的博客
03-09 955
我运行exe时Eclipse无法启动？当我在给定文件夹中运行Eclipse.exe时，它将无法启动。 Eclipse初始屏幕将显示一秒钟，然后关闭。 没有错误。我几乎已经尝试了一切。 更新JDK和JRE：我安装了JRE 7和JDK 1.7.0_40。 两者均为64位，并且都位于(x86)文件夹中。 我试过重新安装它们。 并重新下载Eclipse。 每次相同的结果。 我已经将虚拟机添加到配置中，仍然...
１６线激光雷达点云采集过程中遇到的问题
xiangzipeng的博客
01-12 512
１６线激光雷达点云采集过程中遇到的问题
02-Elaticsearch安装-Windows版
佳佳的博客
04-26 256
Elasticsearch安装（Windows版） 1. 准备Windows版安装包 注：这里我准备的是elasticsearch-7.6.1版本（官网地址下载速度很慢，可通过Elastic中文社区下载） 2. 将安装包解压到本地磁盘 bin 启动文件 config 配置文件 elasticsearch.yml elasticsearch的配置文件：默认9200端口 jvm.option...
Redis核心知识点总结
03-15
### Redis核心知识点总结 #### 一、Redis简介与特点 **定义**： - **Remote Dictionary Server**（简称Redis）是一款完全开源的、采用ANSI C语言编写的、遵循BSD许可协议的高性能Key-Value数据库系统。 - Redis...
Redis知识点重点总结
09-27
**Redis知识点重点总结** Redis，全称Remote Dictionary Server，是一个高性能的键值对存储系统，广泛应用于缓存、消息队列、数据持久化等多个场景。它以文本协议提供服务，支持多种数据结构，如字符串、哈希、列表...
redis数据类型及应用场景知识点总结
12-14
Redis是一种高性能的键值存储系统，它支持五种主要的数据类型：String、Hash、List、Set和Sorted Set。这些数据类型的设计使得Redis可以应用于多种场景，具有很高的灵活性和效率。 **1. String（字符串）** String...
kaggle_经验_Sim
ningyanggege的博客
06-08 696
I recently participated in the Kaggle-hosted data science competition How Much Did It Rain II where the goal was to predict a set of hourly rainfall levels from sequences of weather radar measurements...
Wow64 环境检测
songbei6的博客
03-31 1494
1、使用 IsWow64Process2 说明 Determines whether the specified process is running under WOW64; also returns additional machine process and architecture information. 语法 BOOL IsWow64Process2( HANDLE hProcess...
面试题总结
如沐春风
11-17 2603
HTML div水平垂直居中 1.给div的父级添加相对定位（position: relative),//可以不知道元素自身宽高 自己position: absolute;left:50%;top:50%;transform: translate(-50%, -50%); 2.给div的父级添加相对定位（position: relative), 自己position: absolute;top left right bottom 都设置0,margin: auto; 3.弹性盒主轴侧轴居中:di
问题签名: 问题事件名称: BEX64 及解决方案
热门推荐
pengdongneng的博客
03-23 12万+
这几天突然对*.exe文件右键失败，直接爆出重启资源管理器的消息框。而且问题居然还是“BEX64”…不理解。我的系统是win7 64位。错误代码在此：好吧，我直接帖我的解决方案：第一步，右键进入NVIDIA（英伟达）控制面板： 第二步，在菜单栏中取消勾选：“将用户图形处理器……下文菜单”。 好了，结果是： 解决成功！
windows终端事件日志监控指南
12306小哥
08-22 1万+
windows事件监控指南 推荐收集的活动日志 账户使用情况 收集和审核用户帐户信息。 跟踪本地帐户使用情况有助于安全分析人员检测传递哈希活动和其他未经授权的帐户使用情况。 还可以跟踪其他信息，例如远程桌面登录，添加到特权组的用户以及帐户锁定。 值得注意的是，你要特别关注那些被提升为特权组的用户帐户，以确保用户被提升到特权组的行为是正常的，经过内部审核的，而不是未授权的。 未经审核授权的特权组成员...
shell脚本部署redis,mysql,elasticsearch
最新发布
weixin_42934205的博客
10-19 211
这里用到的包为elasticsearch-6.8.0.tar.gz，elasticsearch-analysis-ik-6.8.0.zip ，elasticsearch-sql-6.8.0.0.zip，redis-5.0.4.zip，libaio-0.3.109-13.el7.x86_64.rpm，mysql-5.7.18-1.el7.x86_64.rpm-bundle.tar，net-tools-2.0-0.24.20131004git.el7.x86_64.rpm。
【Redis】Zset类型常用命令
m0_74105656的博客
10-16 997
Redis中zset有序集合常用命令总结
Redis 缓存预热，缓存雪崩，缓存击穿，缓存穿透
fada_da_da的博客
10-13 1543
缓存预热就是系统启动前，提前将相关的缓存数据直接加载到缓存系统。避免在用户请求的时候，先查询数据库，然后再将数据缓存的问题！用户直接查询事先被预热的缓存数据。
Redisson使用全解
猪猪
10-15 267
redisson使用全解——redisson官方文档+注释（上篇）_redisson官网中文-CSDN博客redisson使用全解——redisson官方文档+注释（中篇）-CSDN博客redisson使用全解——redisson官方文档+注释（下篇）_redisson官网中文-CSDN博客
Golang、MySQL与Redis面试必备知识点总结
本资源集合了面试中针对Go语言（Golang）、MySQL数据库和Redis缓存系统的一些常见知识点，旨在帮助面试者在面试过程中更好地展示自己的能力，同时也为技术面试官提供了一个参考标准。 首先，让我们从Go语言（Golang...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值