我摊牌了，这篇文章，值得99%的人收藏！！！
阅读时间较长，后续会设置成仅粉丝可见，建议收藏起来慢慢看！！！
原创不易，千万不要白嫖，真香警告⚠️。
本文评论区会送出两本我精挑细选的Redis著作，想要的兄弟们评论区留言！！！
《Redis深度历险》
《Redis设计与实现》
目录
6.1 Redis安装布隆(Bloom Filter)过滤器
8.2 LFU(Least Frequently Used)
10.3 CentOS 7单机安装Redis Cluster(3主3从伪集群)
- 增量同步中对于断线重连后的复制，会根据情况采取不同措施；如果条件允许，仍然只发送从服务缺失的部分数据。
1、入门
1.1 安装
1.1.1 创建安装目录
为了方便管理我们一般统一软件的安装目录，这里选择安装的目录是 ->
/usr/local/soft
1.1.2 下载Redis
我们通过wget命令从redis官网下载压缩包 -> Redis
当前最新版本下载地址 -> https://download.redis.io/releases/redis-6.2.4.tar.gz
cd /usr/local/soft
wget https://download.redis.io/releases/
1.1.3 解压
tar -zxvf redis-6.2.4.tar.gz
1.1.4 安装gcc依赖
Redis是C语言编写，编译需要GCC
Redis6.x.x版本支持了多线程，需要gcc的版本大于4.9，我们需要查看默认GCC版本，如果版本过低则需要升级
gcc -v
我的新安装的虚拟机CentOS显示 ->
证明我的没有安装gcc，安装gcc ->
yum install gcc
再次查看安装后的版本，发现是4.8.5，这个是CentOS默认的版本，我们需要对gcc进行升级 ->
yum -y install centos-release-scl
yum -y install devtoolset-9-gcc devtoolset-9-gcc-c++ devtoolset-9-binutils
scl enable devtoolset-9 bash
echo "source /opt/rh/devtoolset-9/enable" >>/etc/profile
查看升级后的版本 ->
1.1.5 编译安装
cd redis-6.2.4/src
make install
编译过程如下 ->
看到如下结果输出则编译成功 ->
或者在src目录下出现服务端和客户端的脚本 ->
redis-sentinel
redis-server
redis-cli
1.1.6 修改配置文件
Redis的配置文件在解压目录下的 redis.conf
1.1.6.1 首先设置后台启动，防止窗口一关闭服务就挂掉
默认后台启动参数为 no->
# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
# When Redis is supervised by upstart or systemd, this parameter has no impact.
daemonize no
修改成 yes->
# By default Redis does not run as a daemon. Use 'yes' if you need it.
# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
# When Redis is supervised by upstart or systemd, this parameter has no impact.
daemonize yes
1.1.6.2 允许其他主机访问
根据Redis的文档配置注释，我们要运行其他主机访问有多种方式 ->
- 可以选择配置访问主机的IP address
- bind * -::* 相当于允许所有其它主机访问
- bind 0.0.0.0 相当于允许所有其它主机访问
- 直接注释 相当于允许所有其它主机访问
# bind 192.168.1.100 10.0.0.1 # listens on two specific IPv4 addresses
# bind 127.0.0.1 ::1 # listens on loopback IPv4 and IPv6
# bind * -::* # like the default, all available interfaces
我的处理方式，安装文档的注释来配置
1.1.6.3 配置访问密码
如果是要考虑安全性，一定要配置密码，找到requirepass配置处，新增如下配置（阿里云等云服务其外网访问一定要配置，作者被黑过，整台服务器重启都无法重启，损失惨重，但是穷，官方处理需要Money，建议这里一定要谨慎）
requirepass yourpassword
1.1.7 启动Redis
使用redis-server 来启动，启动的方式如下->
/usr/local/soft/redis-6.2.4/src/redis-server /usr/local/soft/redis-6.2.4/redis.conf
或者这个也一样 ->
cd /src
redis-server ../redis.conf
查看端口是否启动成功 ->
netstat -an|grep 6379
1.1.8 客户端
进入客户端的方式如下 ->
/usr/local/soft/redis-6.2.4/src/redis-cli
1.1.9 停止Redis
停止Redis有两种方式 ：
方式一，在客户端中执行SHUTDOWN
SHUTDOWN
方式二，暴力kill -9
ps -aux | grep redis
kill -9 57927
1.1.10 配置别名
为了方便启动Redis和进入客户端，我们可以通过配置别名来实现
vim ~/.bashrc
添加如下配置，
- 注意''很重要
- redis与rcli后面的=两边不能有空格
alias redis='/usr/local/soft/redis-6.2.4/src/redis-server /usr/local/soft/redis-6.2.4/redis.conf'
alias rcli='/usr/local/soft/redis-6.2.4/src/redis-cli'
使配置生效
source ~/.bashrc
现在我们可以通过redis启动Redis服务，使用rcli进入Redis客户端
2、五大基本数据类型
2.1 String
2.1.1 简介
Redis中所有的的数据结构都是通过一个唯一的字符串key来获取相应的value数据。
Redis有5种基础数据结构，分别是：
- string（字符串）
- list（列表）
- hash（字典）
- set（集合）
- zset（有序集合）
本小结讲述的是Redis的5种基础数据结构中的string(字符串)
2.1.2 string(字符串)相关介绍
2.1.2.1 string(字符串)的内部结构
string(字符串)是Redis最简单也是使用最广泛的数据结构，它的内部是一个字符数组。如图所示：
Redis中string(字符串)是动态字符串，允许修改；它在结构上的实现类似于Java中的ArrayList（默认构造一个大小为10的初始数组），这是冗余分配内存的思想，也称为预分配；这种思想可以减少扩容带来的性能消耗。
2.1.2.2 string(字符串)的扩容
当string(字符串)的大小达到扩容阈值时，将会对string(字符串)进行扩容，string(字符串)的扩容主要有以下几个点：
- 长度小于1MB，扩容后为原先的两倍; length = length * 2
- 长度大于1MB，扩容后增加1MB; length = length + 1MB
- 字符串的长度最大值为 512MB
2.1.3 string(字符串)的指令
2.1.3.1 单个键值对增删改查操作
set -> key 不存在则新增，存在则修改
set key value
get -> 查询，返回对应key的value，不存在返回(nil)
get key
del -> 删除指定的key(key可以是多个)
del key [key …]
示例：
127.0.0.1:6379> set name liziba
OK
127.0.0.1:6379> get name
"liziba"
127.0.0.1:6379> set name liziba001
OK
127.0.0.1:6379> get name
"liziba001"
127.0.0.1:6379> del name
(integer) 1
127.0.0.1:6379> get name
(nil)
2.1.3.2 批量键值对
批量键值读取和写入最大的优势在于节省网络传输开销
mset -> 批量插入
mset key value [key value …]
mget -> 批量获取
mget key [key …]
示例：
127.0.0.1:6379> mset name1 liziba1 name2 liziba2 name3 liziba3
OK
127.0.0.1:6379> mget name1 name2 name3
1) "liziba1"
2) "liziba2"
3) "liziba3"
2.1.3.3 过期set命令
过期set是通过设置一个缓存key的过期时间，使得缓存到期后自动删除从而失效的机制。
方式一：
expire key seconds
示例：
127.0.0.1:6379> set name liziba
OK
127.0.0.1:6379> get name
"liziba"
127.0.0.1:6379> expire name 10 # 10s 后get name 返回 nil
(integer) 1
127.0.0.1:6379> get name
(nil)
方式二：
setex key seconds value
示例：
127.0.0.1:6379> setex name 10 liziba # 10s 后get name 返回 nil
OK
127.0.0.1:6379> get name
(nil)
2.1.3.4 不存在创建存在不更新
上面的set操作不存在创建，存在则更新；此时如果需要存在不更新的场景，那么可以使用如下这个指令
setnx -> 不存在创建存在不更新
setnx key value
示例：
127.0.0.1:6379> get name
(nil)
127.0.0.1:6379> setnx name liziba
(integer) 1
127.0.0.1:6379> get name
"liziba"
127.0.0.1:6379> setnx name liziba_98 # 已经存在再次设值，失败
(integer) 0
127.0.0.1:6379> get name
"liziba"
2.1.3.5计数
string(字符串)也可以用来计数，前提是value是一个整数，那么可以对它进行自增的操作。自增的范围必须在signed long的区间访问内，[-9223372036854775808,9223372036854775808]
2.1.3.5.1 incr -> 自增1
incr key
示例：
127.0.0.1:6379> set fans 1000
OK
127.0.0.1:6379> incr fans # 自增1
(integer) 1001
2.1.3.5.2 incrby -> 自定义累加值
incrby key increment
127.0.0.1:6379> set fans 1000
OK
127.0.0.1:6379> incr fans
(integer) 1001
127.0.0.1:6379> incrby fans 999
(integer) 2000
2.1.3.5.3 测试value为整数的自增区间
最大值：
127.0.0.1:6379> set fans 9223372036854775808
OK
127.0.0.1:6379> incr fans
(error) ERR value is not an integer or out of range
最小值：
127.0.0.1:6379> set money -9223372036854775808
OK
127.0.0.1:6379> incrby money -1
(error) ERR increment or decrement would overflow
2.2 list
2.2.1 简介
Redis中所有的的数据结构都是通过一个唯一的字符串key来获取相应的value数据。
Redis有5种基础数据结构，分别是：
- string（字符串）
- list（列表）
- hash（字典）
- set（集合）
- zset（有序集合）
其中list、set、hash、zset这四种数据结构是容器型数据结构，它们共享下面两条通用规则：
- create if not exists：容器不存在则创建
- drop if no elements：如果容器中没有元素，则立即删除容器，释放内存
本小结讲述的是Redis的5种基础数据结构中的list(列表)
2.2.2 list(列表)相关介绍
2.2.2.1 list(列表)的内部结构
Redis的列表相当于Java语言中的LinkedList，它是一个双向链表数据结构（但是这个结构设计比较巧妙，后面会介绍），支持前后顺序遍历。链表结构插入和删除操作快，时间复杂度O(1)，查询慢，时间复杂度O(n)。
2.2.2.2 list(列表)的使用场景
根据Redis双向列表的特性，因此其也被用于异步队列的使用。实际开发中将需要延后处理的任务结构体序列化成字符串，放入Redis的队列中，另一个线程从这个列表中获取数据进行后续处理。其流程类似如下的图：
2.2.3 list(列表)的指令
2.2.3.1 右进左出—队列
队列在结构上是先进先出（FIFO）的数据结构（比如排队购票的顺序），常用于消息队列类似的功能，例如消息排队、异步处理等场景。通过它可以确保元素的访问顺序。
lpush -> 从左边边添加元素
lpush key value [value …]
rpush -> 从右边添加元素
rpush key value [value …]
llen -> 获取列表的长度
llen key
lpop -> 从左边弹出元素
lpop key
127.0.0.1:6379> rpush code java c python # 向列表中添加元素
(integer) 3
127.0.0.1:6379> llen code # 获取列表长度
(integer) 3
127.0.0.1:6379> lpop code # 弹出最先添加的元素
"java"
127.0.0.1:6379> lpop code
"c"
127.0.0.1:6379> lpop code
"python"
127.0.0.1:6379> llen code
(integer) 0
127.0.0.1:6379> lpop code
(nil)
2.2.3.2 右进右出——栈
栈在结构上是先进后出（FILO）的数据结构（比如弹夹压入子弹，子弹被射击出去的顺序就是栈），这种数据结构一般用来逆序输出。
lpush -> 从左边边添加元素
lpush key value [value …]
rpush -> 从右边添加元素
rpush key value [value …]
rpop -> 从右边弹出元素
rpop code
127.0.0.1:6379> rpush code java c python
(integer) 3
127.0.0.1:6379> rpop code # 弹出最后添加的元素
"python"
127.0.0.1:6379> rpop code
"c"
127.0.0.1:6379> rpop code
"java"
127.0.0.1:6379> rpop code
(nil)
2.2.3.3 慢操作
列表(list)是个链表数据结构，它的遍历是慢操作，所以涉及到遍历的性能将会遍历区间range的增大而增大。注意list的索引运行为负数，-1代表倒数第一个，-2代表倒数第二个，其它同理。
lindex -> 遍历获取列表指定索引处的值
lindex key ind
lrange -> 获取从索引start到stop处的全部值
lrange key start stop
ltrim -> 截取索引start到stop处的全部值，其它将会被删除
ltrim key start stop
127.0.0.1:6379> rpush code java c python
(integer) 3
127.0.0.1:6379> lindex code 0 # 获取索引为0的数据
"java"
127.0.0.1:6379> lindex code 1 # 获取索引为1的数据
"c"
127.0.0.1:6379> lindex code 2 # 获取索引为2的数据
"python"
127.0.0.1:6379> lrange code 0 -1 # 获取全部 0 到倒数第一个数据 == 获取全部数据
1) "java"
2) "c"
3) "python"
127.0.0.1:6379> ltrim code 0 -1 # 截取并保理 0 到 -1 的数据 == 保理全部
OK
127.0.0.1:6379> lrange code 0 -1
1) "java"
2) "c"
3) "python"
127.0.0.1:6379> ltrim code 1 -1 # 截取并保理 1 到 -1 的数据 == 移除了索引为0的数据 java
OK
127.0.0.1:6379> lrange code 0 -1
1) "c"
2) "python"
2.2.4 list(列表)深入理解
Redis底层存储list(列表)不是一个简单的LinkedList，而是quicklist ——“快速列表”。关于quicklist是什么，下面会简单介绍，具体源码我也还在学习中，后面大家一起探讨。
quicklist是多个ziplist(压缩列表)组成的双向列表；而这个ziplist(压缩列表)又是什么呢？ziplist指的是一块连续的内存存储空间，Redis底层对于list(列表)的存储，当元素个数少的时候，它会使用一块连续的内存空间来存储，这样可以减少每个元素增加prev和next指针带来的内存消耗，最重要的是可以减少内存碎片化问题。
2.2.4.1 常见的链表结构示意图
每个node节点元素，都会持有一个prev->执行前一个node节点和next->指向后一个node节点的指针（引用），这种结构虽然支持前后顺序遍历，但是也带来了不小的内存开销，如果node节点仅仅是一个int类型的值，那么可想而知，引用的内存比例将会更大。
2.2.4.2 ziplist示意图
ziplist是一块连续的内存地址，他们之间无需持有prev和next指针，能通过地址顺序寻址访问。
2.2.4.3 quicklist示意图
quicklist是由多个ziplist组成的双向链表。
2.3 hash(字典)
2.3.1 简介
Redis中所有的的数据结构都是通过一个唯一的字符串key来获取相应的value数据。
Redis有5种基础数据结构，分别是：
- string（字符串）
- list（列表）
- hash（字典）
- set（集合）
- zset（有序集合）
其中list、set、hash、zset这四种数据结构是容器型数据结构，它们共享下面两条通用规则：
- create if not exists：容器不存在则创建
- drop if no elements：如果容器中没有元素，则立即删除容器，释放内存
本小节讲述的是Redis的5种基础数据结构中的hash(字典)
2.3.2 hash(字典)相关介绍
2.3.2.1 hash(字典)的内部结构
Redis的hash(字典)相当于Java语言中的HashMap，它是根据散列值分布的无序字典，内部的元素是通过键值对的方式存储。
hash(字典)的实现与Java中的HashMap（JDK1.7）的结构也是一致的，它的数据结构也是数组+链表组成的二维结构，节点元素散列在数组上，如果发生hash碰撞则使用链表串联在数组节点上。
2.3.2.2 hash(字典)扩容
Redis中的hash(字典)存储的value只能是字符串值，此外扩容与Java中的HashMap也不同。Java中的HashMap在扩容的时候是一次性完成的，而Redis考虑到其核心存取是单线程的性能问题，为了追求高性能，因而采取了渐进式rehash策略。
渐进式rehash指的是并非一次性完成，它是多次完成的，因此需要保理旧的hash结构，所以Redis中的hash(字典)会存在新旧两个hash结构，在rehash结束后也就是旧hash的值全部搬迁到新hash之后，新的hash在功能上才会完全替代以前的hash。
2.3.2.3 hash(字典)的相关使用场景
hash(字典)可以用来存储对象的相关信息，一个hash(字典)代表一个对象，hash的一个key代表对象的一个属性，key的值代表属性的值。hash(字典)结构相比字符串来说，它无需将整个对象进行序列化后进行存储。这样在获取的时候可以进行部分获取。所以相比之下hash(字典)具有如下的优缺点：
- 读取可以部分读取，节省网络流量
- 存储消耗的高于单个字符串的存储
2.3.3 hash(字典)相关指令
2.3.3.1 hash(字典)常用指令
hset -> hash(字典)插入值，字典不存在则创建 key代表字典名称，field 相当于 key，value是key的值
hset key field value
hmset -> 批量设值
hmset key field value [field value …]
示例：
7.0.0.1:6379> hset book java "Thinking in Java" # 字符串包含空格需要""包裹
(integer) 1
127.0.0.1:6379> hset book python "Python code"
(integer) 1
127.0.0.1:6379> hset book c "The best of c"
(integer) 1
127.0.0.1:6379> hmset book go "concurrency in go" mysql "high-performance MySQL" # 批量设值
OK
hget -> 获取字典中的指定key的value
hget key field
hgetall -> 获取字典中所有的key和value，换行输出
hgetall key
示例：
127.0.0.1:6379> hget book java
"Thinking in Java"
127.0.0.1:6379> hgetall book
1) "java"
2) "Thinking in Java"
3) "python"
4) "Python code"
5) "c"
6) "The best of c"
hlen -> 获取指定字典的key的个数
hlen key
举例：
127.0.0.1:6379> hlen book
(integer) 5
2.3.3.2 hash(字典)使用小技巧
在string(字符串)中可以使用incr和incrby对value是整数的字符串进行自加操作，在hash(字典)结构中如果单个子key是整数也可以进行自加操作。
hincrby -> 增对hash(字典)中的某个key的整数value进行自加操作
hincrby key field increment
127.0.0.1:6379> hset liziba money 10
(integer) 1
127.0.0.1:6379> hincrby liziba money -1
(integer) 9
127.0.0.1:6379> hget liziba money
"9"
注意如果不是整数会报错。
127.0.0.1:6379> hset liziba money 10.1
(integer) 1
127.0.0.1:6379> hincrby liziba money 1
(error) ERR hash value is not an integer
2.4 set(集合)
2.4.1 简介
Redis中所有的的数据结构都是通过一个唯一的字符串key来获取相应的value数据。
Redis有5种基础数据结构，分别是：
- string（字符串）
- list（列表）
- hash（字典）
- set（集合）
- zset（有序集合）
其中list、set、hash、zset这四种数据结构是容器型数据结构，它们共享下面两条通用规则：
- create if not exists：容器不存在则创建
- drop if no elements：如果容器中没有元素，则立即删除容器，释放内存
本文讲述的是Redis的5种基础数据结构中的set(集合)
2.4.2 set(集合)相关介绍
2.4.2.1 set(集合)的内部结构
Redis的set(集合)相当于Java语言里的HashSet，它内部的键值对是无序的、唯一的。它的内部实现了一个所有value为null的特殊字典。
集合中的最后一个元素被移除之后，数据结构被自动删除，内存被回收。
2.4.2.2 set(集合)的使用场景
set(集合)由于其特殊去重复的功能，我们可以用来存储活动中中奖的用户的ID，这样可以保证一个用户不会中奖两次。
2.4.3 set(集合)相关指令
sadd -> 添加集合成员，key值集合名称，member值集合元素，元素不能重复
sadd key member [member …]
127.0.0.1:6379> sadd name zhangsan
(integer) 1
127.0.0.1:6379> sadd name zhangsan # 不能重复，重复返回0
(integer) 0
127.0.0.1:6379> sadd name lisi wangwu liumazi # 支持一次添加多个元素
(integer) 3
smembers -> 查看集合中所有的元素，注意是无序的
smembers key
127.0.0.1:6379> smembers name # 无序输出集合中所有的元素
1) "lisi"
2) "wangwu"
3) "liumazi"
4) "zhangsan"
sismember -> 查询集合中是否包含某个元素
sismember key member
127.0.0.1:6379> sismember name lisi # 包含返回1
(integer) 1
127.0.0.1:6379> sismember name tianqi # 不包含返回0
(integer) 0
scard -> 获取集合的长度
scard key
127.0.0.1:6379> scard name
(integer) 4
spop -> 弹出元素，count指弹出元素的个数
spop key [count]
127.0.0.1:6379> spop name # 默认弹出一个
"wangwu"
127.0.0.1:6379> spop name 3
1) "lisi"
2) "zhangsan"
3) "liumazi"
2.5 zset(有序集合)
2.5.1 简介
Redis中所有的的数据结构都是通过一个唯一的字符串key来获取相应的value数据。
Redis有5种基础数据结构，分别是：
- string（字符串）
- list（列表）
- hash（字典）
- set（集合）
- zset（有序集合）
其中list、set、hash、zset这四种数据结构是容器型数据结构，它们共享下面两条通用规则：
- create if not exists：容器不存在则创建
- drop if no elements：如果容器中没有元素，则立即删除容器，释放内存
本文讲述的是Redis的5种基础数据结构中的zset(有序列表)
2.5.2 zset(有序集合)相关介绍
2.5.2.1 zset(有序集合)的内部结构
zset(有序集合)是Redis中最常问的数据结构。它类似于Java语言中的SortedSet和HashMap的结合体，它一方面通过set来保证内部value值的唯一性，另一方面通过value的score（权重）来进行排序。这个排序的功能是通过Skip List（跳跃列表）来实现的。
zset(有序集合)的最后一个元素value被移除后，数据结构被自动删除，内存被回收。
2.5.2.2 zset(有序集合)的相关使用场景
利用zset的去重和有序的效果可以由很多使用场景，举两个例子：
- 存储粉丝列表，value是粉丝的ID，score是关注时间戳，这样可以对粉丝关注进行排序
- 存储学生成绩，value使学生的ID，score是学生的成绩，这样可以对学生的成绩排名
2.5.3 zset(有序集合)相关指令
1、zadd -> 向集合中添加元素，集合不存在则新建，key代表zset集合名称，score代表元素的权重，member代表元素
zadd key [NX|XX] [CH] [INCR] score member [score member …]
127.0.0.1:6379> zadd name 10 zhangsan
(integer) 1
127.0.0.1:6379> zadd name 10.1 lisi
(integer) 1
127.0.0.1:6379> zadd name 9.9 wangwu
(integer) 1
2、zrange -> 按照score权重从小到大排序输出集合中的元素，权重相同则按照value的字典顺序排序(lexicographical order )
超出范围的下标并不会引起错误。 比如说，当 start 的值比有序集的最大下标还要大，或是 start > stop 时， zrange 命令只是简单地返回一个空列表。 另一方面，假如 stop 参数的值比有序集的最大下标还要大，那么 Redis 将 stop 当作最大下标来处理。
可以通过使用 WITHSCORES 选项，来让成员和它的 score 值一并返回，返回列表以 value1,score1, …, valueN,scoreN 的格式表示。 客户端库可能会返回一些更复杂的数据类型，比如数组、元组等。
zrange key start stop [WITHSCORES]
127.0.0.1:6379> zrange name 0 -1 # 获取所有元素，按照score的升序输出
1) "wangwu"
2) "zhangsan"
3) "lisi"
127.0.0.1:6379> zrange name 0 1 # 获取第一个和第二个slot的元素
1) "wangwu"
2) "zhangsan"
127.0.0.1:6379> zadd name 10 tianqi # 在上面的基础上添加score为10的元素
(integer) 1
127.0.0.1:6379> zrange name 0 2 # key相等则按照value字典排序输出
1) "wangwu"
2) "tianqi"
3) "zhangsan"
127.0.0.1:6379> zrange name 0 -1 WITHSCORES # WITHSCORES 输出权重
1) "wangwu"
2) "9.9000000000000004"
3) "tianqi"
4) "10"
5) "zhangsan"
6) "10"
7) "lisi"
8) "10.1"
3、zrevrange -> 按照score权重从大到小输出集合中的元素，权重相同则按照value的字典逆序排序
其中成员的位置按 score 值递减(从大到小)来排列。 具有相同 score 值的成员按字典序的逆序(reverse lexicographical order)排列。除了成员按 score 值递减的次序排列这一点外， ZREVRANGE 命令的其他方面和 ZRANGE key start stop [WITHSCORES] 命令一样。
zrevrange key start stop [WITHSCORES]
127.0.0.1:6379> zrevrange name 0 -1 WITHSCORES
1) "lisi"
2) "10.1"
3) "zhangsan"
4) "10"
5) "tianqi"
6) "10"
7) "wangwu"
8) "9.9000000000000004"
4、zcard -> 当 key 存在且是有序集类型时，返回有序集的基数。 当 key 不存在时，返回 0
zcard key
127.0.0.1:6379> zcard name
(integer) 4
5、zscore -> 返回有序集 key 中，成员 member 的 score 值，如果 member 元素不是有序集 key 的成员，或 key 不存在，返回 nil
zscore key member z
127.0.0.1:6379> zscore name zhangsan
"10"
127.0.0.1:6379> zscore name liziba
(nil)
6、zrank -> 返回有序集 key 中成员 member 的排名。其中有序集成员按 score 值递增(从小到大)顺序排列。
排名以 0 为底，也就是说， score 值最小的成员排名为 0
zrank key member
127.0.0.1:6379> zrange name 0 -1
1) "wangwu"
2) "tianqi"
3) "zhangsan"
4) "lisi"
127.0.0.1:6379> zrank name wangwu
(integer) 0
7、zrangebyscore -> 返回有序集 key 中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
min 和 max 可以是 -inf 和 +inf ，这样一来，你就可以在不知道有序集的最低和最高 score 值的情况下，使用 *ZRANGEBYSCORE这类命令。
默认情况下，区间的取值使用闭区间 (小于等于或大于等于)，你也可以通过给参数前增加 ( 符号来使用可选的开区间 (小于或大于)
zrangebyscore key min max [WITHSCORES] [LIMIT offset count]
127.0.0.1:6379> zrange name 0 -1 WITHSCORES # 输出全部元素
1) "wangwu"
2) "9.9000000000000004"
3) "tianqi"
4) "10"
5) "zhangsan"
6) "10"
7) "lisi"
8) "10.1"
127.0.0.1:6379> zrangebyscore name 9 10
1) "wangwu"
2) "tianqi"
3) "zhangsan"
127.0.0.1:6379> zrangebyscore name 9 10 WITHSCORES # 输出分数
1) "wangwu"
2) "9.9000000000000004"
3) "tianqi"
4) "10"
5) "zhangsan"
6) "10"
127.0.0.1:6379> zrangebyscore name -inf 10 # -inf 从负无穷开始
1) "wangwu"
2) "tianqi"
3) "zhangsan"
127.0.0.1:6379> zrangebyscore name -inf +inf # +inf 直到正无穷
1) "wangwu"
2) "tianqi"
3) "zhangsan"
4) "lisi"
127.0.0.1:6379> zrangebyscore name (10 11 # 10 < score <=11
1) "lisi"
127.0.0.1:6379> zrangebyscore name (10 (10.1 # 10 < socre < -11
(empty list or set)
127.0.0.1:6379> zrangebyscore name (10 (11
1) "lisi"
8、zrem -> 移除有序集 key 中的一个或多个成员，不存在的成员将被忽略
zrem key member [member …]
127.0.0.1:6379> zrange name 0 -1
1) "wangwu"
2) "tianqi"
3) "zhangsan"
4) "lisi"
127.0.0.1:6379> zrem name zhangsan # 移除元素
(integer) 1
127.0.0.1:6379> zrange name 0 -1
1) "wangwu"
2) "tianqi"
3) "lisi"
2.6 跳跃列表
2.6.1 简介
跳表全称叫做跳跃表，简称跳表。跳表是一个随机化的数据结构，实质就是一种可以进行二分查找的有序链表。跳表在原有的有序链表上面增加了多级索引，通过索引来实现快速查找。跳表不仅能提高搜索性能，同时也可以提高插入和删除操作的性能。
Skip List(跳跃列表)这种随机的数据结构，可以看做是一个二叉树的变种，它在性能上与红黑树、AVL树很相近；但是Skip List(跳跃列表)的实现相比前两者要简单很多，目前Redis的zset实现采用了Skip List(跳跃列表)（其它还有LevelDB等也使用了跳跃列表）。
RBT红黑树与Skip List(跳跃列表)简单对比：
RBT红黑树
- 插入、查询时间复杂度O(logn)
- 数据天然有序
- 实现复杂，设计变色、左旋右旋平衡等操作
- 需要加锁
Skip List跳跃列表
- 插入、查询时间复杂度O(logn)
- 数据天然有序
- 实现简单，链表结构
- 无需加锁
2.6.2 Skip List算法分析
2.6.2.1 Skip List论文
这里贴出Skip List的论文，需要详细研究的请看论文，下文部分公式、代码、图片出自该论文。
Skip Lists: A Probabilistic Alternative to Balanced Trees
https://www.cl.cam.ac.uk/teaching/2005/Algorithms/skiplists.pdf
2.6.2.2 Skip List动态图
先通过一张动图来了解Skip List的插入节点元素的流程，此图来自维基百科。
2.6.2.3 Skip List算法性能分析
2.6.2.3.1 计算随机层数算法
首先分析的是执行插入操作时计算随机数的过程，这个过程会涉及层数的计算，所以十分重要。对于节点他有如下特性：
- 节点都有第一层的指针
- 节点有第i层指针，那么第i+1层出现的概率为p
- 节点有最大层数限制，MaxLevel
计算随机层数的伪代码：
论文中的示例
Java版本
public int randomLevel(){
int level = 1;
// random()返回一个[0...1)的随机数
while (random() < p && level < MaxLevel){
level += 1;
}
return level;
}
代码中包含两个变量P和MaxLevel，在Redis中这两个参数的值分别是：
p = 1/4
MaxLevel = 64
2.3.2 节点包含的平均指针数目
Skip List属于空间换时间的数据结构，这里的空间指的就是每个节点包含的指针数目，这一部分是额外的内内存开销，可以用来度量空间复杂度。random()是个随机数，因此产生越高的节点层数，概率越低（Redis标准源码中的晋升率数据1/4，相对来说Skip List的结构是比较扁平的，层高相对较低）。其定量分析如下：
- level = 1 概率为1-p
- level >=2 概率为p
- level = 2 概率为p(1-p)
- level >= 3 概率为p^2
- level = 3 概率为p^2(1-p)
- level >=4 概率为p^3
- level = 4 概率为p^3(1-p)
- ……
得出节点的平均层数（节点包含的平均指针数目）：
所以Redis中p=1/4计算的平均指针数目为1.33
2.3.3 时间复杂度计算
以下推算来自论文内容
假设p=1/2，在以p=1/2生成的16个元素的跳过列表中，我们可能碰巧具有9个元素，1级3个元素，3个元素3级元素和1个元素14级（这不太可能，但可能会发生）。我们该怎么处理这种情况？如果我们使用标准算法并在第14级开始我们的搜索，我们将会做很多无用的工作。那么我们应该从哪里开始搜索？此时我们假设SkipList中有n个元素，第L层级元素个数的期望是1/p个；每个元素出现在L层的概率是p^(L-1), 那么第L层级元素个数的期望是 n * (p^L-1)；得到1 / p =n * (p^L-1)
1 / p = n * (p^L-1)
n = (1/p)^L
L = log(1/p)^n
所以我们应该选择MaxLevel = log(1/p)^n
定义：MaxLevel = L(n) = log(1/p)^n
推算Skip List的时间复杂度，可以用逆向思维，从层数为i的节点x出发，返回起点的方式来回溯时间复杂度，节点x点存在两种情况：
- 节点x存在(i+1)层指针，那么向上爬一级，概率为p，对应下图situation c.
- 节点x不存在(i+1)层指针，那么向左爬一级，概率为1-p，对应下图situation b.
设C(k) = 在无限列表中向上攀升k个level的搜索路径的预期成本（即长度）那么推演如下：
C(0)=0
C(k)=(1-p)×(情况b的查找长度) + p×(情况c的查找长度)
C(k)=(1-p)(C(k)+1) + p(C(k-1)+1)
C(k)=1/p+C(k-1)
C(k)=k/p
上面推演的结果可知，爬升k个level的预期长度为k/p，爬升一个level的长度为1/p。
由于MaxLevel = L(n)， C(k) = k / p，因此期望值为：(L(n) – 1) / p；将L(n) = log(1/p)^n 代入可得：(log(1/p)^n - 1) / p；将p = 1 / 2 代入可得：2 * log2^n - 2，即O(logn)的时间复杂度。
2.6.3 Skip List特性及其实现
2.6.3.1 Skip List特性
Skip List跳跃列表通常具有如下这些特性
- Skip List包含多个层，每层称为一个level，level从0开始递增
- Skip List 0层，也就是最底层，应该包含所有的元素
- 每一个level/层都是一个有序的列表
- level小的层包含level大的层的元素，也就是说元素A在X层出现，那么 想X>Z>=0的level/层都应该包含元素A
- 每个节点元素由节点key、节点value和指向当前节点所在level的指针数组组成
2.6.3.2 Skip List查询
假设初始Skip List跳跃列表中已经存在这些元素，他们分布的结构如下所示：
此时查询节点88，它的查询路线如下所示：
- 从Skip List跳跃列表最顶层level3开始，往后查询到10 < 88 && 后续节点值为null && 存在下层level2
- level2 10往后遍历，27 < 88 && 后续节点值为null && 存在下层level1
- level1 27往后遍历，88 = 88，查询命中
2.6.3.3 Skip List插入
Skip List的初始结构与2.3中的初始结构一致，此时假设插入的新节点元素值为90，插入路线如下所示：
- 查询插入位置，与Skip List查询方式一致，这里需要查询的是第一个比90大的节点位置，插入在这个节点的前面， 88 < 90 < 100
- 构造一个新的节点Node(90)，为插入的节点Node(90)计算一个随机level，这里假设计算的是1，这个level时随机计算的，可能时1、2、3、4…均有可能，level越大的可能越小，主要看随机因子x ，层数的概率大致计算为 (1/x)^level ，如果level大于当前的最大level3，需要新增head和tail节点
- 节点构造完毕后，需要将其插入列表中，插入十分简单步骤 -> Node(88).next = Node(90); Node(90).prev = Node(80); Node(90).next = Node(100); Node(100).prev = Node(90);
2.6.3.4 Skip List删除
删除的流程就是查询到节点，然后删除，重新将删除节点左右两边的节点以链表的形式组合起来即可，这里不再画图
2.6.4 手写实现一个简单Skip List
实现一个Skip List比较简单，主要分为两个步骤：
- 定义Skip List的节点Node，节点之间以链表的形式存储，因此节点持有相邻节点的指针，其中prev与next是同一level的前后节点的指针，down与up是同一节点的多个level的上下节点的指针
- 定义Skip List的实现类，包含节点的插入、删除、查询，其中查询操作分为升序查询和降序查询（往后和往前查询），这里实现的Skip List默认节点之间的元素是升序链表
2.6.4.1 定义Node节点
Node节点类主要包括如下重要属性：
- score -> 节点的权重，这个与Redis中的score相同，用来节点元素的排序作用
- value -> 节点存储的真实数据，只能存储String类型的数据
- prev -> 当前节点的前驱节点，同一level
- next -> 当前节点的后继节点，同一level
- down -> 当前节点的下层节点，同一节点的不同level
- up -> 当前节点的上层节点，同一节点的不同level
package com.liziba.skiplist;
/**
* <p>
* 跳表节点元素
* </p>
*
* @Author: Liziba
* @Date: 2021/7/5 21:01
*/
public class Node {
/** 节点的分数值，根据分数值来排序 */
public Double score;
/** 节点存储的真实数据 */
public String value;
/** 当前节点的 前、后、下、上节点的引用 */
public Node prev, next, down, up;
public Node(Double score) {
this.score = score;
prev = next = down = up = null;
}
public Node(Double score, String value) {
this.score = score;
this.value = value;
}
}
2.6.4.2 SkipList节点元素的操作类
SkipList主要包括如下重要属性：
- head -> SkipList中的头节点的最上层头节点（level最大的层的头节点），这个节点不存储元素，是为了构建列表和查询时做查询起始位置的，具体的结构请看2.3中的结构
- tail -> SkipList中的尾节点的最上层尾节点（level最大的层的尾节点），这个节点也不存储元素，是查询某一个level的终止标志
- level -> 总层数
- size -> Skip List中节点元素的个数
- random -> 用于随机计算节点level，如果 random.nextDouble() < 1/2则需要增加当前节点的level，如果当前节点增加的level超过了总的level则需要增加head和tail(总level)
package com.liziba.skiplist;
import java.util.Random;
/**
* <p>
* 跳表实现
* </p>
*
* @Author: Liziba
*/
public class SkipList {
/** 最上层头节点 */
public Node head;
/** 最上层尾节点 */
public Node tail;
/** 总层数 */
public int level;
/** 元素个数 */
public int size;
public Random random;
public SkipList() {
level = size = 0;
head = new Node(null);
tail = new Node(null);
head.next = tail;
tail.prev = head;
}
/**
* 查询插入节点的前驱节点位置
*
* @param score
* @return
*/
public Node fidePervNode(Double score) {
Node p = head;
for(;;) {
// 当前层(level)往后遍历，比较score，如果小于当前值，则往后遍历
while (p.next.value == null && p.prev.score <= score)
p = p.next;
// 遍历最右节点的下一层(level)
if (p.down != null)
p = p.down;
else
break;
}
return p;
}
/**
* 插入节点，插入位置为fidePervNode(Double score)前面
*
* @param score
* @param value
*/
public void insert(Double score, String value) {
// 当前节点的前置节点
Node preNode = fidePervNode(score);
// 当前新插入的节点
Node curNode = new Node(score, value);
// 分数和值均相等则直接返回
if (curNode.value != null && preNode.value != null && preNode.value.equals(curNode.value)
&& curNode.score.equals(preNode.score)) {
return;
}
preNode.next = curNode;
preNode.next.prev = curNode;
curNode.next = preNode.next;
curNode.prev = preNode;
int curLevel = 0;
while (random.nextDouble() < 1/2) {
// 插入节点层数(level)大于等于层数(level)，则新增一层(level)
if (curLevel >= level) {
Node newHead = new Node(null);
Node newTail = new Node(null);
newHead.next = newTail;
newHead.down = head;
newTail.prev = newHead;
newTail.down = tail;
head.up = newHead;
tail.up = newTail;
// 头尾节点指针修改为新的，确保head、tail指针一直是最上层的头尾节点
head = newHead;
tail = newTail;
++level;
}
while (preNode.up == null)
preNode = preNode.prev;
preNode = preNode.up;
Node copy = new Node(null);
copy.prev = preNode;
copy.next = preNode.next;
preNode.next.prev = copy;
preNode.next = copy;
copy.down = curNode;
curNode.up = copy;
curNode = copy;
++curLevel;
}
++size;
}
/**
* 查询指定score的节点元素
* @param score
* @return
*/
public Node search(double score) {
Node p = head;
for (;;) {
while (p.next.score != null && p.next.score <= score)
p = p.next;
if (p.down != null)
p = p.down;
else // 遍历到最底层
if (p.score.equals(score))
return p;
return null;
}
}
/**
* 升序输出Skip List中的元素 （默认升序存储，因此从列表head往tail遍历）
*/
public void dumpAllAsc() {
Node p = head;
while (p.down != null) {
p = p.down;
}
while (p.next.score != null) {
System.out.println(p.next.score + "-->" + p.next.value);
p = p.next;
}
}
/**
* 降序输出Skip List中的元素
*/
public void dumpAllDesc() {
Node p = tail;
while (p.down != null) {
p = p.down;
}
while (p.prev.score != null) {
System.out.println(p.prev.score + "-->" + p.prev.value);
p = p.prev;
}
}
/**
* 删除Skip List中的节点元素
* @param score
*/
public void delete(Double score) {
Node p = search(score);
while (p != null) {
p.prev.next = p.next;
p.next.prev = p.prev;
p = p.up;
}
}
}
3、三大特殊数据类型
3.1 简介
Bitmaps、HyperLogLog、Geospatial是Redis的三大特殊数据类型，其中Bitmaps严格来说不能算一种数据类型。Bitmaps、HyperLogLog、Geospatial能轻松的解决很多问题，也是大厂面试中经常会考究的知识点。下文详细的讲述了Bitmaps、HyperLogLog、Geospatial的原理、使用等等。有需要的可以一键三连，如果有什么问题欢迎留言交流，看到一定及时回复。
3.2 Bitmaps
3.1.1 简介
Bitmaps 称为位图，它不是一种数据类型。网上很多视频教程把Bitmaps称为数据类型，应该是不正确的。Bitmaps 是Redis提供给使用者用于操作位的“数据类型”。它主要有如下的基本特性：
- Bitmaps 不是数据类型，底层就是字符串（key-value），byte数组。我们可以使用普通的get/set直接获取和设值位图的内容，也可以通过Redis提供的位图操作getbit/setbit等将byte数组看成“位数组”来处理
- Bitmaps 的“位数组”每个单元格只能存储0和1，数组的下标在Bitmaps中称为偏移量
- Bitmaps设置时key不存在会自动生成一个新的字符串，如果设置的偏移量超出了现有内容的范围，就会自动将位数组进行零扩充
3.1.2 基本操作
3.1.2.1 SETBIT key offset value
对key存储的字符串，设置或者清除指定偏移量上的位（bit），位的设置或者清除取决于value参数，0/1；当key不存在时，自动生成一个新的字符串。字符串会进行伸展确保value保存在指定的偏移量上。字符串进行伸展时，空白位置以0填充。
时间复杂度 :
O(1)
offset 范围：
0~2^32
返回值：
指定偏移量原来存储的位
案例：
使用Bitmaps来存储用户是否打卡，打卡记做1，未打卡为0，用户的id作为偏移量
假设存在10个用户，此时用户1、3、5、9、10打了卡，其他人未打卡，Bitmaps的初始化结果如下所示：
clock:20210806代表2021/08/06的打卡记录
注意事项：
正式系统中，id肯定不会是0、1、2这种，而是以某一个数组开头，比如1000000000000001、1000000000000002这个时候非常容易导致偏移量的浪费，因此我们可以考虑通过计算减去一个合适的值后再设置偏移量，如果设置的Bitmaps偏移量过大，容易造成分配内存时间过长，Redis服务器被阻塞。
3.1.2.2 GETBIT key offset
获取指定偏移量上的位（bit），当offset比字符串长度大，或者key不存在，返回0；
时间复杂度：
O(1)
返回值：
字符串值指定偏移量上的位（bit）
案例：
clock:20210806代表2021/08/06的打卡记录
3.1.2.3 BITCOUNT key [start] [end]
计算给定字符串中，被设置为1的bit位的数量。start和end参数可以指定查询的范围，可以使用负数值。-1代表最后一个字节，-2代表倒是第二个字节。
注意：start和end是字节索引，因此每增加1 代表的是增加一个字符，也就是8位，所以位的查询范围必须是8的倍数。
时间复杂度：
O(N)
返回值：
被设置为1的位的数量
案例：
clock:20210806代表2021/08/06的打卡记录，此时一共11位，前8位置3个1，后3位中2个1
bitcount clock:20210806 0 0 表示第1个字符中1的个数
bitcount clock:20210806 1 1 表示第2个字符中1的个数
bitcount clock:20210806 0 1 表示第1和第2个字符中1的个数
3.1.2.4 BITPOS key bit [start] [end]
返回第一个置为bit的二进制位的位置，默认检测整个Bitmaps，也可以通过start和end参数指定查询范围
注意：start和end是字节索引，因此每增加1 代表的是增加一个字符，也就是8位，所以位的查询范围必须是8的倍数。
时间复杂度：
O(N)
返回值：
整数回复
案例：
bitpos clock:20210806 0 表示第一个0的位置
bitpos clock:20210806 1 表示第一个1的位置
bitpos clock:20210806 1 0 0 表示第一个字符中，第一个1的位置
bitpos clock:20210806 1 1 1 表示第二个字符中，第一个1的位置
bitpos clock:20210806 1 0 1 表示第一个和第二个字符中，第一个1的位置
3.1.2.5 BITOP operation destkey key [key …]
Redis的Bitmaps提供BITOP指令来对一个或多个（除了NOT操作）二进制位的字符串key进行位元操作，操作的结果保存到destkey上，operation是操作类型，有四种分别是：AND、OR、NOT、XOR
- BITOP AND destkey key [key …] ，对一个或多个 key 求逻辑并，并将结果保存到 destkey
- BITOP OR destkey key [key …] ，对一个或多个 key 求逻辑或，并将结果保存到 destkey
- BITOP XOR destkey key [key …] ，对一个或多个 key 求逻辑异或，并将结果保存到 destkey
- BITOP NOT destkey key ，对给定 key 求逻辑非，并将结果保存到 destkey
当字符串长度不一致是，较短的那个字符串所缺失的部分会被看作0，空的key也会被看作是包含0的字符串序列
时间复杂度：
O(N)
返回值：
位运算的结果（保存到destkey的字符串的长度和输入key中的最长的字符串的长度相等）
案例：
这里使用key1 1001和key2 1011进行上述四种操作
BITOP AND destkey key [key …]
运算规则：0&0=0; 0&1=0; 1&0=0; 1&1=1;
即：两位同时为“1”，结果才为“1”，否则为0
BITOP OR destkey key [key …]
运算规则：0|0=0； 0|1=1； 1|0=1； 1|1=1；
即 ：参加运算的两个对象只要有一个为1，其值为1
BITOP XOR destkey key [key …]
运算规则：0^0=0； 0^1=1； 1^0=1； 1^1=0；
即：参加运算的两个对象，如果两个相应位为“异”（值不同），则该位结果为1，否则为0
BITOP NOT destkey key
运算规则：取反
3.1.2.6 BITFIELD key [GET type offset] [SET type offset value] [INCRBY type offset increment] [OVERFLOW WRAP|SAT|FAIL]
2.1和2.2中的setbit和getbit都是对指定key的单个位的操作，如果需要对多个位同时操作，那么可以使用bitfield指令，bitfield有三个子指令，分别是get、set、incrby，它们可以对指定的片段进行读写，但是最多处理64个连续的位，超过64个连续的位，需要使用多个子指令，bitfield可以同时执行多个子指令（无符号整数只能返回63位）。
注意：
- 使用 GET 子命令对超出字符串当前范围的二进制位进行访问（包括键不存在的情况）， 超出部分的二进制位的值将被当做是 0 。
- 使用 SET 子命令或者 INCRBY 子命令对超出字符串当前范围的二进制位进行访问将导致字符串被扩大， 被扩大的部分会使用值为 0 的二进制位进行填充。 在对字符串进行扩展时， 命令会根据字符串目前已有的最远端二进制位， 计算出执行操作所需的最小长度。
值操作子指令：
- GET —— 返回指定的二进制位范围
- SET —— 对指定的二进制位范围进行设置，并返回它的旧值
- INCRBY —— 对指定的二进制位范围执行加法操作，并返回它的旧值。用户可以通过向 increment 参数传入负值来实现相应的减法操作
溢出策略子指令：
- WRAP：回绕/折返（wrap around）-默认溢出策略，对于无符号整数来说， 回绕就像使用数值本身与能够被储存的最大无符号整数执行取模计算， 这也是 C 语言的标准行为。 对于有符号整数来说， 上溢将导致数字重新从最小的负数开始计算， 而下溢将导致数字重新从最大的正数开始计算。
- SAT：饱和计算（saturation arithmetic），也可以理解为饱和截断，这种模式下下溢计算的结果为最小的整数值， 而上溢计算的结果为最大的整数值
- FAIL：失败不执行，这种模式会拒绝执行那些导致上溢或者下溢的计算情况，返回nil表示计算未被执行。
需要注意的是， OVERFLOW 子命令只会对紧随着它之后被执行的 INCRBY 命令产生效果， 这一效果将一直持续到与它一同被执行的下一个 OVERFLOW 命令为止。 在默认情况下， INCRBY 命令使用 WRAP 方式来处理溢出计算。
i与u:
i表示有符号整数，u表示无符号整数。u4代表4位长的无符号整数，i8代表8位长的有符号整数。
案例：
测试数字为10100111
bitfield key get u4 0 从第一个位开始取4个位，得到无符号数1010=10
bitfield key set u8 0 128 从第0个开始，将接下来的8位用无符号整数128替换，也就是10000000
bitfield key incrby u4 2 1 从第2位开始对接下来的4位无符号数+1
bitfield key set u8 0 128 get u4 0 incrby u4 2 1 复合指令，是上面三者的组成，返回值是每个操作的子集，相当于管道操作
3.3 HyperLogLog
3.3.1 简介
首先抛出一个业务问题：
假设产品经理让你设计一个模块，来统计PV（Page View页面的访问量），那么你会怎么做？
我想很多人对于PV（Page View页面的访问量）的统计会很快的想到使用Redis的incr、incrby指令，给每个网页配置一个独立Redis计数器就可以了，把这个技术区的key后缀加上当它的日期，这样一个请求过来，就可以通过执行incr、incrby指令统计所有PV。
此时当你完成这个需求后，产品经理又让你设计一个模块，统计UV（Unique Visitor，独立访客），那么你又会怎么做呢？
UV与PV不一样，UV需要根据用户ID去重，如果用户没有ID我们可能需要考虑使用用户访问的IP或者其他前端穿过了的唯一标志来区分，此时你可能会想到使用如下的方案来统计UV。
- 存储在MySQL数据库表中，使用distinct count计算不重复的个数
- 使用Redis的set、hash、bitmaps等数据结构来存储，比如使用set，我们可以使用用户ID，通过sadd加入set集合即可
但是上面的两张方案都存在两个比较大的问题：
- 随着数据量的增加，存储数据的空间占用越来越大，对于非常大的页面的UV统计，基本不合实际
- 统计的性能比较慢，虽然可以通过异步方式统计，但是性能并不理想
因此针对UV的统计，我们将会考虑使用Redis的新数据类型HyperLogLog.
HyperLogLog是用来做基数统计的算法，它提供不精确的去重计数方案（这个不精确并不是非常不精确），标准误差是0.81%，对于UV这种统计来说这样的误差范围是被允许的。HyperLogLog的优点在于，输入元素的数量或者体积非常大时，基数计算的存储空间是固定的。在Redis中，每个HyperLogLog键只需要花费12KB内存，就可以计算接近2^64个不同的基数。
但是：HyperLogLog只能统计基数的大小（也就是数据集的大小，集合的个数），他不能存储元素的本身，不能向set集合那样存储元素本身，也就是说无法返回元素。
HyperLogLog指令都是pf(PF)开头，这是因为HyperLogLog的发明人是Philippe Flajolet，pf是他的名字的首字母缩写。
3.3.2 命令
3.3.2.1 PFADD key element [element …]
将任意数量的元素添加到指定的 HyperLogLog 里面，当PFADD key element [element …]指令执行时，如果HyperLogLog的估计近似基数在命令执行之后出现了变化，那么命令返回1，否则返回0，如果HyperLogLog命令执行时给定的键不存在，那么程序将先创建一个空的HyperLogLog结构，再执行命令。
该命令可以只给定key不给element，这种以方式被调用时：
- 如果给定的键存在且已经是一个HyperLogLog，那么这种调用不会产生任何效果
- 如果给定的键不存在，那么命令会闯进一个空的HyperLogLog，并且给客户端返回1
返回值：
如果HyperLogLog数据结构内部存储的数据被修改了，那么返回1，否则返回0
时间复杂度：
O(1)
使用示例：
3.3.2.2 PFCOUNT key [key …]
PFCOUNT 指令后面可以跟多个key，当PFCOUNT key [key …]命令作用于单个键时，返回存储在给定键的HyperLogLog的近似基数，如果键不存在，则返回0；当PFCOUNT key [key …]命令作用于多个键时，返回所给定HyperLogLog的并集的近似基数，这个近似基数是通过将索引给定HyperLogLog合并至一个临时HyperLogLog来计算得出的。
返回值：
返回给定HyperLogLog包含的唯一元素的近似数量的整数值
时间复杂度：
当命令作用于单个HyperLogLog时，时间复杂度为O(1)，并且具有非常低的平均常数时间。当命令作用于N个HyperLogLog时，时间复杂度为O(N)，常数时间会比单个HyperLogLog要大的多。
使用示例：
3.3.2.3 PFMERGE destkey sourcekey [sourcekey …]
将多个HyperLogLog合并到一个HyperLogLog中，合并后HyperLogLog的基数接近于所有输入HyperLogLog的可见集合的并集，合并后得到的HyperLogLog会被存储在destkey键里面，如果该键不存在，那么命令在执行之前，会先为该键创建一个空的HyperLogLog。
返回值：
字符串回复，返回OK
时间复杂度：
O(N)，其中N为被合并的HyperLogLog的数量，不过这个命令的常数复杂度比较高
使用示例：
3.3.3 原理
3.3.3.1 伯努利试验
HyperLogLog的算法设计能使用12k的内存来近似的统计2^64个数据，这个和伯努利试验有很大的关系，因此在探究HyperLogLog原理之前，需要先了解一下伯努利试验。
以下是百度百科关于伯努利试验的介绍：
伯努利试验（Bernoulli experiment）是在同样的条件下重复地、相互独立地进行的一种随机试验，其特点是该随机试验只有两种可能结果：发生或者不发生。我们假设该项试验独立重复地进行了n次，那么就称这一系列重复独立的随机试验为n重伯努利试验，或称为伯努利概型。单个伯努利试验是没有多大意义的，然而，当我们反复进行伯努利试验，去观察这些试验有多少是成功的，多少是失败的，事情就变得有意义了，这些累计记录包含了很多潜在的非常有用的信息。
伯努利试验是数据概率论中的一部分，它的典故源于“抛硬币”。
一个硬币只有正面和反面，每次抛硬币出现正反面的概率都是50%，我们一直抛硬币直到出现第一次正面为止，记录抛硬币的次数，这个就被称为一次伯努利试验。伯努利试验需要做非常多的次数，数据才会变得有意义。
对于n次伯努利试验，出现正面的次数为n，假设每次伯努利试验抛掷的次数为k（也就是每次出现正面抛掷的次数），第一次伯努利试验抛掷次数为k1，第n次伯努利试验抛掷次数为kn，在这n次伯努利试验中，抛掷次数最大值为kmax。
上述的伯努利试验，结合极大似然估算方法（极大似然估计），得出n和kmax之间的估算关系：n=2^kmax。很显然这个估算关系是不准确的，例如如下案例：
第一次试验：抛掷1次出现正面，此时k=1,n=1;
第二次实验：抛掷3次出现正面，此时k=3,n=2;
第三次实验：抛掷6次出现正面，此时k=6,n=3;
第n次试验：抛掷10次出现正面，此时k=10,n=n,通过估算关系计算，n=2^10
上述案例可以看出&#x
最低0.47元/天 解锁文章
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
