Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
wushizhenking
JavaGuide
提交
0de8ebb8
J
JavaGuide
项目概览
wushizhenking
/
JavaGuide
与 Fork 源项目一致
从无法访问的项目Fork
通知
2
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
J
JavaGuide
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
0de8ebb8
编写于
3月 22, 2020
作者:
S
shuang.kou
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
[feat] 添加redis系列文章合集
上级
2f2ca994
变更
10
展开全部
显示空白变更内容
内联
并排
Showing
10 changed file
with
1435 addition
and
4 deletion
+1435
-4
README.md
README.md
+11
-4
docs/database/Redis/redis-collection/Redis(1)——5种基本数据结构.md
docs/database/Redis/redis-collection/Redis(1)——5种基本数据结构.md
+0
-0
docs/database/Redis/redis-collection/Redis(2)——跳跃表.md
docs/database/Redis/redis-collection/Redis(2)——跳跃表.md
+392
-0
docs/database/Redis/redis-collection/Redis(3)——分布式锁深入探究.md
docs/database/Redis/redis-collection/Redis(3)——分布式锁深入探究.md
+228
-0
docs/database/Redis/redis-collection/Redis(5)——亿级数据过滤和布隆过滤器.md
...database/Redis/redis-collection/Redis(5)——亿级数据过滤和布隆过滤器.md
+361
-0
docs/database/Redis/redis-collection/Redis(6)——GeoHash查找附近的人.md
...atabase/Redis/redis-collection/Redis(6)——GeoHash查找附近的人.md
+228
-0
docs/database/Redis/redis-collection/Redis(7)——持久化.md
docs/database/Redis/redis-collection/Redis(7)——持久化.md
+215
-0
docs/database/Redis/redis-collection/Redis(8)——发布订阅与Stream.md
.../database/Redis/redis-collection/Redis(8)——发布订阅与Stream.md
+0
-0
docs/database/Redis/redis-collection/Redis(9)——集群入门实践教程.md
docs/database/Redis/redis-collection/Redis(9)——集群入门实践教程.md
+0
-0
docs/database/Redis/redis-collection/Reids(4)——神奇的HyperLoglog解决统计问题.md
.../Redis/redis-collection/Reids(4)——神奇的HyperLoglog解决统计问题.md
+0
-0
未找到文件。
README.md
浏览文件 @
0de8ebb8
...
...
@@ -191,10 +191,17 @@ Github用户如果访问速度缓慢的话,可以转移到[码云](https://git
### Redis
*
[
Redis 总结
](
docs/database/Redis/Redis.md
)
*
[
Redlock分布式锁
](
docs/database/Redis/Redlock分布式锁.md
)
*
[
如何做可靠的分布式锁,Redlock真的可行么
](
docs/database/Redis/如何做可靠的分布式锁,Redlock真的可行么.md
)
*
[
几种常见的 Redis 集群以及使用场景
](
docs/database/Redis/redis集群以及应用场景.md
)
*
[
Redis 常见问题总结
](
docs/database/Redis/Redis.md
)
*
**Redis 系列文章合集:**
1.
[
5种基本数据结构
](
docs/database/Redis/redis-collection/Redis(1
)
——5种基本数据结构.md)
2.
[
跳跃表
](
docs/database/Redis/redis-collection/Redis(2
)
——跳跃表.md)
3.
[
分布式锁深入探究
](
docs/database/Redis/redis-collection/Redis(3
)
——分布式锁深入探究.md) 、
[
Redlock分布式锁
](
docs/database/Redis/Redlock分布式锁.md
)
、
[
如何做可靠的分布式锁,Redlock真的可行么
](
docs/database/Redis/如何做可靠的分布式锁,Redlock真的可行么.md
)
4.
[
神奇的HyperLoglog解决统计问题
](
docs/database/Redis/redis-collection/Reids(4
)
——神奇的HyperLoglog解决统计问题.md)
5.
[
亿级数据过滤和布隆过滤器
](
docs/database/Redis/redis-collection/Redis(5
)
——亿级数据过滤和布隆过滤器.md)
6.
[
GeoHash查找附近的人
](
docs/database/Redis/redis-collection/Redis(6
)
——GeoHash查找附近的人.md)
7.
[
持久化
](
docs/database/Redis/redis-collection/Redis(7
)
——持久化.md)
8.
[
发布订阅与Stream
](
docs/database/Redis/redis-collection/Redis(8
)
——发布订阅与Stream.md)
9.
[
史上最强【集群】入门实践教程
](
docs/database/Redis/redis-collection/Redis(9
)
——集群入门实践教程.md)
## 系统设计
...
...
docs/database/Redis/redis-collection/Redis(1)——5种基本数据结构.md
0 → 100644
浏览文件 @
0de8ebb8
此差异已折叠。
点击以展开。
docs/database/Redis/redis-collection/Redis(2)——跳跃表.md
0 → 100644
浏览文件 @
0de8ebb8
> 授权转载自: https://github.com/wmyskxz/MoreThanJava#part3-redis
![](
https://upload-images.jianshu.io/upload_images/7896890-97a4ce9191464f62.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
# 一、跳跃表简介
跳跃表(skiplist)是一种随机化的数据结构,由
**William Pugh**
在论文
[
《Skip lists: a probabilistic alternative to balanced trees》
](
https://www.cl.cam.ac.uk/teaching/0506/Algorithms/skiplists.pdf
)
中提出,是一种可以于平衡树媲美的层次化链表结构——查找、删除、添加等操作都可以在对数期望时间下完成,以下是一个典型的跳跃表例子:
![](
https://upload-images.jianshu.io/upload_images/7896890-65a5b1a2849fb91c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
我们在上一篇中提到了 Redis 的五种基本结构中,有一个叫做
**有序列表 zset**
的数据结构,它类似于 Java 中的
**SortedSet**
和
**HashMap**
的结合体,一方面它是一个 set 保证了内部 value 的唯一性,另一方面又可以给每个 value 赋予一个排序的权重值 score,来达到
**排序**
的目的。
它的内部实现就依赖了一种叫做
**「跳跃列表」**
的数据结构。
## 为什么使用跳跃表
首先,因为 zset 要支持随机的插入和删除,所以它
**不宜使用数组来实现**
,关于排序问题,我们也很容易就想到
**红黑树/ 平衡树**
这样的树形结构,为什么 Redis 不使用这样一些结构呢?
1.
**性能考虑:**
在高并发的情况下,树形结构需要执行一些类似于 rebalance 这样的可能涉及整棵树的操作,相对来说跳跃表的变化只涉及局部 _(下面详细说)_;
2.
**实现考虑:**
在复杂度与红黑树相同的情况下,跳跃表实现起来更简单,看起来也更加直观;
基于以上的一些考虑,Redis 基于
**William Pugh**
的论文做出一些改进后采用了
**跳跃表**
这样的结构。
## 本质是解决查找问题
我们先来看一个普通的链表结构:
![](
https://upload-images.jianshu.io/upload_images/7896890-11b7eebde1779904.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
我们需要这个链表按照 score 值进行排序,这也就意味着,当我们需要添加新的元素时,我们需要定位到插入点,这样才可以继续保证链表是有序的,通常我们会使用
**二分查找法**
,但二分查找是有序数组的,链表没办法进行位置定位,我们除了遍历整个找到第一个比给定数据大的节点为止 _(时间复杂度 O(n))_ 似乎没有更好的办法。
但假如我们每相邻两个节点之间就增加一个指针,让指针指向下一个节点,如下图:
![](
https://upload-images.jianshu.io/upload_images/7896890-8cae2c261c950b32.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
这样所有新增的指针连成了一个新的链表,但它包含的数据却只有原来的一半 _(图中的为 3,11)_。
现在假设我们想要查找数据时,可以根据这条新的链表查找,如果碰到比待查找数据大的节点时,再回到原来的链表中进行查找,比如,我们想要查找 7,查找的路径则是沿着下图中标注出的红色指针所指向的方向进行的:
![](
https://upload-images.jianshu.io/upload_images/7896890-9c0262c7a85c120e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
这是一个略微极端的例子,但我们仍然可以看到,通过新增加的指针查找,我们不再需要与链表上的每一个节点逐一进行比较,这样改进之后需要比较的节点数大概只有原来的一半。
利用同样的方式,我们可以在新产生的链表上,继续为每两个相邻的节点增加一个指针,从而产生第三层链表:
![](
https://upload-images.jianshu.io/upload_images/7896890-22036e274bedaa5a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
在这个新的三层链表结构中,我们试着
**查找 13**
,那么沿着最上层链表首先比较的是 11,发现 11 比 13 小,于是我们就知道只需要到 11 后面继续查找,
**从而一下子跳过了 11 前面的所有节点。**
可以想象,当链表足够长,这样的多层链表结构可以帮助我们跳过很多下层节点,从而加快查找的效率。
## 更进一步的跳跃表
**跳跃表 skiplist**
就是受到这种多层链表结构的启发而设计出来的。按照上面生成链表的方式,上面每一层链表的节点个数,是下面一层的节点个数的一半,这样查找过程就非常类似于一个二分查找,使得查找的时间复杂度可以降低到 _O(logn)_。
但是,这种方法在插入数据的时候有很大的问题。新插入一个节点之后,就会打乱上下相邻两层链表上节点个数严格的 2:1 的对应关系。如果要维持这种对应关系,就必须把新插入的节点后面的所有节点 _(也包括新插入的节点)_ 重新进行调整,这会让时间复杂度重新蜕化成 _O(n)_。删除数据也有同样的问题。
**skiplist**
为了避免这一问题,它不要求上下相邻两层链表之间的节点个数有严格的对应关系,而是
**为每个节点随机出一个层数(level)**
。比如,一个节点随机出的层数是 3,那么就把它链入到第 1 层到第 3 层这三层链表中。为了表达清楚,下图展示了如何通过一步步的插入操作从而形成一个 skiplist 的过程:
![](
https://upload-images.jianshu.io/upload_images/7896890-1e0626c013de095e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
从上面的创建和插入的过程中可以看出,每一个节点的层数(level)是随机出来的,而且新插入一个节点并不会影响到其他节点的层数,因此,
**插入操作只需要修改节点前后的指针,而不需要对多个节点都进行调整**
,这就降低了插入操作的复杂度。
现在我们假设从我们刚才创建的这个结构中查找 23 这个不存在的数,那么查找路径会如下图:
![](
https://upload-images.jianshu.io/upload_images/7896890-a8f66d808e8a4d1e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
# 二、跳跃表的实现
Redis 中的跳跃表由
`server.h/zskiplistNode`
和
`server.h/zskiplist`
两个结构定义,前者为跳跃表节点,后者则保存了跳跃节点的相关信息,同之前的
`集合 list`
结构类似,其实只有
`zskiplistNode`
就可以实现了,但是引入后者是为了更加方便的操作:
```
c
/* ZSETs use a specialized version of Skiplists */
typedef
struct
zskiplistNode
{
// value
sds
ele
;
// 分值
double
score
;
// 后退指针
struct
zskiplistNode
*
backward
;
// 层
struct
zskiplistLevel
{
// 前进指针
struct
zskiplistNode
*
forward
;
// 跨度
unsigned
long
span
;
}
level
[];
}
zskiplistNode
;
typedef
struct
zskiplist
{
// 跳跃表头指针
struct
zskiplistNode
*
header
,
*
tail
;
// 表中节点的数量
unsigned
long
length
;
// 表中层数最大的节点的层数
int
level
;
}
zskiplist
;
```
正如文章开头画出来的那张标准的跳跃表那样。
## 随机层数
对于每一个新插入的节点,都需要调用一个随机算法给它分配一个合理的层数,源码在
`t_zset.c/zslRandomLevel(void)`
中被定义:
```
c
int
zslRandomLevel
(
void
)
{
int
level
=
1
;
while
((
random
()
&
0xFFFF
)
<
(
ZSKIPLIST_P
*
0xFFFF
))
level
+=
1
;
return
(
level
<
ZSKIPLIST_MAXLEVEL
)
?
level
:
ZSKIPLIST_MAXLEVEL
;
}
```
直观上期望的目标是 50% 的概率被分配到
`Level 1`
,25% 的概率被分配到
`Level 2`
,12.5% 的概率被分配到
`Level 3`
,以此类推...有 2
<sup>
-63
</sup>
的概率被分配到最顶层,因为这里每一层的晋升率都是 50%。
**Redis 跳跃表默认允许最大的层数是 32**
,被源码中
`ZSKIPLIST_MAXLEVEL`
定义,当
`Level[0]`
有 2
<sup>
64
</sup>
个元素时,才能达到 32 层,所以定义 32 完全够用了。
## 创建跳跃表
这个过程比较简单,在源码中的
`t_zset.c/zslCreate`
中被定义:
```
c
zskiplist
*
zslCreate
(
void
)
{
int
j
;
zskiplist
*
zsl
;
// 申请内存空间
zsl
=
zmalloc
(
sizeof
(
*
zsl
));
// 初始化层数为 1
zsl
->
level
=
1
;
// 初始化长度为 0
zsl
->
length
=
0
;
// 创建一个层数为 32,分数为 0,没有 value 值的跳跃表头节点
zsl
->
header
=
zslCreateNode
(
ZSKIPLIST_MAXLEVEL
,
0
,
NULL
);
// 跳跃表头节点初始化
for
(
j
=
0
;
j
<
ZSKIPLIST_MAXLEVEL
;
j
++
)
{
// 将跳跃表头节点的所有前进指针 forward 设置为 NULL
zsl
->
header
->
level
[
j
].
forward
=
NULL
;
// 将跳跃表头节点的所有跨度 span 设置为 0
zsl
->
header
->
level
[
j
].
span
=
0
;
}
// 跳跃表头节点的后退指针 backward 置为 NULL
zsl
->
header
->
backward
=
NULL
;
// 表头指向跳跃表尾节点的指针置为 NULL
zsl
->
tail
=
NULL
;
return
zsl
;
}
```
即执行完之后创建了如下结构的初始化跳跃表:
![](
https://upload-images.jianshu.io/upload_images/7896890-551660604afd1041.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
## 插入节点实现
这几乎是最重要的一段代码了,但总体思路也比较清晰简单,如果理解了上面所说的跳跃表的原理,那么很容易理清楚插入节点时发生的几个动作
*(几乎跟链表类似)*
:
1.
找到当前我需要插入的位置
*(其中包括相同 score 时的处理)*
;
2.
创建新节点,调整前后的指针指向,完成插入;
为了方便阅读,我把源码
`t_zset.c/zslInsert`
定义的插入函数拆成了几个部分
### 第一部分:声明需要存储的变量
```
c
// 存储搜索路径
zskiplistNode
*
update
[
ZSKIPLIST_MAXLEVEL
],
*
x
;
// 存储经过的节点跨度
unsigned
int
rank
[
ZSKIPLIST_MAXLEVEL
];
int
i
,
level
;
```
### 第二部分:搜索当前节点插入位置
```
c
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
;
}
```
**讨论:**
有一种极端的情况,就是跳跃表中的所有 score 值都是一样,zset 的查找性能会不会退化为 O(n) 呢?
从上面的源码中我们可以发现 zset 的排序元素不只是看 score 值,也会比较 value 值
*(字符串比较)*
### 第三部分:生成插入节点
```
c
/* 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
();
// 如果随机生成的 level 超过了当前最大 level 需要更新跳跃表的信息
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
);
```
### 第四部分:重排前向指针
```
c
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
++
;
}
```
### 第五部分:重排后向指针并返回
```
c
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
;
```
## 节点删除实现
删除过程由源码中的
`t_zset.c/zslDeleteNode`
定义,和插入过程类似,都需要先把这个
**"搜索路径"**
找出来,然后对于每个层的相关节点重排一下前向后向指针,同时还要注意更新一下最高层数
`maxLevel`
,直接放源码
*(如果理解了插入这里还是很容易理解的)*
:
```
c
/* Internal function used by zslDelete, zslDeleteByScore and zslDeleteByRank */
void
zslDeleteNode
(
zskiplist
*
zsl
,
zskiplistNode
*
x
,
zskiplistNode
**
update
)
{
int
i
;
for
(
i
=
0
;
i
<
zsl
->
level
;
i
++
)
{
if
(
update
[
i
]
->
level
[
i
].
forward
==
x
)
{
update
[
i
]
->
level
[
i
].
span
+=
x
->
level
[
i
].
span
-
1
;
update
[
i
]
->
level
[
i
].
forward
=
x
->
level
[
i
].
forward
;
}
else
{
update
[
i
]
->
level
[
i
].
span
-=
1
;
}
}
if
(
x
->
level
[
0
].
forward
)
{
x
->
level
[
0
].
forward
->
backward
=
x
->
backward
;
}
else
{
zsl
->
tail
=
x
->
backward
;
}
while
(
zsl
->
level
>
1
&&
zsl
->
header
->
level
[
zsl
->
level
-
1
].
forward
==
NULL
)
zsl
->
level
--
;
zsl
->
length
--
;
}
/* Delete an element with matching score/element from the skiplist.
* The function returns 1 if the node was found and deleted, otherwise
* 0 is returned.
*
* If 'node' is NULL the deleted node is freed by zslFreeNode(), otherwise
* it is not freed (but just unlinked) and *node is set to the node pointer,
* so that it is possible for the caller to reuse the node (including the
* referenced SDS string at node->ele). */
int
zslDelete
(
zskiplist
*
zsl
,
double
score
,
sds
ele
,
zskiplistNode
**
node
)
{
zskiplistNode
*
update
[
ZSKIPLIST_MAXLEVEL
],
*
x
;
int
i
;
x
=
zsl
->
header
;
for
(
i
=
zsl
->
level
-
1
;
i
>=
0
;
i
--
)
{
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
)))
{
x
=
x
->
level
[
i
].
forward
;
}
update
[
i
]
=
x
;
}
/* We may have multiple elements with the same score, what we need
* is to find the element with both the right score and object. */
x
=
x
->
level
[
0
].
forward
;
if
(
x
&&
score
==
x
->
score
&&
sdscmp
(
x
->
ele
,
ele
)
==
0
)
{
zslDeleteNode
(
zsl
,
x
,
update
);
if
(
!
node
)
zslFreeNode
(
x
);
else
*
node
=
x
;
return
1
;
}
return
0
;
/* not found */
}
```
## 节点更新实现
当我们调用
`ZADD`
方法时,如果对应的 value 不存在,那就是插入过程,如果这个 value 已经存在,只是调整一下 score 的值,那就需要走一个更新流程。
假设这个新的 score 值并不会带来排序上的变化,那么就不需要调整位置,直接修改元素的 score 值就可以了,但是如果排序位置改变了,那就需要调整位置,该如何调整呢?
从源码
`t_zset.c/zsetAdd`
函数
`1350`
行左右可以看到,Redis 采用了一个非常简单的策略:
```
c
/* Remove and re-insert when score changed. */
if
(
score
!=
curscore
)
{
zobj
->
ptr
=
zzlDelete
(
zobj
->
ptr
,
eptr
);
zobj
->
ptr
=
zzlInsert
(
zobj
->
ptr
,
ele
,
score
);
*
flags
|=
ZADD_UPDATED
;
}
```
**把这个元素删除再插入这个**
,需要经过两次路径搜索,从这一点上来看,Redis 的
`ZADD`
代码似乎还有进一步优化的空间。
## 元素排名的实现
跳跃表本身是有序的,Redis 在 skiplist 的 forward 指针上进行了优化,给每一个 forward 指针都增加了
`span`
属性,用来
**表示从前一个节点沿着当前层的 forward 指针跳到当前这个节点中间会跳过多少个节点**
。在上面的源码中我们也可以看到 Redis 在插入、删除操作时都会小心翼翼地更新
`span`
值的大小。
所以,沿着
**"搜索路径"**
,把所有经过节点的跨度
`span`
值进行累加就可以算出当前元素的最终 rank 值了:
```
c
/* Find the rank for an element by both score and key.
* Returns 0 when the element cannot be found, rank otherwise.
* Note that the rank is 1-based due to the span of zsl->header to the
* first element. */
unsigned
long
zslGetRank
(
zskiplist
*
zsl
,
double
score
,
sds
ele
)
{
zskiplistNode
*
x
;
unsigned
long
rank
=
0
;
int
i
;
x
=
zsl
->
header
;
for
(
i
=
zsl
->
level
-
1
;
i
>=
0
;
i
--
)
{
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
)))
{
// span 累加
rank
+=
x
->
level
[
i
].
span
;
x
=
x
->
level
[
i
].
forward
;
}
/* x might be equal to zsl->header, so test if obj is non-NULL */
if
(
x
->
ele
&&
sdscmp
(
x
->
ele
,
ele
)
==
0
)
{
return
rank
;
}
}
return
0
;
}
```
# 扩展阅读
1.
跳跃表 Skip List 的原理和实现(Java) -
[
https://blog.csdn.net/DERRANTCM/article/details/79063312
](
https://blog.csdn.net/DERRANTCM/article/details/79063312
)
2.
【算法导论33】跳跃表(Skip list)原理与java实现 -
[
https://blog.csdn.net/brillianteagle/article/details/52206261
](
https://blog.csdn.net/brillianteagle/article/details/52206261
)
# 参考资料
1.
《Redis 设计与实现》 -
[
http://redisbook.com/
](
http://redisbook.com/
)
2.
【官方文档】Redis 数据类型介绍 -
[
http://www.redis.cn/topics/data-types-intro.html
](
http://www.redis.cn/topics/data-types-intro.html
)
3.
《Redis 深度历险》 -
[
https://book.douban.com/subject/30386804/
](
https://book.douban.com/subject/30386804/
)
4.
Redis 源码 -
[
https://github.com/antirez/redis
](
https://github.com/antirez/redis
)
5.
Redis 快速入门 - 易百教程 -
[
https://www.yiibai.com/redis/redis_quick_guide.html
](
https://www.yiibai.com/redis/redis_quick_guide.html
)
6.
Redis【入门】就这一篇! -
[
https://www.wmyskxz.com/2018/05/31/redis-ru-men-jiu-zhe-yi-pian/
](
https://www.wmyskxz.com/2018/05/31/redis-ru-men-jiu-zhe-yi-pian/
)
7.
Redis为什么用跳表而不用平衡树? -
[
https://mp.weixin.qq.com/s?__biz=MzA4NTg1MjM0Mg==&mid=2657261425&idx=1&sn=d840079ea35875a8c8e02d9b3e44cf95&scene=21#wechat_redirect
](
https://mp.weixin.qq.com/s?__biz=MzA4NTg1MjM0Mg==&mid=2657261425&idx=1&sn=d840079ea35875a8c8e02d9b3e44cf95&scene=21#wechat_redirect
)
8.
为啥 redis 使用跳表(skiplist)而不是使用 red-black? - 知乎@于康 -
[
https://www.zhihu.com/question/20202931
](
https://www.zhihu.com/question/20202931
)
docs/database/Redis/redis-collection/Redis(3)——分布式锁深入探究.md
0 → 100644
浏览文件 @
0de8ebb8
> 授权转载自: https://github.com/wmyskxz/MoreThanJava#part3-redis
![](
https://upload-images.jianshu.io/upload_images/7896890-5fe2adf61ccf11aa.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
# 一、分布式锁简介
**锁**
是一种用来解决多个执行线程
**访问共享资源**
错误或数据不一致问题的工具。
如果
*把一台服务器比作一个房子*
,那么
*线程就好比里面的住户*
,当他们想要共同访问一个共享资源,例如厕所的时候,如果厕所门上没有锁...更甚者厕所没装门...这是会出原则性的问题的..
![](
https://upload-images.jianshu.io/upload_images/7896890-26a364bddb9218eb.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
装上了锁,大家用起来就安心多了,本质也就是
**同一时间只允许一个住户使用**
。
而随着互联网世界的发展,单体应用已经越来越无法满足复杂互联网的高并发需求,转而慢慢朝着分布式方向发展,慢慢进化成了
**更大一些的住户**
。所以同样,我们需要引入分布式锁来解决分布式应用之间访问共享资源的并发问题。
## 为何需要分布式锁
一般情况下,我们使用分布式锁主要有两个场景:
1.
**避免不同节点重复相同的工作**
:比如用户执行了某个操作有可能不同节点会发送多封邮件;
2.
**避免破坏数据的正确性**
:如果两个节点在同一条数据上同时进行操作,可能会造成数据错误或不一致的情况出现;
## Java 中实现的常见方式
上面我们用简单的比喻说明了锁的本质:
**同一时间只允许一个用户操作**
。所以理论上,能够满足这个需求的工具我们都能够使用
*(就是其他应用能帮我们加锁的)*
:
1.
**基于 MySQL 中的锁**
:MySQL 本身有自带的悲观锁
`for update`
关键字,也可以自己实现悲观/乐观锁来达到目的;
2.
**基于 Zookeeper 有序节点**
:Zookeeper 允许临时创建有序的子节点,这样客户端获取节点列表时,就能够当前子节点列表中的序号判断是否能够获得锁;
3.
**基于 Redis 的单线程**
:由于 Redis 是单线程,所以命令会以串行的方式执行,并且本身提供了像
`SETNX(set if not exists)`
这样的指令,本身具有互斥性;
每个方案都有各自的优缺点,例如 MySQL 虽然直观理解容易,但是实现起来却需要额外考虑
**锁超时**
、
**加事务**
等,并且性能局限于数据库,诸如此类我们在此不作讨论,重点关注 Redis。
## Redis 分布式锁的问题
### 1)锁超时
假设现在我们有两台平行的服务 A B,其中 A 服务在
**获取锁之后**
由于未知神秘力量突然
**挂了**
,那么 B 服务就永远无法获取到锁了:
![](
https://upload-images.jianshu.io/upload_images/7896890-4ea386c23ef0eec9.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
所以我们需要额外设置一个超时时间,来保证服务的可用性。
但是另一个问题随即而来:
**如果在加锁和释放锁之间的逻辑执行得太长,以至于超出了锁的超时限制**
,也会出现问题。因为这时候第一个线程持有锁过期了,而临界区的逻辑还没有执行完,与此同时第二个线程就提前拥有了这把锁,导致临界区的代码不能得到严格的串行执行。
为了避免这个问题,
**Redis 分布式锁不要用于较长时间的任务**
。如果真的偶尔出现了问题,造成的数据小错乱可能就需要人工的干预。
有一个稍微安全一点的方案是
**将锁的 `value` 值设置为一个随机数**
,释放锁时先匹配随机数是否一致,然后再删除 key,这是为了
**确保当前线程占有的锁不会被其他线程释放**
,除非这个锁是因为过期了而被服务器自动释放的。
但是匹配
`value`
和删除
`key`
在 Redis 中并不是一个原子性的操作,也没有类似保证原子性的指令,所以可能需要使用像 Lua 这样的脚本来处理了,因为 Lua 脚本可以
**保证多个指令的原子性执行**
。
### 延伸的讨论:GC 可能引发的安全问题
[
Martin Kleppmann
](
https://martin.kleppmann.com/
)
曾与 Redis 之父 Antirez 就 Redis 实现分布式锁的安全性问题进行过深入的讨论,其中有一个问题就涉及到
**GC**
。
熟悉 Java 的同学肯定对 GC 不陌生,在 GC 的时候会发生
**STW(Stop-The-World)**
,这本身是为了保障垃圾回收器的正常执行,但可能会引发如下的问题:
![](
https://upload-images.jianshu.io/upload_images/7896890-cf3a403968a23be4.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
服务 A 获取了锁并设置了超时时间,但是服务 A 出现了 STW 且时间较长,导致了分布式锁进行了超时释放,在这个期间服务 B 获取到了锁,待服务 A STW 结束之后又恢复了锁,这就导致了
**服务 A 和服务 B 同时获取到了锁**
,这个时候分布式锁就不安全了。
不仅仅局限于 Redis,Zookeeper 和 MySQL 有同样的问题。
想吃更多瓜的童鞋,可以访问下列网站看看 Redis 之父 Antirez 怎么说:
[
http://antirez.com/news/101
](
http://antirez.com/news/101
)
### 2)单点/多点问题
如果 Redis 采用单机部署模式,那就意味着当 Redis 故障了,就会导致整个服务不可用。
而如果采用主从模式部署,我们想象一个这样的场景:
*服务 A*
申请到一把锁之后,如果作为主机的 Redis 宕机了,那么
*服务 B*
在申请锁的时候就会从从机那里获取到这把锁,为了解决这个问题,Redis 作者提出了一种
**RedLock 红锁**
的算法
*(Redission 同 Jedis)*
:
```
java
// 三个 Redis 集群
RLock
lock1
=
redissionInstance1
.
getLock
(
"lock1"
);
RLock
lock2
=
redissionInstance2
.
getLock
(
"lock2"
);
RLock
lock3
=
redissionInstance3
.
getLock
(
"lock3"
);
RedissionRedLock
lock
=
new
RedissionLock
(
lock1
,
lock2
,
lock2
);
lock
.
lock
();
// do something....
lock
.
unlock
();
```
# 二、Redis 分布式锁的实现
分布式锁类似于 "占坑",而
`SETNX(SET if Not eXists)`
指令就是这样的一个操作,只允许被一个客户端占有,我们来看看
**源码(t_string.c/setGenericCommand)**
吧:
```
c
// SET/ SETEX/ SETTEX/ SETNX 最底层实现
void
setGenericCommand
(
client
*
c
,
int
flags
,
robj
*
key
,
robj
*
val
,
robj
*
expire
,
int
unit
,
robj
*
ok_reply
,
robj
*
abort_reply
)
{
long
long
milliseconds
=
0
;
/* initialized to avoid any harmness warning */
// 如果定义了 key 的过期时间则保存到上面定义的变量中
// 如果过期时间设置错误则返回错误信息
if
(
expire
)
{
if
(
getLongLongFromObjectOrReply
(
c
,
expire
,
&
milliseconds
,
NULL
)
!=
C_OK
)
return
;
if
(
milliseconds
<=
0
)
{
addReplyErrorFormat
(
c
,
"invalid expire time in %s"
,
c
->
cmd
->
name
);
return
;
}
if
(
unit
==
UNIT_SECONDS
)
milliseconds
*=
1000
;
}
// lookupKeyWrite 函数是为执行写操作而取出 key 的值对象
// 这里的判断条件是:
// 1.如果设置了 NX(不存在),并且在数据库中找到了 key 值
// 2.或者设置了 XX(存在),并且在数据库中没有找到该 key
// => 那么回复 abort_reply 给客户端
if
((
flags
&
OBJ_SET_NX
&&
lookupKeyWrite
(
c
->
db
,
key
)
!=
NULL
)
||
(
flags
&
OBJ_SET_XX
&&
lookupKeyWrite
(
c
->
db
,
key
)
==
NULL
))
{
addReply
(
c
,
abort_reply
?
abort_reply
:
shared
.
null
[
c
->
resp
]);
return
;
}
// 在当前的数据库中设置键为 key 值为 value 的数据
genericSetKey
(
c
->
db
,
key
,
val
,
flags
&
OBJ_SET_KEEPTTL
);
// 服务器每修改一个 key 后都会修改 dirty 值
server
.
dirty
++
;
if
(
expire
)
setExpire
(
c
,
c
->
db
,
key
,
mstime
()
+
milliseconds
);
notifyKeyspaceEvent
(
NOTIFY_STRING
,
"set"
,
key
,
c
->
db
->
id
);
if
(
expire
)
notifyKeyspaceEvent
(
NOTIFY_GENERIC
,
"expire"
,
key
,
c
->
db
->
id
);
addReply
(
c
,
ok_reply
?
ok_reply
:
shared
.
ok
);
}
```
就像上面介绍的那样,其实在之前版本的 Redis 中,由于
`SETNX`
和
`EXPIRE`
并不是
**原子指令**
,所以在一起执行会出现问题。
也许你会想到使用 Redis 事务来解决,但在这里不行,因为
`EXPIRE`
命令依赖于
`SETNX`
的执行结果,而事务中没有
`if-else`
的分支逻辑,如果
`SETNX`
没有抢到锁,
`EXPIRE`
就不应该执行。
为了解决这个疑难问题,Redis 开源社区涌现了许多分布式锁的 library,为了治理这个乱象,后来在 Redis 2.8 的版本中,加入了
`SET`
指令的扩展参数,使得
`SETNX`
可以和
`EXPIRE`
指令一起执行了:
```
console
>
SET lock:test
true
ex 5 nx
OK
... do something critical ...
>
del lock:test
```
你只需要符合
`SET key value [EX seconds | PX milliseconds] [NX | XX] [KEEPTTL]`
这样的格式就好了,你也在下方右拐参照官方的文档:
-
官方文档:
[
https://redis.io/commands/set
](
https://redis.io/commands/set
)
另外,官方文档也在
[
`SETNX` 文档
](
https://redis.io/commands/setnx
)
中提到了这样一种思路:
**把 SETNX 对应 key 的 value 设置为 <current Unix time + lock timeout + 1>**
,这样在其他客户端访问时就能够自己判断是否能够获取下一个 value 为上述格式的锁了。
## 代码实现
下面用 Jedis 来模拟实现以下,关键代码如下:
```
java
private
static
final
String
LOCK_SUCCESS
=
"OK"
;
private
static
final
Long
RELEASE_SUCCESS
=
1L
;
private
static
final
String
SET_IF_NOT_EXIST
=
"NX"
;
private
static
final
String
SET_WITH_EXPIRE_TIME
=
"PX"
;
@Override
public
String
acquire
()
{
try
{
// 获取锁的超时时间,超过这个时间则放弃获取锁
long
end
=
System
.
currentTimeMillis
()
+
acquireTimeout
;
// 随机生成一个 value
String
requireToken
=
UUID
.
randomUUID
().
toString
();
while
(
System
.
currentTimeMillis
()
<
end
)
{
String
result
=
jedis
.
set
(
lockKey
,
requireToken
,
SET_IF_NOT_EXIST
,
SET_WITH_EXPIRE_TIME
,
expireTime
);
if
(
LOCK_SUCCESS
.
equals
(
result
))
{
return
requireToken
;
}
try
{
Thread
.
sleep
(
100
);
}
catch
(
InterruptedException
e
)
{
Thread
.
currentThread
().
interrupt
();
}
}
}
catch
(
Exception
e
)
{
log
.
error
(
"acquire lock due to error"
,
e
);
}
return
null
;
}
@Override
public
boolean
release
(
String
identify
)
{
if
(
identify
==
null
)
{
return
false
;
}
String
script
=
"if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end"
;
Object
result
=
new
Object
();
try
{
result
=
jedis
.
eval
(
script
,
Collections
.
singletonList
(
lockKey
),
Collections
.
singletonList
(
identify
));
if
(
RELEASE_SUCCESS
.
equals
(
result
))
{
log
.
info
(
"release lock success, requestToken:{}"
,
identify
);
return
true
;
}
}
catch
(
Exception
e
)
{
log
.
error
(
"release lock due to error"
,
e
);
}
finally
{
if
(
jedis
!=
null
)
{
jedis
.
close
();
}
}
log
.
info
(
"release lock failed, requestToken:{}, result:{}"
,
identify
,
result
);
return
false
;
}
```
-
引用自下方
*参考资料 3*
,其中还有 RedLock 的实现和测试,有兴趣的童鞋可以戳一下
# 推荐阅读
1.
【官方文档】Distributed locks with Redis -
[
https://redis.io/topics/distlock
](
https://redis.io/topics/distlock
)
2.
Redis【入门】就这一篇! -
[
https://www.wmyskxz.com/2018/05/31/redis-ru-men-jiu-zhe-yi-pian/
](
https://www.wmyskxz.com/2018/05/31/redis-ru-men-jiu-zhe-yi-pian/
)
3.
Redission - Redis Java Client 源码 -
[
https://github.com/redisson/redisson
](
https://github.com/redisson/redisson
)
4.
手写一个 Jedis 以及 JedisPool -
[
https://juejin.im/post/5e5101c46fb9a07cab3a953a
](
https://juejin.im/post/5e5101c46fb9a07cab3a953a
)
# 参考资料
1.
再有人问你分布式锁,这篇文章扔给他 -
[
https://juejin.im/post/5bbb0d8df265da0abd3533a5#heading-0
](
https://juejin.im/post/5bbb0d8df265da0abd3533a5#heading-0
)
2.
【官方文档】Distributed locks with Redis -
[
https://redis.io/topics/distlock
](
https://redis.io/topics/distlock
)
3.
【分布式缓存系列】Redis实现分布式锁的正确姿势 -
[
https://www.cnblogs.com/zhili/p/redisdistributelock.html
](
https://www.cnblogs.com/zhili/p/redisdistributelock.html
)
4.
Redis源码剖析和注释(九)--- 字符串命令的实现(t_string) -
[
https://blog.csdn.net/men_wen/article/details/70325566
](
https://blog.csdn.net/men_wen/article/details/70325566
)
5.
《Redis 深度历险》 - 钱文品/ 著
docs/database/Redis/redis-collection/Redis(5)——亿级数据过滤和布隆过滤器.md
0 → 100644
浏览文件 @
0de8ebb8
> 授权转载自: https://github.com/wmyskxz/MoreThanJava#part3-redis
![](
https://upload-images.jianshu.io/upload_images/7896890-59d043fad3a66d7f.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
# 一、布隆过滤器简介
[
上一次
](
https://www.wmyskxz.com/2020/03/02/reids-4-shen-qi-de-hyperloglog-jie-jue-tong-ji-wen-ti/
)
我们学会了使用
**HyperLogLog**
来对大数据进行一个估算,它非常有价值,可以解决很多精确度不高的统计需求。但是如果我们想知道某一个值是不是已经在
**HyperLogLog**
结构里面了,它就无能为力了,它只提供了
`pfadd`
和
`pfcount`
方法,没有提供类似于
`contains`
的这种方法。
就举一个场景吧,比如你
**刷抖音**
:
![](
https://upload-images.jianshu.io/upload_images/7896890-c7b6b5c8a47caf4a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
你有
**刷到过重复的推荐内容**
吗?这么多的推荐内容要推荐给这么多的用户,它是怎么保证每个用户在看推荐内容时,保证不会出现之前已经看过的推荐视频呢?也就是说,抖音是如何实现
**推送去重**
的呢?
你会想到服务器
**记录**
了用户看过的
**所有历史记录**
,当推荐系统推荐短视频时会从每个用户的历史记录里进行
**筛选**
,过滤掉那些已经存在的记录。问题是当
**用户量很大**
,每个用户看过的短视频又很多的情况下,这种方式,推荐系统的去重工作
**在性能上跟的上么?**
实际上,如果历史记录存储在关系数据库里,去重就需要频繁地对数据库进行
`exists`
查询,当系统并发量很高时,数据库是很难抗住压力的。
![
image
](
https://upload-images.jianshu.io/upload_images/7896890-099f3600b7022ef6.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
你可能又想到了
**缓存**
,但是这么多用户这么多的历史记录,如果全部缓存起来,那得需要
**浪费多大的空间**
啊..
*(可能老板看一眼账单,看一眼你..)*
并且这个存储空间会随着时间呈线性增长,就算你用缓存撑得住一个月,但是又能继续撑多久呢?不缓存性能又跟不上,咋办呢?
![](
https://upload-images.jianshu.io/upload_images/7896890-204e7440395a31b5.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
如上图所示,
**布隆过滤器(Bloom Filter)**
就是这样一种专门用来解决去重问题的高级数据结构。但是跟
**HyperLogLog**
一样,它也一样有那么一点点不精确,也存在一定的误判概率,但它能在解决去重的同时,在
**空间上能节省 90%**
以上,也是非常值得的。
## 布隆过滤器是什么
**布隆过滤器(Bloom Filter)**
是 1970 年由布隆提出的。它
**实际上**
是一个很长的二进制向量和一系列随机映射函数
*(下面详细说)*
,实际上你也可以把它
**简单理解**
为一个不怎么精确的
**set**
结构,当你使用它的
`contains`
方法判断某个对象是否存在时,它可能会误判。但是布隆过滤器也不是特别不精确,只要参数设置的合理,它的精确度可以控制的相对足够精确,只会有小小的误判概率。
当布隆过滤器说某个值存在时,这个值
**可能不存在**
;当它说不存在时,那么
**一定不存在**
。打个比方,当它说不认识你时,那就是真的不认识,但是当它说认识你的时候,可能是因为你长得像它认识的另外一个朋友
*(脸长得有些相似)*
,所以误判认识你。
![
image
](
https://upload-images.jianshu.io/upload_images/7896890-757891d52045869d.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
## 布隆过滤器的使用场景
基于上述的功能,我们大致可以把布隆过滤器用于以下的场景之中:
-
**大数据判断是否存在**
:这就可以实现出上述的去重功能,如果你的服务器内存足够大的话,那么使用 HashMap 可能是一个不错的解决方案,理论上时间复杂度可以达到 O(1 的级别,但是当数据量起来之后,还是只能考虑布隆过滤器。
-
**解决缓存穿透**
:我们经常会把一些热点数据放在 Redis 中当作缓存,例如产品详情。 通常一个请求过来之后我们会先查询缓存,而不用直接读取数据库,这是提升性能最简单也是最普遍的做法,但是
**如果一直请求一个不存在的缓存**
,那么此时一定不存在缓存,那就会有
**大量请求直接打到数据库**
上,造成
**缓存穿透**
,布隆过滤器也可以用来解决此类问题。
-
**爬虫/ 邮箱等系统的过滤**
:平时不知道你有没有注意到有一些正常的邮件也会被放进垃圾邮件目录中,这就是使用布隆过滤器
**误判**
导致的。
# 二、布隆过滤器原理解析
布隆过滤器
**本质上**
是由长度为
`m`
的位向量或位列表(仅包含
`0`
或
`1`
位值的列表)组成,最初所有的值均设置为
`0`
,所以我们先来创建一个稍微长一些的位向量用作展示:
![](
https://upload-images.jianshu.io/upload_images/7896890-362a693c82af3c8e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
当我们向布隆过滤器中添加数据时,会使用
**多个**
`hash`
函数对
`key`
进行运算,算得一个证书索引值,然后对位数组长度进行取模运算得到一个位置,每个
`hash`
函数都会算得一个不同的位置。再把位数组的这几个位置都置为
`1`
就完成了
`add`
操作,例如,我们添加一个
`wmyskxz`
:
![](
https://upload-images.jianshu.io/upload_images/7896890-fdbf75a56fb03c02.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
向布隆过滤器查查询
`key`
是否存在时,跟
`add`
操作一样,会把这个
`key`
通过相同的多个
`hash`
函数进行运算,查看
**对应的位置**
是否
**都**
为
`1`
,
**只要有一个位为 `0`**
,那么说明布隆过滤器中这个
`key`
不存在。如果这几个位置都是
`1`
,并不能说明这个
`key`
一定存在,只能说极有可能存在,因为这些位置的
`1`
可能是因为其他的
`key`
存在导致的。
就比如我们在
`add`
了一定的数据之后,查询一个
**不存在**
的
`key`
:
![](
https://upload-images.jianshu.io/upload_images/7896890-0beb6acc89d5c927.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
很明显,
`1/3/5`
这几个位置的
`1`
是因为上面第一次添加的
`wmyskxz`
而导致的,所以这里就存在
**误判**
。幸运的是,布隆过滤器有一个可以预判误判率的公式,比较复杂,感兴趣的朋友可以自行去阅读,比较烧脑.. 只需要记住以下几点就好了:
-
使用时
**不要让实际元素数量远大于初始化数量**
;
-
当实际元素数量超过初始化数量时,应该对布隆过滤器进行
**重建**
,重新分配一个
`size`
更大的过滤器,再将所有的历史元素批量
`add`
进行;
# 三、布隆过滤器的使用
**Redis 官方**
提供的布隆过滤器到了
**Redis 4.0**
提供了插件功能之后才正式登场。布隆过滤器作为一个插件加载到 Redis Server 中,给 Redis 提供了强大的布隆去重功能。下面我们来体验一下 Redis 4.0 的布隆过滤器,为了省去繁琐安装过程,我们直接用
Docker 吧。
```
bash
>
docker pull redislabs/rebloom
# 拉取镜像
>
docker run
-p6379
:6379 redislabs/rebloom
# 运行容器
>
redis-cli
# 连接容器中的 redis 服务
```
如果上面三条指令执行没有问题,下面就可以体验布隆过滤器了。
-
当然,如果你不想使用 Docker,也可以在检查本机 Redis 版本合格之后自行安装插件,可以参考这里:
[
https://blog.csdn.net/u013030276/article/details/88350641
](
https://blog.csdn.net/u013030276/article/details/88350641
)
## 布隆过滤器的基本用法
布隆过滤器有两个基本指令,
`bf.add`
添加元素,
`bf.exists`
查询元素是否存在,它的用法和 set 集合的
`sadd`
和
`sismember`
差不多。注意
`bf.add`
只能一次添加一个元素,如果想要一次添加多个,就需要用到
`bf.madd`
指令。同样如果需要一次查询多个元素是否存在,就需要用到
`bf.mexists`
指令。
```
bash
127.0.0.1:6379> bf.add codehole user1
(
integer
)
1
127.0.0.1:6379> bf.add codehole user2
(
integer
)
1
127.0.0.1:6379> bf.add codehole user3
(
integer
)
1
127.0.0.1:6379> bf.exists codehole user1
(
integer
)
1
127.0.0.1:6379> bf.exists codehole user2
(
integer
)
1
127.0.0.1:6379> bf.exists codehole user3
(
integer
)
1
127.0.0.1:6379> bf.exists codehole user4
(
integer
)
0
127.0.0.1:6379> bf.madd codehole user4 user5 user6
1
)
(
integer
)
1
2
)
(
integer
)
1
3
)
(
integer
)
1
127.0.0.1:6379> bf.mexists codehole user4 user5 user6 user7
1
)
(
integer
)
1
2
)
(
integer
)
1
3
)
(
integer
)
1
4
)
(
integer
)
0
```
上面使用的布隆过过滤器只是默认参数的布隆过滤器,它在我们第一次
`add`
的时候自动创建。Redis 也提供了可以自定义参数的布隆过滤器,只需要在
`add`
之前使用
`bf.reserve`
指令显式创建就好了。如果对应的
`key`
已经存在,
`bf.reserve`
会报错。
`bf.reserve`
有三个参数,分别是
`key`
、
`error_rate`
*(错误率)*
和
`initial_size`
:
-
**`error_rate` 越低,需要的空间越大**
,对于不需要过于精确的场合,设置稍大一些也没有关系,比如上面说的推送系统,只会让一小部分的内容被过滤掉,整体的观看体验还是不会受到很大影响的;
-
**`initial_size` 表示预计放入的元素数量**
,当实际数量超过这个值时,误判率就会提升,所以需要提前设置一个较大的数值避免超出导致误判率升高;
如果不适用
`bf.reserve`
,默认的
`error_rate`
是
`0.01`
,默认的
`initial_size`
是
`100`
。
# 四、布隆过滤器代码实现
## 自己简单模拟实现
根据上面的基础理论,我们很容易就可以自己实现一个用于
`简单模拟`
的布隆过滤器数据结构:
```
java
public
static
class
BloomFilter
{
private
byte
[]
data
;
public
BloomFilter
(
int
initSize
)
{
this
.
data
=
new
byte
[
initSize
*
2
];
// 默认创建大小 * 2 的空间
}
public
void
add
(
int
key
)
{
int
location1
=
Math
.
abs
(
hash1
(
key
)
%
data
.
length
);
int
location2
=
Math
.
abs
(
hash2
(
key
)
%
data
.
length
);
int
location3
=
Math
.
abs
(
hash3
(
key
)
%
data
.
length
);
data
[
location1
]
=
data
[
location2
]
=
data
[
location3
]
=
1
;
}
public
boolean
contains
(
int
key
)
{
int
location1
=
Math
.
abs
(
hash1
(
key
)
%
data
.
length
);
int
location2
=
Math
.
abs
(
hash2
(
key
)
%
data
.
length
);
int
location3
=
Math
.
abs
(
hash3
(
key
)
%
data
.
length
);
return
data
[
location1
]
*
data
[
location2
]
*
data
[
location3
]
==
1
;
}
private
int
hash1
(
Integer
key
)
{
return
key
.
hashCode
();
}
private
int
hash2
(
Integer
key
)
{
int
hashCode
=
key
.
hashCode
();
return
hashCode
^
(
hashCode
>>>
3
);
}
private
int
hash3
(
Integer
key
)
{
int
hashCode
=
key
.
hashCode
();
return
hashCode
^
(
hashCode
>>>
16
);
}
}
```
这里很简单,内部仅维护了一个
`byte`
类型的
`data`
数组,实际上
`byte`
仍然占有一个字节之多,可以优化成
`bit`
来代替,这里也仅仅是用于方便模拟。另外我也创建了三个不同的
`hash`
函数,其实也就是借鉴
`HashMap`
哈希抖动的办法,分别使用自身的
`hash`
和右移不同位数相异或的结果。并且提供了基础的
`add`
和
`contains`
方法。
下面我们来简单测试一下这个布隆过滤器的效果如何:
```
java
public
static
void
main
(
String
[]
args
)
{
Random
random
=
new
Random
();
// 假设我们的数据有 1 百万
int
size
=
1_000_000
;
// 用一个数据结构保存一下所有实际存在的值
LinkedList
<
Integer
>
existentNumbers
=
new
LinkedList
<>();
BloomFilter
bloomFilter
=
new
BloomFilter
(
size
);
for
(
int
i
=
0
;
i
<
size
;
i
++)
{
int
randomKey
=
random
.
nextInt
();
existentNumbers
.
add
(
randomKey
);
bloomFilter
.
add
(
randomKey
);
}
// 验证已存在的数是否都存在
AtomicInteger
count
=
new
AtomicInteger
();
AtomicInteger
finalCount
=
count
;
existentNumbers
.
forEach
(
number
->
{
if
(
bloomFilter
.
contains
(
number
))
{
finalCount
.
incrementAndGet
();
}
});
System
.
out
.
printf
(
"实际的数据量: %d, 判断存在的数据量: %d \n"
,
size
,
count
.
get
());
// 验证10个不存在的数
count
=
new
AtomicInteger
();
while
(
count
.
get
()
<
10
)
{
int
key
=
random
.
nextInt
();
if
(
existentNumbers
.
contains
(
key
))
{
continue
;
}
else
{
// 这里一定是不存在的数
System
.
out
.
println
(
bloomFilter
.
contains
(
key
));
count
.
incrementAndGet
();
}
}
}
```
输出如下:
```
bash
实际的数据量: 1000000, 判断存在的数据量: 1000000
false
true
false
true
true
true
false
false
true
false
```
这就是前面说到的,当布隆过滤器说某个值
**存在时**
,这个值
**可能不存在**
,当它说某个值
**不存在时**
,那就
**肯定不存在**
,并且还有一定的误判率...
## 手动实现参考
当然上面的版本特别 low,不过主体思想是不差的,这里也给出一个好一些的版本用作自己实现测试的参考:
```
java
import
java.util.BitSet
;
public
class
MyBloomFilter
{
/**
* 位数组的大小
*/
private
static
final
int
DEFAULT_SIZE
=
2
<<
24
;
/**
* 通过这个数组可以创建 6 个不同的哈希函数
*/
private
static
final
int
[]
SEEDS
=
new
int
[]{
3
,
13
,
46
,
71
,
91
,
134
};
/**
* 位数组。数组中的元素只能是 0 或者 1
*/
private
BitSet
bits
=
new
BitSet
(
DEFAULT_SIZE
);
/**
* 存放包含 hash 函数的类的数组
*/
private
SimpleHash
[]
func
=
new
SimpleHash
[
SEEDS
.
length
];
/**
* 初始化多个包含 hash 函数的类的数组,每个类中的 hash 函数都不一样
*/
public
MyBloomFilter
()
{
// 初始化多个不同的 Hash 函数
for
(
int
i
=
0
;
i
<
SEEDS
.
length
;
i
++)
{
func
[
i
]
=
new
SimpleHash
(
DEFAULT_SIZE
,
SEEDS
[
i
]);
}
}
/**
* 添加元素到位数组
*/
public
void
add
(
Object
value
)
{
for
(
SimpleHash
f
:
func
)
{
bits
.
set
(
f
.
hash
(
value
),
true
);
}
}
/**
* 判断指定元素是否存在于位数组
*/
public
boolean
contains
(
Object
value
)
{
boolean
ret
=
true
;
for
(
SimpleHash
f
:
func
)
{
ret
=
ret
&&
bits
.
get
(
f
.
hash
(
value
));
}
return
ret
;
}
/**
* 静态内部类。用于 hash 操作!
*/
public
static
class
SimpleHash
{
private
int
cap
;
private
int
seed
;
public
SimpleHash
(
int
cap
,
int
seed
)
{
this
.
cap
=
cap
;
this
.
seed
=
seed
;
}
/**
* 计算 hash 值
*/
public
int
hash
(
Object
value
)
{
int
h
;
return
(
value
==
null
)
?
0
:
Math
.
abs
(
seed
*
(
cap
-
1
)
&
((
h
=
value
.
hashCode
())
^
(
h
>>>
16
)));
}
}
}
```
## 使用 Google 开源的 Guava 中自带的布隆过滤器
自己实现的目的主要是为了让自己搞懂布隆过滤器的原理,Guava 中布隆过滤器的实现算是比较权威的,所以实际项目中我们不需要手动实现一个布隆过滤器。
首先我们需要在项目中引入 Guava 的依赖:
```
xml
<dependency>
<groupId>
com.google.guava
</groupId>
<artifactId>
guava
</artifactId>
<version>
28.0-jre
</version>
</dependency>
```
实际使用如下:
我们创建了一个最多存放 最多 1500 个整数的布隆过滤器,并且我们可以容忍误判的概率为百分之(0.01)
```
java
// 创建布隆过滤器对象
BloomFilter
<
Integer
>
filter
=
BloomFilter
.
create
(
Funnels
.
integerFunnel
(),
1500
,
0.01
);
// 判断指定元素是否存在
System
.
out
.
println
(
filter
.
mightContain
(
1
));
System
.
out
.
println
(
filter
.
mightContain
(
2
));
// 将元素添加进布隆过滤器
filter
.
put
(
1
);
filter
.
put
(
2
);
System
.
out
.
println
(
filter
.
mightContain
(
1
));
System
.
out
.
println
(
filter
.
mightContain
(
2
));
```
在我们的示例中,当
`mightContain()`
方法返回
`true`
时,我们可以
**99%**
确定该元素在过滤器中,当过滤器返回
`false`
时,我们可以
**100%**
确定该元素不存在于过滤器中。
Guava 提供的布隆过滤器的实现还是很不错的
*(想要详细了解的可以看一下它的源码实现)*
,但是它有一个重大的缺陷就是只能单机使用
*(另外,容量扩展也不容易)*
,而现在互联网一般都是分布式的场景。为了解决这个问题,我们就需要用到
**Redis**
中的布隆过滤器了。
# 相关阅读
1.
Redis(1)——5种基本数据结构 -
[
https://www.wmyskxz.com/2020/02/28/redis-1-5-chong-ji-ben-shu-ju-jie-gou/
](
https://www.wmyskxz.com/2020/02/28/redis-1-5-chong-ji-ben-shu-ju-jie-gou/
)
2.
Redis(2)——跳跃表 -
[
https://www.wmyskxz.com/2020/02/29/redis-2-tiao-yue-biao/
](
https://www.wmyskxz.com/2020/02/29/redis-2-tiao-yue-biao/
)
3.
Redis(3)——分布式锁深入探究 -
[
https://www.wmyskxz.com/2020/03/01/redis-3/
](
https://www.wmyskxz.com/2020/03/01/redis-3/
)
4.
Reids(4)——神奇的HyperLoglog解决统计问题 -
[
https://www.wmyskxz.com/2020/03/02/reids-4-shen-qi-de-hyperloglog-jie-jue-tong-ji-wen-ti/
](
https://www.wmyskxz.com/2020/03/02/reids-4-shen-qi-de-hyperloglog-jie-jue-tong-ji-wen-ti/
)
\
# 参考资料
1.
《Redis 深度历险》 - 钱文品/ 著 -
[
https://book.douban.com/subject/30386804/
](
https://book.douban.com/subject/30386804/
)
2.
5 分钟搞懂布隆过滤器,亿级数据过滤算法你值得拥有! -
[
https://juejin.im/post/5de1e37c5188256e8e43adfc
](
https://juejin.im/post/5de1e37c5188256e8e43adfc
)
3.
【原创】不了解布隆过滤器?一文给你整的明明白白! -
[
https://github.com/Snailclimb/JavaGuide/blob/master/docs/dataStructures-algorithms/data-structure/bloom-filter.md
](
https://github.com/Snailclimb/JavaGuide/blob/master/docs/dataStructures-algorithms/data-structure/bloom-filter.md
)
docs/database/Redis/redis-collection/Redis(6)——GeoHash查找附近的人.md
0 → 100644
浏览文件 @
0de8ebb8
> 授权转载自: https://github.com/wmyskxz/MoreThanJava#part3-redis
![](
https://upload-images.jianshu.io/upload_images/7896890-8ccb98beab9aff6a.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
像微信
**"附近的人"**
,美团
**"附近的餐厅"**
,支付宝共享单车
**"附近的车"**
是怎么设计实现的呢?
# 一、使用数据库实现查找附近的人
我们都知道,地球上的任何一个位置都可以使用二维的
**经纬度**
来表示,经度范围
*[-180, 180]*
,纬度范围
*[-90, 90]*
,纬度正负以赤道为界,北正南负,经度正负以本初子午线
*(英国格林尼治天文台)*
为界,东正西负。比如说,北京人民英雄纪念碑的经纬度坐标就是
*(39.904610, 116.397724)*
,都是正数,因为中国位于东北半球。
所以,当我们使用数据库存储了所有人的
**经纬度**
信息之后,我们就可以基于当前的坐标节点,来划分出一个矩形的范围,来得知附近的人,如下图:
![](
https://upload-images.jianshu.io/upload_images/7896890-c5e82d3cab59ad22.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
所以,我们很容易写出下列的伪 SQL 语句:
```
sql
SELECT
id
FROM
positions
WHERE
x0
-
r
<
x
<
x0
+
r
AND
y0
-
r
<
y
<
y0
+
r
```
如果我们还想进一步地知道与每个坐标元素的距离并排序的话,就需要一定的计算。
当两个坐标元素的距离不是很远的时候,我们就可以简单利用
**勾股定理**
就能够得出他们之间的
**距离**
。不过需要注意的是,地球不是一个标准的球体,
**经纬度的密度**
是
**不一样**
的,所以我们使用勾股定理计算平方之后再求和时,需要按照一定的系数
**加权**
再进行求和。当然,如果不准求精确的话,加权也不必了。
参考下方
*参考资料 2*
我们能够差不多能写出如下优化之后的 SQL 语句来:
*(仅供参考)*
```
sql
SELECT
*
FROM
users_location
WHERE
latitude
>
'.$lat.'
-
1
AND
latitude
<
'.$lat.'
+
1
AND
longitude
>
'.$lon.'
-
1
AND
longitude
<
'.$lon.'
+
1
ORDER
BY
ACOS
(
SIN
(
(
'.$lat.'
*
3
.
1415
)
/
180
)
*
SIN
(
(
latitude
*
3
.
1415
)
/
180
)
+
COS
(
(
'.$lat.'
*
3
.
1415
)
/
180
)
*
COS
(
(
latitude
*
3
.
1415
)
/
180
)
*
COS
(
(
'.$lon.'
*
3
.
1415
)
/
180
-
(
longitude
*
3
.
1415
)
/
180
)
)
*
6380
ASC
LIMIT
10
';
```
为了满足高性能的矩形区域算法,数据表也需要把经纬度坐标加上
**双向复合索引 (x, y)**
,这样可以满足最大优化查询性能。
# 二、GeoHash 算法简述
这是业界比较通用的,用于
**地理位置距离排序**
的一个算法,
**Redis**
也采用了这样的算法。GeoHash 算法将
**二维的经纬度**
数据映射到
**一维**
的整数,这样所有的元素都将在挂载到一条线上,距离靠近的二维坐标映射到一维后的点之间距离也会很接近。当我们想要计算
**「附近的人时」**
,首先将目标位置映射到这条线上,然后在这个一维的线上获取附近的点就行了。
它的核心思想就是把整个地球看成是一个
**二维的平面**
,然后把这个平面不断地等分成一个一个小的方格,
**每一个**
坐标元素都位于其中的
**唯一一个方格**
中,等分之后的
**方格越小**
,那么坐标也就
**越精确**
,类似下图:
![](
https://upload-images.jianshu.io/upload_images/7896890-6396ae153a485857.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
经过划分的地球,我们需要对其进行编码:
![](
https://upload-images.jianshu.io/upload_images/7896890-573525c3f1179bbc.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
经过这样顺序的编码之后,如果你仔细观察一会儿,你就会发现一些规律:
-
横着的所有编码中,
**第 2 位和第 4 位都是一样的**
,例如第一排第一个
`0101`
和第二个
`0111`
,他们的第 2 位和第 4 位都是
`1`
;
-
竖着的所有编码中,
**第 1 位和第 3 位是递增的**
,例如第一排第一个
`0101`
,如果单独把第 1 位和第 3 位拎出来的话,那就是
`00`
,同理看第一排第二个
`0111`
,同样的方法第 1 位和第 3 位拎出来是
`01`
,刚好是
`00`
递增一个;
通过这样的规律我们就把每一个小方块儿进行了一定顺序的编码,这样做的
**好处**
是显而易见的:每一个元素坐标既能够被
**唯一标识**
在这张被编码的地图上,也不至于
**暴露特别的具体的位置**
,因为区域是共享的,我可以告诉你我就在公园附近,但是在具体的哪个地方你就无从得知了。
总之,我们通过上面的思想,能够把任意坐标变成一串二进制的编码了,类似于
`11010010110001000100`
这样
*(注意经度和维度是交替出现的哦..)*
,通过这个整数我们就可以还原出元素的坐标,整数越长,还原出来的坐标值的损失程序就越小。对于
**"附近的人"**
这个功能来说,损失的一点经度可以忽略不计。
最后就是一个
`Base32`
*(0~9, a~z, 去掉 a/i/l/o 四个字母)*
的编码操作,让它变成一个字符串,例如上面那一串儿就变成了
`wx4g0ec1`
。
在
**Redis**
中,经纬度使用
`52`
位的整数进行编码,放进了 zset 里面,zset 的
`value`
是元素的
`key`
,
`score`
是
**GeoHash**
的
`52`
位整数值。zset 的
`score`
虽然是浮点数,但是对于
`52`
位的整数值来说,它可以无损存储。
# 三、在 Redis 中使用 Geo
> 下方内容引自 *参考资料 1 - 《Redis 深度历险》*
在使用
**Redis**
进行
**Geo 查询**
时,我们要时刻想到它的内部结构实际上只是一个
**zset(skiplist)**
。通过 zset 的
`score`
排序就可以得到坐标附近的其他元素
*(实际情况要复杂一些,不过这样理解足够了)*
,通过将
`score`
还原成坐标值就可以得到元素的原始坐标了。
Redis 提供的 Geo 指令只有 6 个,很容易就可以掌握。
## 增加
`geoadd`
指令携带集合名称以及多个经纬度名称三元组,注意这里可以加入多个三元组。
```
bash
127.0.0.1:6379> geoadd company 116.48105 39.996794 juejin
(
integer
)
1
127.0.0.1:6379> geoadd company 116.514203 39.905409 ireader
(
integer
)
1
127.0.0.1:6379> geoadd company 116.489033 40.007669 meituan
(
integer
)
1
127.0.0.1:6379> geoadd company 116.562108 39.787602 jd 116.334255 40.027400 xiaomi
(
integer
)
2
```
不过很奇怪.. Redis 没有直接提供 Geo 的删除指令,但是我们可以通过 zset 相关的指令来操作 Geo 数据,所以元素删除可以使用
`zrem`
指令即可。
## 距离
`geodist`
指令可以用来计算两个元素之间的距离,携带集合名称、2 个名称和距离单位。
```
bash
127.0.0.1:6379> geodist company juejin ireader km
"10.5501"
127.0.0.1:6379> geodist company juejin meituan km
"1.3878"
127.0.0.1:6379> geodist company juejin jd km
"24.2739"
127.0.0.1:6379> geodist company juejin xiaomi km
"12.9606"
127.0.0.1:6379> geodist company juejin juejin km
"0.0000"
```
我们可以看到掘金离美团最近,因为它们都在望京。距离单位可以是
`m`
、
`km`
、
`ml`
、
`ft`
,分别代表米、千米、英里和尺。
## 获取元素位置
`geopos`
指令可以获取集合中任意元素的经纬度坐标,可以一次获取多个。
```
bash
127.0.0.1:6379> geopos company juejin
1
)
1
)
"116.48104995489120483"
2
)
"39.99679348858259686"
127.0.0.1:6379> geopos company ireader
1
)
1
)
"116.5142020583152771"
2
)
"39.90540918662494363"
127.0.0.1:6379> geopos company juejin ireader
1
)
1
)
"116.48104995489120483"
2
)
"39.99679348858259686"
2
)
1
)
"116.5142020583152771"
2
)
"39.90540918662494363"
```
我们观察到获取的经纬度坐标和
`geoadd`
进去的坐标有轻微的误差,原因是
**Geohash**
对二维坐标进行的一维映射是有损的,通过映射再还原回来的值会出现较小的差别。对于
**「附近的人」**
这种功能来说,这点误差根本不是事。
## 获取元素的 hash 值
`geohash`
可以获取元素的经纬度编码字符串,上面已经提到,它是
`base32`
编码。 你可以使用这个编码值去
`http://geohash.org/${hash}`
中进行直接定位,它是
**Geohash**
的标准编码值。
```
bash
127.0.0.1:6379> geohash company ireader
1
)
"wx4g52e1ce0"
127.0.0.1:6379> geohash company juejin
1
)
"wx4gd94yjn0"
```
让我们打开地址
`http://geohash.org/wx4g52e1ce0`
,观察地图指向的位置是否正确:
![](
https://upload-images.jianshu.io/upload_images/7896890-b5d4215d6397729c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
很好,就是这个位置,非常准确。
## 附近的公司
`georadiusbymember`
指令是最为关键的指令,它可以用来查询指定元素附近的其它元素,它的参数非常复杂。
```
bash
# 范围 20 公里以内最多 3 个元素按距离正排,它不会排除自身
127.0.0.1:6379> georadiusbymember company ireader 20 km count 3 asc
1
)
"ireader"
2
)
"juejin"
3
)
"meituan"
# 范围 20 公里以内最多 3 个元素按距离倒排
127.0.0.1:6379> georadiusbymember company ireader 20 km count 3 desc
1
)
"jd"
2
)
"meituan"
3
)
"juejin"
# 三个可选参数 withcoord withdist withhash 用来携带附加参数
# withdist 很有用,它可以用来显示距离
127.0.0.1:6379> georadiusbymember company ireader 20 km withcoord withdist withhash count 3 asc
1
)
1
)
"ireader"
2
)
"0.0000"
3
)
(
integer
)
4069886008361398
4
)
1
)
"116.5142020583152771"
2
)
"39.90540918662494363"
2
)
1
)
"juejin"
2
)
"10.5501"
3
)
(
integer
)
4069887154388167
4
)
1
)
"116.48104995489120483"
2
)
"39.99679348858259686"
3
)
1
)
"meituan"
2
)
"11.5748"
3
)
(
integer
)
4069887179083478
4
)
1
)
"116.48903220891952515"
2
)
"40.00766997707732031"
```
除了
`georadiusbymember`
指令根据元素查询附近的元素,
**Redis**
还提供了根据坐标值来查询附近的元素,这个指令更加有用,它可以根据用户的定位来计算「附近的车」,「附近的餐馆」等。它的参数和
`georadiusbymember`
基本一致,除了将目标元素改成经纬度坐标值:
```
bash
127.0.0.1:6379> georadius company 116.514202 39.905409 20 km withdist count 3 asc
1
)
1
)
"ireader"
2
)
"0.0000"
2
)
1
)
"juejin"
2
)
"10.5501"
3
)
1
)
"meituan"
2
)
"11.5748"
```
## 注意事项
在一个地图应用中,车的数据、餐馆的数据、人的数据可能会有百万千万条,如果使用
**Redis**
的
**Geo**
数据结构,它们将
**全部放在一个**
zset 集合中。在
**Redis**
的集群环境中,集合可能会从一个节点迁移到另一个节点,如果单个 key 的数据过大,会对集群的迁移工作造成较大的影响,在集群环境中单个 key 对应的数据量不宜超过 1M,否则会导致集群迁移出现卡顿现象,影响线上服务的正常运行。
所以,这里建议
**Geo**
的数据使用
**单独的 Redis 实例部署**
,不使用集群环境。
如果数据量过亿甚至更大,就需要对
**Geo**
数据进行拆分,按国家拆分、按省拆分,按市拆分,在人口特大城市甚至可以按区拆分。这样就可以显著降低单个 zset 集合的大小。
# 相关阅读
1.
Redis(1)——5种基本数据结构 -
[
https://www.wmyskxz.com/2020/02/28/redis-1-5-chong-ji-ben-shu-ju-jie-gou/
](
https://www.wmyskxz.com/2020/02/28/redis-1-5-chong-ji-ben-shu-ju-jie-gou/
)
2.
Redis(2)——跳跃表 -
[
https://www.wmyskxz.com/2020/02/29/redis-2-tiao-yue-biao/
](
https://www.wmyskxz.com/2020/02/29/redis-2-tiao-yue-biao/
)
3.
Redis(3)——分布式锁深入探究 -
[
https://www.wmyskxz.com/2020/03/01/redis-3/
](
https://www.wmyskxz.com/2020/03/01/redis-3/
)
4.
Reids(4)——神奇的HyperLoglog解决统计问题 -
[
https://www.wmyskxz.com/2020/03/02/reids-4-shen-qi-de-hyperloglog-jie-jue-tong-ji-wen-ti/
](
https://www.wmyskxz.com/2020/03/02/reids-4-shen-qi-de-hyperloglog-jie-jue-tong-ji-wen-ti/
)
5.
Redis(5)——亿级数据过滤和布隆过滤器 -
[
https://www.wmyskxz.com/2020/03/11/redis-5-yi-ji-shu-ju-guo-lu-he-bu-long-guo-lu-qi/
](
https://www.wmyskxz.com/2020/03/11/redis-5-yi-ji-shu-ju-guo-lu-he-bu-long-guo-lu-qi/
)
# 参考资料
1.
《Redis 深度历险》 - 钱文品/ 著 -
[
https://book.douban.com/subject/30386804/
](
https://book.douban.com/subject/30386804/
)
2.
mysql经纬度查询并且计算2KM范围内附近用户的sql查询性能优化实例教程 -
[
https://www.cnblogs.com/mgbert/p/4146538.html
](
https://www.cnblogs.com/mgbert/p/4146538.html
)
3.
Geohash算法原理及实现 -
[
https://www.jianshu.com/p/2fd0cf12e5ba
](
https://www.jianshu.com/p/2fd0cf12e5ba
)
4.
GeoHash算法学习讲解、解析及原理分析 -
[
https://zhuanlan.zhihu.com/p/35940647
](
https://zhuanlan.zhihu.com/p/35940647
)
> - 本文已收录至我的 Github 程序员成长系列 **【More Than Java】,学习,不止 Code,欢迎 star:[https://github.com/wmyskxz/MoreThanJava](https://github.com/wmyskxz/MoreThanJava)**
> - **个人公众号** :wmyskxz,**个人独立域名博客**:wmyskxz.com,坚持原创输出,下方扫码关注,2020,与您共同成长!
![](
https://upload-images.jianshu.io/upload_images/7896890-fca34cfd601e7449.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
非常感谢各位人才能
**看到这里**
,如果觉得本篇文章写得不错,觉得
**「我没有三颗心脏」有点东西**
的话,
**求点赞,求关注,求分享,求留言!**
创作不易,各位的支持和认可,就是我创作的最大动力,我们下篇文章见!
\ No newline at end of file
docs/database/Redis/redis-collection/Redis(7)——持久化.md
0 → 100644
浏览文件 @
0de8ebb8
> 授权转载自: https://github.com/wmyskxz/MoreThanJava#part3-redis
![](
https://upload-images.jianshu.io/upload_images/7896890-7879862264eeea7b.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
# 一、持久化简介
**Redis**
的数据
**全部存储**
在
**内存**
中,如果
**突然宕机**
,数据就会全部丢失,因此必须有一套机制来保证 Redis 的数据不会因为故障而丢失,这种机制就是 Redis 的
**持久化机制**
,它会将内存中的数据库状态
**保存到磁盘**
中。
## 持久化发生了什么 | 从内存到磁盘
我们来稍微考虑一下
**Redis**
作为一个
**"内存数据库"**
要做的关于持久化的事情。通常来说,从客户端发起请求开始,到服务器真实地写入磁盘,需要发生如下几件事情:
![](
https://upload-images.jianshu.io/upload_images/7896890-5c209bc08da11abb.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
**详细版**
的文字描述大概就是下面这样:
1.
客户端向数据库
**发送写命令**
*(数据在客户端的内存中)*
2.
数据库
**接收**
到客户端的
**写请求**
*(数据在服务器的内存中)*
3.
数据库
**调用系统 API**
将数据写入磁盘
*(数据在内核缓冲区中)*
4.
操作系统将
**写缓冲区**
传输到
**磁盘控控制器**
*(数据在磁盘缓存中)*
5.
操作系统的磁盘控制器将数据
**写入实际的物理媒介**
中
*(数据在磁盘中)*
**注意:**
上面的过程其实是
**极度精简**
的,在实际的操作系统中,
**缓存**
和
**缓冲区**
会比这
**多得多**
...
## 如何尽可能保证持久化的安全
如果我们故障仅仅涉及到
**软件层面**
*(该进程被管理员终止或程序崩溃)*
并且没有接触到内核,那么在
*上述步骤 3*
成功返回之后,我们就认为成功了。即使进程崩溃,操作系统仍然会帮助我们把数据正确地写入磁盘。
如果我们考虑
**停电/ 火灾**
等
**更具灾难性**
的事情,那么只有在完成了第
**5**
步之后,才是安全的。
![
机房”火了“
](
https://upload-images.jianshu.io/upload_images/7896890-de083f477fe1bce4.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
所以我们可以总结得出数据安全最重要的阶段是:
**步骤三、四、五**
,即:
-
数据库软件调用写操作将用户空间的缓冲区转移到内核缓冲区的频率是多少?
-
内核多久从缓冲区取数据刷新到磁盘控制器?
-
磁盘控制器多久把数据写入物理媒介一次?
-
**注意:**
如果真的发生灾难性的事件,我们可以从上图的过程中看到,任何一步都可能被意外打断丢失,所以只能
**尽可能地保证**
数据的安全,这对于所有数据库来说都是一样的。
我们从
**第三步**
开始。Linux 系统提供了清晰、易用的用于操作文件的
`POSIX file API`
,
`20`
多年过去,仍然还有很多人对于这一套
`API`
的设计津津乐道,我想其中一个原因就是因为你光从
`API`
的命名就能够很清晰地知道这一套 API 的用途:
```
c
int
open
(
const
char
*
path
,
int
oflag
,
...
/*,mode_t mode */
);
int
close
(
int
filedes
);
int
remove
(
const
char
*
fname
);
ssize_t
write
(
int
fildes
,
const
void
*
buf
,
size_t
nbyte
);
ssize_t
read
(
int
fildes
,
void
*
buf
,
size_t
nbyte
);
```
-
参考自:API 设计最佳实践的思考 -
[
https://www.cnblogs.com/yuanjiangw/p/10846560.html
](
https://www.cnblogs.com/yuanjiangw/p/10846560.html
)
所以,我们有很好的可用的
`API`
来完成
**第三步**
,但是对于成功返回之前,我们对系统调用花费的时间没有太多的控制权。
然后我们来说说
**第四步**
。我们知道,除了早期对电脑特别了解那帮人
*(操作系统就这帮人搞的)*
,实际的物理硬件都不是我们能够
**直接操作**
的,都是通过
**操作系统调用**
来达到目的的。为了防止过慢的 I/O 操作拖慢整个系统的运行,操作系统层面做了很多的努力,譬如说
**上述第四步**
提到的
**写缓冲区**
,并不是所有的写操作都会被立即写入磁盘,而是要先经过一个缓冲区,默认情况下,Linux 将在
**30 秒**
后实际提交写入。
![
image
](
https://upload-images.jianshu.io/upload_images/7896890-c08b7572ef02d67b.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
但是很明显,
**30 秒**
并不是 Redis 能够承受的,这意味着,如果发生故障,那么最近 30 秒内写入的所有数据都可能会丢失。幸好
`PROSIX API`
提供了另一个解决方案:
`fsync`
,该命令会
**强制**
内核将
**缓冲区**
写入
**磁盘**
,但这是一个非常消耗性能的操作,每次调用都会
**阻塞等待**
直到设备报告 IO 完成,所以一般在生产环境的服务器中,
**Redis**
通常是每隔 1s 左右执行一次
`fsync`
操作。
到目前为止,我们了解到了如何控制
`第三步`
和
`第四步`
,但是对于
**第五步**
,我们
**完全无法控制**
。也许一些内核实现将试图告诉驱动实际提交物理介质上的数据,或者控制器可能会为了提高速度而重新排序写操作,不会尽快将数据真正写到磁盘上,而是会等待几个多毫秒。这完全是我们无法控制的。
# 二、Redis 中的两种持久化方式
## 方式一:快照
![
image
](
https://upload-images.jianshu.io/upload_images/7896890-9a4d234c53120b33.gif?imageMogr2/auto-orient/strip
)
**Redis 快照**
是最简单的 Redis 持久性模式。当满足特定条件时,它将生成数据集的时间点快照,例如,如果先前的快照是在2分钟前创建的,并且现在已经至少有
*100*
次新写入,则将创建一个新的快照。此条件可以由用户配置 Redis 实例来控制,也可以在运行时修改而无需重新启动服务器。快照作为包含整个数据集的单个
`.rdb`
文件生成。
但我们知道,Redis 是一个
**单线程**
的程序,这意味着,我们不仅仅要响应用户的请求,还需要进行内存快照。而后者要求 Redis 必须进行 IO 操作,这会严重拖累服务器的性能。
还有一个重要的问题是,我们在
**持久化的同时**
,
**内存数据结构**
还可能在
**变化**
,比如一个大型的 hash 字典正在持久化,结果一个请求过来把它删除了,可是这才刚持久化结束,咋办?
![](
https://upload-images.jianshu.io/upload_images/7896890-fbfcbd606e95f105.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
### 使用系统多进程 COW(Copy On Write) 机制 | fork 函数
操作系统多进程
**COW(Copy On Write) 机制**
拯救了我们。
**Redis**
在持久化时会调用
`glibc`
的函数
`fork`
产生一个子进程,简单理解也就是基于当前进程
**复制**
了一个进程,主进程和子进程会共享内存里面的代码块和数据段:
![](
https://upload-images.jianshu.io/upload_images/7896890-bc264b6a9f0c3404.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
这里多说一点,
**为什么 fork 成功调用后会有两个返回值呢?**
因为子进程在复制时复制了父进程的堆栈段,所以两个进程都停留在了
`fork`
函数中
*(都在同一个地方往下继续"同时"执行)*
,等待返回,所以
**一次在父进程中返回子进程的 pid,另一次在子进程中返回零,系统资源不够时返回负数**
。
*(伪代码如下)*
```
python
pid
=
os
.
fork
()
if
pid
>
0
:
handle_client_request
()
# 父进程继续处理客户端请求
if
pid
==
0
:
handle_snapshot_write
()
# 子进程处理快照写磁盘
if
pid
<
0
:
# fork error
```
所以
**快照持久化**
可以完全交给
**子进程**
来处理,
**父进程**
则继续
**处理客户端请求**
。
**子进程**
做数据持久化,它
**不会修改现有的内存数据结构**
,它只是对数据结构进行遍历读取,然后序列化写到磁盘中。但是
**父进程**
不一样,它必须持续服务客户端请求,然后对
**内存数据结构进行不间断的修改**
。
这个时候就会使用操作系统的 COW 机制来进行
**数据段页面**
的分离。数据段是由很多操作系统的页面组合而成,当父进程对其中一个页面的数据进行修改时,会将被共享的页面复
制一份分离出来,然后
**对这个复制的页面进行修改**
。这时
**子进程**
相应的页面是
**没有变化的**
,还是进程产生时那一瞬间的数据。
子进程因为数据没有变化,它能看到的内存里的数据在进程产生的一瞬间就凝固了,再也不会改变,这也是为什么
**Redis**
的持久化
**叫「快照」的原因**
。接下来子进程就可以非常安心的遍历数据了进行序列化写磁盘了。
## 方式二:AOF
![](
https://upload-images.jianshu.io/upload_images/7896890-e4e08ebef2cf0144.gif?imageMogr2/auto-orient/strip
)
**快照不是很持久**
。如果运行 Redis 的计算机停止运行,电源线出现故障或者您
`kill -9`
的实例意外发生,则写入 Redis 的最新数据将丢失。尽管这对于某些应用程序可能不是什么大问题,但有些使用案例具有充分的耐用性,在这些情况下,快照并不是可行的选择。
**AOF(Append Only File - 仅追加文件)**
它的工作方式非常简单:每次执行
**修改内存**
中数据集的写操作时,都会
**记录**
该操作。假设 AOF 日志记录了自 Redis 实例创建以来
**所有的修改性指令序列**
,那么就可以通过对一个空的 Redis 实例
**顺序执行所有的指令**
,也就是
**「重放」**
,来恢复 Redis 当前实例的内存数据结构的状态。
为了展示 AOF 在实际中的工作方式,我们来做一个简单的实验:
```
bash
./redis-server
--appendonly
yes
# 设置一个新实例为 AOF 模式
```
然后我们执行一些写操作:
```
bash
redis 127.0.0.1:6379>
set
key1 Hello
OK
redis 127.0.0.1:6379> append key1
" World!"
(
integer
)
12
redis 127.0.0.1:6379> del key1
(
integer
)
1
redis 127.0.0.1:6379> del non_existing_key
(
integer
)
0
```
前三个操作实际上修改了数据集,第四个操作没有修改,因为没有指定名称的键。这是 AOF 日志保存的文本:
```
bash
$
cat
appendonly.aof
*
2
$6
SELECT
$1
0
*
3
$3
set
$4
key1
$5
Hello
*
3
$6
append
$4
key1
$7
World!
*
2
$3
del
$4
key1
```
如您所见,最后的那一条
`DEL`
指令不见了,因为它没有对数据集进行任何修改。
就是这么简单。当 Redis 收到客户端修改指令后,会先进行参数校验、逻辑处理,如果没问题,就
**立即**
将该指令文本
**存储**
到 AOF 日志中,也就是说,
**先执行指令再将日志存盘**
。这一点不同于
`MySQL`
、
`LevelDB`
、
`HBase`
等存储引擎,如果我们先存储日志再做逻辑处理,这样就可以保证即使宕机了,我们仍然可以通过之前保存的日志恢复到之前的数据状态,但是
**Redis 为什么没有这么做呢?**
> Emmm... 没找到特别满意的答案,引用一条来自知乎上的回答吧:
> - **@缘于专注** - 我甚至觉得没有什么特别的原因。仅仅是因为,由于AOF文件会比较大,为了避免写入无效指令(错误指令),必须先做指令检查?如何检查,只能先执行了。因为语法级别检查并不能保证指令的有效性,比如删除一个不存在的key。而MySQL这种是因为它本身就维护了所有的表的信息,所以可以语法检查后过滤掉大部分无效指令直接记录日志,然后再执行。
> - 更多讨论参见:[为什么Redis先执行指令,再记录AOF日志,而不是像其它存储引擎一样反过来呢? - https://www.zhihu.com/question/342427472](https://www.zhihu.com/question/342427472)
### AOF 重写
![](
https://upload-images.jianshu.io/upload_images/7896890-c21e2a37892ee989.jpg?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
**Redis**
在长期运行的过程中,AOF 的日志会越变越长。如果实例宕机重启,重放整个 AOF 日志会非常耗时,导致长时间 Redis 无法对外提供服务。所以需要对
**AOF 日志 "瘦身"**
。
**Redis**
提供了
`bgrewriteaof`
指令用于对 AOF 日志进行瘦身。其
**原理**
就是
**开辟一个子进程**
对内存进行
**遍历**
转换成一系列 Redis 的操作指令,
**序列化到一个新的 AOF 日志文件**
中。序列化完毕后再将操作期间发生的
**增量 AOF 日志**
追加到这个新的 AOF 日志文件中,追加完毕后就立即替代旧的 AOF 日志文件了,瘦身工作就完成了。
### fsync
![](
https://upload-images.jianshu.io/upload_images/7896890-384a546b5bf6b86d.gif?imageMogr2/auto-orient/strip
)
AOF 日志是以文件的形式存在的,当程序对 AOF 日志文件进行写操作时,实际上是将内容写到了内核为文件描述符分配的一个内存缓存中,然后内核会异步将脏数据刷回到磁盘的。
就像我们
*上方第四步*
描述的那样,我们需要借助
`glibc`
提供的
`fsync(int fd)`
函数来讲指定的文件内容
**强制从内核缓存刷到磁盘**
。但
**"强制开车"**
仍然是一个很消耗资源的一个过程,需要
**"节制"**
!通常来说,生产环境的服务器,Redis 每隔 1s 左右执行一次
`fsync`
操作就可以了。
Redis 同样也提供了另外两种策略,一个是
**永不 `fsync`**
,来让操作系统来决定合适同步磁盘,很不安全,另一个是
**来一个指令就 `fsync` 一次**
,非常慢。但是在生产环境基本不会使用,了解一下即可。
## Redis 4.0 混合持久化
![](
https://upload-images.jianshu.io/upload_images/7896890-7de9f7706be6216c.gif?imageMogr2/auto-orient/strip
)
重启 Redis 时,我们很少使用
`rdb`
来恢复内存状态,因为会丢失大量数据。我们通常使用 AOF 日志重放,但是重放 AOF 日志性能相对
`rdb`
来说要慢很多,这样在 Redis 实例很大的情况下,启动需要花费很长的时间。
**Redis 4.0**
为了解决这个问题,带来了一个新的持久化选项——
**混合持久化**
。将
`rdb`
文件的内容和增量的 AOF 日志文件存在一起。这里的 AOF 日志不再是全量的日志,而是
**自持久化开始到持久化结束**
的这段时间发生的增量 AOF 日志,通常这部分 AOF 日志很小:
![](
https://upload-images.jianshu.io/upload_images/7896890-2f7887f84eaa34d9.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240
)
于是在 Redis 重启的时候,可以先加载
`rdb`
的内容,然后再重放增量 AOF 日志就可以完全替代之前的 AOF 全量文件重放,重启效率因此大幅得到提升。
# 相关阅读
1.
Redis(1)——5种基本数据结构 -
[
https://www.wmyskxz.com/2020/02/28/redis-1-5-chong-ji-ben-shu-ju-jie-gou/
](
https://www.wmyskxz.com/2020/02/28/redis-1-5-chong-ji-ben-shu-ju-jie-gou/
)
2.
Redis(2)——跳跃表 -
[
https://www.wmyskxz.com/2020/02/29/redis-2-tiao-yue-biao/
](
https://www.wmyskxz.com/2020/02/29/redis-2-tiao-yue-biao/
)
3.
Redis(3)——分布式锁深入探究 -
[
https://www.wmyskxz.com/2020/03/01/redis-3/
](
https://www.wmyskxz.com/2020/03/01/redis-3/
)
4.
Reids(4)——神奇的HyperLoglog解决统计问题 -
[
https://www.wmyskxz.com/2020/03/02/reids-4-shen-qi-de-hyperloglog-jie-jue-tong-ji-wen-ti/
](
https://www.wmyskxz.com/2020/03/02/reids-4-shen-qi-de-hyperloglog-jie-jue-tong-ji-wen-ti/
)
5.
Redis(5)——亿级数据过滤和布隆过滤器 -
[
https://www.wmyskxz.com/2020/03/11/redis-5-yi-ji-shu-ju-guo-lu-he-bu-long-guo-lu-qi/
](
https://www.wmyskxz.com/2020/03/11/redis-5-yi-ji-shu-ju-guo-lu-he-bu-long-guo-lu-qi/
)
6.
Redis(6)——GeoHash查找附近的人
[
https://www.wmyskxz.com/2020/03/12/redis-6-geohash-cha-zhao-fu-jin-de-ren/
](
https://www.wmyskxz.com/2020/03/12/redis-6-geohash-cha-zhao-fu-jin-de-ren/
)
# 扩展阅读
1.
Redis 数据备份与恢复 | 菜鸟教程 -
[
https://www.runoob.com/redis/redis-backup.html
](
https://www.runoob.com/redis/redis-backup.html
)
2.
Java Fork/Join 框架 -
[
https://www.cnblogs.com/cjsblog/p/9078341.html
](
https://www.cnblogs.com/cjsblog/p/9078341.html
)
# 参考资料
1.
Redis persistence demystified | antirez weblog (作者博客) -
[
http://oldblog.antirez.com/post/redis-persistence-demystified.html
](
http://oldblog.antirez.com/post/redis-persistence-demystified.html
)
2.
操作系统 — fork()函数的使用与底层原理 -
[
https://blog.csdn.net/Dawn_sf/article/details/78709839
](
https://blog.csdn.net/Dawn_sf/article/details/78709839
)
3.
磁盘和内存读写简单原理 -
[
https://blog.csdn.net/zhanghongzheng3213/article/details/54141202
](
https://blog.csdn.net/zhanghongzheng3213/article/details/54141202
)
docs/database/Redis/redis-collection/Redis(8)——发布订阅与Stream.md
0 → 100644
浏览文件 @
0de8ebb8
此差异已折叠。
点击以展开。
docs/database/Redis/redis-collection/Redis(9)——集群入门实践教程.md
0 → 100644
浏览文件 @
0de8ebb8
此差异已折叠。
点击以展开。
docs/database/Redis/redis-collection/Reids(4)——神奇的HyperLoglog解决统计问题.md
0 → 100644
浏览文件 @
0de8ebb8
此差异已折叠。
点击以展开。
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录