Redis学习笔记

NoSql概述

解耦！

1.方便扩展（数据之间没有关系，很好扩展）！

2.大数据量高性能（Redis一秒写8万次，读取11万次，NoSQL的缓存记录级，是一种细粒度的缓存，性能会比较高）！

3.数据类型是多样型的（不需要事先设计数据库！，随取随用！如果是数据量十分的大，很多人就无法设计了）

4.传统的RDBMS（关系型数据库）和NoSQL的区别：

传统的RDBMS
--结构化组织
-sql
-数据和关系都存在单独的表中
-操作复杂，数据定义语言
-严格的一致性
-基础的事物
..............

Nosql

-不仅仅是数据
-没有固定的查询语言
-键值对存储，列存储，文档存储，图形数据库（社交关系）
-最终的一致性
- CAP 定理和base（异地多活）
- 高性能，高可用，高可扩

了解：3V+3高

3V:主要是描述问题的

​ 海量Velume

​ 多样Variety

​ 实时Velocit

3高：主要是对程序的要求

​ 高并发

​ 高可扩 （随时可以水平拆分，机器不够了，可以扩展机器）

​ 高性能 （保证用户体验和性能）

真正的实践：NoSQL+关系型数据库

NoSQL的四大分类

KV键值对

文档型数据库（bson格式，和json一样）

MongDB(一般必须要掌握)

• MongDB 是一个基于分布式文件存储的数据库，C++编写，主要用来处理大量的文档！

• MongDB是一个介于关系型数据库和非关系型数据中的中间产品，MongDB是非关系型数据库中功能最丰富，最像关系型数据库！

列存储数据库

• Hbase

• 分布式文件系统

图关系数据库

• 他不是存图形，放的是关系，比如朋友圈社交网络；

• Neo4j，infoGrid

Redis入门

概述

Redis是什么？ 即 远程字典服务； 也被称为结构化数据库

Redis 能干嘛？

1、内存存储，持久化，内存中是断电即失，所有说持久化很重要（rdb,aof）

2、效率高、可以用于高速缓存

3、发布订阅系统

4、地图信息分析

5、计时器、计数器（浏览器！）

6、…

特性

1、多样的数据类型

2、持久化

3、集群

4、事物

redis 的默认端口是 6379

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vg0P2y1C-1607265283101)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201204145032810.png)]

Linux 安装

​ 基本的环境安装

yum install gcc-c++
make 
make install

• redis默认不是后台运行的

  改为后台启动：daemonize yes
  

• redis 默认安装路径：usr/local/bin

• Linux 环境下启动以及客户端连接：

  启动：
  在usr/local/bin 路径下，
  #kconfig是我们自己备份的一份redis.conf配置文件
  执行 redis-server kconfig/redis.conf 
  
  客户端连接：
  redis-cli -p 6379
  

• 查看redis的进程是否开启：

  ps -ef | grep redis
  

• 如果关闭Redis 服务

  shutdown
  

redis-benchmark

​ 性能测试工具

redis-benchmark命令参数：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xvs84J1Y-1607265283103)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201204172906293.png)]

#测试：100个并发连接，1000000个请求
redis-benchmark -h localhost -p 6379 -c 100 -n 100000 

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lppsnyBU-1607265283105)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201204174044901.png)]

Redis基础的知识

默认有16个数据库 ，默认使用第0个；

基本命令：

#切换数据库
select 数据库编号
#查看数据库大小
DBSIZE
#添加数据
set name tanet
#查询数据
get name
#查看所有的key:  keys *
keys *
#清除当前数据库
flushdb
#清除所有数据库
FLUSHALL

​ 查看所有的key: keys *

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bVPRQS3m-1607265283107)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201204193238834.png)]

为什么端口是6379？ 粉丝效应

redis 是单线程的！

Redis是基于内存操作，CPU不是Redis的性能瓶颈，Redis 的瓶颈是根据机器的内存和网络的带宽；

为什么Redis单线程还这么快？

1.误区（1）高性能的服务器不一定是多线程的

2.误区（2）多线程（CPU调度，上下文切换，耗时的操作）一定比单线程效率高；

核心：Redis是将所有的数据全部都放在内存当中，所有说使用单线程操作效率就是最高的，对于内存来说，如果没有上下文切换，效率就是最高的，多次读写都是在一个CPU中，在内存的情况下，这个效率就是最高的；

五大数据类型

Redis Key

​

#判断是否存在
EXISTS name   #判断name是否存在
#移动到一号数据库
move name 1
#设置字段的过期时间
EXPIRE name 10    #设置name字段10秒后过期
#查看name还剩余的时间
ttl name
#查看字段的类型
type name    #查看name的类型

127.0.0.1:6379[1]> type name
string

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-joMkDwS8-1607265283110)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201204195748352.png)]

String（字符串类型）

127.0.0.1:6379> set key1 v1
OK
127.0.0.1:6379> get key1
"v1"
127.0.0.1:6379> keys *
1) "key1"
127.0.0.1:6379> EXISTS key1              #查看某个key是否存在
(integer) 1
127.0.0.1:6379> APPEND key1 "hello"       #往key1里追加，如果key不存在，就相当于setkey
(integer) 7
127.0.0.1:6379> get key1
"v1hello"
127.0.0.1:6379> STRLEN key1             #获取字符串的长度
(integer) 7
127.0.0.1:6379> APPEND key1 ",kuangshen"
(integer) 17
127.0.0.1:6379> 

127.0.0.1:6379> set views 0
OK
127.0.0.1:6379> get views      #初始浏览量为0
"0"
127.0.0.1:6379> incr views     #加一
(integer) 1
127.0.0.1:6379> get views
"1"
127.0.0.1:6379> get views
"1"
127.0.0.1:6379> incr views
(integer) 2
127.0.0.1:6379> get views
"2"
127.0.0.1:6379> decr views    #减一
(integer) 1
127.0.0.1:6379> decr views
(integer) 0
127.0.0.1:6379> INCRBY views 10   #设置步长，指定增量为10
(integer) 10
127.0.0.1:6379> INCRBY views 10
(integer) 20
127.0.0.1:6379> DECRBY views 5
(integer) 15
127.0.0.1:6379> DECRBY views 5    #设置步长，指定增量为5
(integer) 10
127.0.0.1:6379> 

127.0.0.1:6379> set key1 "hello,kuangshen"
OK
127.0.0.1:6379> get key1
"hello,kuangshen"
127.0.0.1:6379> GETRANGE key1 0 3      #截取前四个字符串
"hell"
127.0.0.1:6379> GETRANGE key1 0 -1      #取出全部字符串
"hello,kuangshen"

#####################################################################################
#替换
127.0.0.1:6379> clear
127.0.0.1:6379> set key2 abcdefg
OK
127.0.0.1:6379> get key2
"abcdefg"
127.0.0.1:6379> SETRANGE key2 1 xx    #替换指定位置开始的字符串
(integer) 7
127.0.0.1:6379> get key2
"axxdefg"

#########################################################################################
# setex   (set with expire)    设置过期时间
# setnx   (set if not exist)   不存在再设置 (在分布式锁中会常常用到)

127.0.0.1:6379> setex keys 30 "hello"      #keys的过期时间为30
OK
127.0.0.1:6379> get keys 
"hello"
127.0.0.1:6379> ttl keys 
(integer) -2
127.0.0.1:6379> get keys
(nil)
127.0.0.1:6379> setnx mykey "redis"          #设置后就不能进行修改
(integer) 1
127.0.0.1:6379> setnx mykey "mango"         #如果mykey不存在，就会创建
(integer) 0
127.0.0.1:6379> get mykey
"redis"

########################################################################################

127.0.0.1:6379> mset k1 v1 k2 v2 k3 v3     #同时设置多个值
OK
127.0.0.1:6379> keys *
1) "k3"
2) "k2"
3) "k1"
127.0.0.1:6379> mget k1 k2 k3            #同时获取多个值
1) "v1"
2) "v2"
3) "v3"
127.0.0.1:6379> msetnx k1 v1 k4 v4      #msetnx是一个原子性的操作，要么一起成功，要么一起失败
(integer) 0
127.0.0.1:6379> get k4
(nil)
127.0.0.1:6379> keys *
1) "k3"
2) "k2"
3) "k1

############################################################################################

#对象
set User:1{name:zhangsan,age:3}   #设置一个user：1，对象值为json字符来保存一个对象；

#这里的key是一个巧妙的设计，user:{id}:{filed},如此设计在redis中是完全OK的

127.0.0.1:6379> mset user:1:name zhangsan user:1:age 2
OK
127.0.0.1:6379> mget user:1:name user:1:age
1) "zhangsan"
2) "2"

############################################################################################

getset   #先get再set

127.0.0.1:6379> getset db redis           #如果不存在值，则返回nil
(nil)
127.0.0.1:6379> get db
"redis"
127.0.0.1:6379> getset db mongDB         #如果存在值，则先获取原来的值，再去设置新的值
"redis"
127.0.0.1:6379> get db
"mongDB"

value 除了是字符串，还可以是我们的数字

• 计数器
• 统计多单位的数量
• 粉丝数

List

基本的数据类型，列表

在Redis中，可以把List做成栈，队列还有阻塞队列！！！

所有的list命令都是以L开头的，redis不区分大小写

127.0.0.1:6379> LPUSH list one     #将一个值或者多个值，插入到列表头部（左）
(integer) 1
127.0.0.1:6379> LPUSH list two
(integer) 2
127.0.0.1:6379> LPUSH list three
(integer) 3
127.0.0.1:6379> LRANGE list 0 -1   #或者列表中的值
1) "three"
2) "two"
3) "one"
127.0.0.1:6379> LRANGE list 0 1
1) "three"
2) "two"
127.0.0.1:6379> Rpush list right    #将一个值或者多个值，插入到列表头部（右）
(integer) 4
127.0.0.1:6379> LRANGE list 0 1
1) "three"
2) "two"
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "two"
3) "one"
4) "right"

############################################################################################

# LPOP
# RPOP
127.0.0.1:6379> Lpop list      #移除list的第一个元素
"three"
127.0.0.1:6379> Rpop list      #移除list的最后一个元素
"right"
127.0.0.1:6379> LRANGE list 0 -1
1) "two"
2) "one"

############################################################################################

#  Lindex
127.0.0.1:6379> lindex list 1
"one"
127.0.0.1:6379> lindex list 0     #通过下标获取list中的某一个值！
"two"

############################################################################################

# Llen
127.0.0.1:6379> lpush list one 
(integer) 1
127.0.0.1:6379> lpush list two
(integer) 2
127.0.0.1:6379> lpush list three
(integer) 3
127.0.0.1:6379> llen list     #获取列表的长度
(integer) 3

############################################################################################

#移除指定的值   Lrem
127.0.0.1:6379> lpush list three
(integer) 4
127.0.0.1:6379> lrem list 1 one        
(integer) 1
127.0.0.1:6379> LRANGE list 0 -1
1) "three"
2) "three"
3) "two"
127.0.0.1:6379> lrem list 2 three      #移除指定个数的value 2个 three
(integer) 2
127.0.0.1:6379> LRANGE list 0 -1
1) "two"

############################################################################################

# trim 修剪

127.0.0.1:6379> rpush mylist "hello"
(integer) 1
127.0.0.1:6379> rpush mylist "hello1"
(integer) 2
127.0.0.1:6379> rpush mylist "hello2"
(integer) 3
127.0.0.1:6379> rpush mylist "hello3"
(integer) 4
127.0.0.1:6379> ltrim mylist 1 2               #通过下标截取指定的长度，这个list已经被改变了，只剩下了截取的元素
OK
127.0.0.1:6379> lrange mylist 0 -1
1) "hello1"
2) "hello2"

############################################################################################

# rpoplpush  移除列表的最后一个元素，并添加一个新元素
127.0.0.1:6379> rpush mylist "hello"
(integer) 1
127.0.0.1:6379> rpush mylist "hello1"
(integer) 2
127.0.0.1:6379> rpush mylist "hello2"
(integer) 3
127.0.0.1:6379> rpoplpush mylist myotherlist       #移动到新的列表中
"hello2"
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "hello1"
127.0.0.1:6379> lrange myotherlist 0 -1     
1) "hello2"

#################################################################################################

#lset    将列表中指定下标的值替换为另外一个值，更新操作
127.0.0.1:6379> lpush list value1
(integer) 1
127.0.0.1:6379> lrange list 0 0 
1) "value1"
127.0.0.1:6379> lset list 0 item      #替换操作
OK
127.0.0.1:6379> lrange list 0 0 
1) "item"
127.0.0.1:6379> lset list 1 other     #如果不存在我们去更新就会报错
(error) ERR index out of range

#################################################################################################

 # linsert
 127.0.0.1:6379> Rpush mylist hello
(integer) 1
127.0.0.1:6379> Rpush mylist world
(integer) 2
127.0.0.1:6379> linsert mylist before world other   #将other插入到world的前面
(integer) 3
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "other"
3) "world"
127.0.0.1:6379> linsert mylist after  world hahah  #将hahah插入到world的后面
(integer) 4
127.0.0.1:6379> lrange mylist 0 -1
1) "hello"
2) "other"
3) "world"
4) "hahah"

小结

• List实际是一个链表，before node after ,left, right都可以插入
• 如果key 不存在，创建新的链表
• 如果key存在，新增内容
• 如果移除了所有值，空链表，也代表不存在
• 在两边插入或者改动值，效率最高，中间元素，相对来说效率会低一点

消息排队！ 消息队列( Lpush Rpop) ,栈（Lpush,Lpop）

Set（集合）

set中的值是不能重复的；

127.0.0.1:6379> sadd myset "hello"                     #set集合中添加元素
(integer) 1
127.0.0.1:6379> sadd myset "kuangshen"
(integer) 1
127.0.0.1:6379> sadd myset "kuangshen1"
(integer) 1
127.0.0.1:6379> smembers myset                      #查看指定set的所有值
1) "hello"
2) "kuangshen"
3) "kuangshen1"
127.0.0.1:6379> sismember myset hello                #判断某一个值是不是在set中    
(integer) 1
127.0.0.1:6379> sismember myset world
(integer) 0

###################################################################################################

127.0.0.1:6379> scard myset                   #获取set集合中的个数
(integer) 3
127.0.0.1:6379> sadd myset "kuangshen2"
(integer) 1
127.0.0.1:6379> scard myset
(integer) 4

###################################################################################################

127.0.0.1:6379> srem myset hello       #移除set中的某个元素
(integer) 1
127.0.0.1:6379> scard myset 
(integer) 3
127.0.0.1:6379> smembers myset
1) "kuangshen2"
2) "kuangshen"
3) "kuangshen1"

###################################################################################################
set 无序不重复，抽随机

127.0.0.1:6379> smembers myset
1) "kuangshen2"
2) "kuangshen"
3) "kuangshen1"
127.0.0.1:6379> srandmember myset           #随机抽选一个元素
"kuangshen2"
127.0.0.1:6379> srandmember myset
"kuangshen2"
127.0.0.1:6379> srandmember myset
"kuangshen2"
127.0.0.1:6379> srandmember myset
"kuangshen"
127.0.0.1:6379> srandmember myset 2         #随机抽选指定个数的元素
1) "kuangshen2"
2) "kuangshen1"
127.0.0.1:6379> srandmember myset 2
1) "kuangshen2"
2) "kuangshen1"
127.0.0.1:6379> srandmember myset 2
1) "kuangshen2"
2) "kuangshen"
127.0.0.1:6379> srandmember myset
"kuangshen"

###################################################################################################

移除指定的key，随机删除key
127.0.0.1:6379> spop myset                 #随机删除set集合的元素
"kuangshen2"
127.0.0.1:6379> smembers myset 
1) "kuangshen"
2) "kuangshen1"

###################################################################################################
将一个指定的值，移动到另外一个set集合中

127.0.0.1:6379> sadd myset hello
(integer) 1
127.0.0.1:6379> sadd myset word 
(integer) 1
127.0.0.1:6379> sadd myset tanet
(integer) 1
127.0.0.1:6379> sadd myset2 set2
(integer) 1
127.0.0.1:6379> smove myset myset2 tanet           #将一个指定的值，移动到另外一个set集合中
(integer) 1
127.0.0.1:6379> smembers myset2
1) "tanet"
2) "set2"

###################################################################################################

微博， B站，共同关注（并集）
数字集合类：
   -差集
   -交集
   -并集
 
 127.0.0.1:6379> sadd key1 a
(integer) 1
127.0.0.1:6379> sadd key1 b
(integer) 1
127.0.0.1:6379> sadd key1 c
(integer) 1
127.0.0.1:6379> sadd key2 c
(integer) 1
127.0.0.1:6379> sadd key2 d
(integer) 1
127.0.0.1:6379> sadd key2 e 
(integer) 1
127.0.0.1:6379> sdiff key1 key2                       #差集，哪些不一样
1) "a"
2) "b"
127.0.0.1:6379> sinter key1 key2                     #交集
1) "c"
127.0.0.1:6379> sunion key1 key2                     #并集
1) "c"
2) "e"
3) "a"
4) "b"
5) "d"

Hash(哈希)

map集合，key-map集合 ；

127.0.0.1:6379> hset myhash field1 kuang                       #set一个具体的key-value
(integer) 1                                   
127.0.0.1:6379> hget myhash field1                            #获取一个字段值
"kuang"
127.0.0.1:6379> hmset myhash field1 hello field2 world        #set多个key-value
OK
127.0.0.1:6379> hmget myhash field1 field2                   #获取多个字段
1) "hello"
2) "world"
127.0.0.1:6379> hgetall myhash                              #获取全部数据
1) "field1"
2) "hello"
3) "field2"
4) "world"

###################################################################################################

127.0.0.1:6379> hgetall myhash
1) "field1"
2) "hello"
3) "field2"
4) "world"
127.0.0.1:6379> hdel myhash field1                          #删除hash 指定的key字段，对应的value也会被删除
(integer) 1
127.0.0.1:6379> hgetall myhash               
1) "field2"
2) "world"

###################################################################################################

#  hlen  
127.0.0.1:6379> hgetall myhash
1) "field2"
2) "world"
3) "field1"
4) "hello"
127.0.0.1:6379> hlen myhash                   #获取hash中的长度
(integer) 2

###################################################################################################
127.0.0.1:6379> hexists myhash field3     #判断hash中指定字段是否存在
(integer) 0
127.0.0.1:6379> hexists myhash field1
(integer) 1

###################################################################################################

#只获得所有field
#只获得所有value
127.0.0.1:6379> hkeys myhash    #只获得所有field
1) "field2"
2) "field1"
127.0.0.1:6379> hvals myhash  #只获得所有value
1) "world"
2) "hello"

###################################################################################################
#  incr 自增       decr   自减

127.0.0.1:6379> hset myhash field3 5
(integer) 1
127.0.0.1:6379> hincrby myhash field3 1             #指定增量
(integer) 6
127.0.0.1:6379> hincrby myhash field3 -1
(integer) 5
127.0.0.1:6379> hget myhash field3
"5"
127.0.0.1:6379> hsetnx myhash field4 hello         #如果不存在则可以设置
(integer) 1
127.0.0.1:6379> hsetnx myhash field4 world         #如果存在则不可以设置  
(integer) 0

hash 存变更的数据， user name age ,尤其是用户信息的之类的，经常变动的信息！！ hash 更适合对象的存储，String更适合字符串的存储

ZSet(有序集合)

在set的基础上，增加了一个值，set k1 ,v1 zset k1 score1 v1

127.0.0.1:6379> zadd myset 1 one              #添加一个值
(integer) 1
127.0.0.1:6379> zadd myset 2 two
(integer) 1
127.0.0.1:6379> zadd myset 3 three 4 four     #添加多个值
(integer) 2
127.0.0.1:6379> zrange myset 0 -1
1) "one"
2) "two"
3) "three"
4) "four"

#########################################################################################################

排序如何实现

127.0.0.1:6379> zadd salary 2500 xiaohong
(integer) 1
127.0.0.1:6379> zadd salary 5000 zhangsan
(integer) 1
127.0.0.1:6379> zadd salary 500 tanet
(integer) 1
127.0.0.1:6379> zrangebyscore salary -inf +inf        # -inf 负无穷    +inf 正无穷
1) "tanet"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf +inf withscores    #排序并带上成绩
1) "tanet"
2) "500"
3) "xiaohong"
4) "2500"
5) "zhangsan"
6) "5000"
127.0.0.1:6379> ZRANGEBYSCORE salary -inf 2500 withscores    #显示工资小于 2500以下的员工，默认为升序
1) "tanet"
2) "500"
3) "xiaohong"
4) "2500"


127.0.0.1:6379> ZREVRANGE salary 0 -1 withscores      #降序
1) "zhangsan"
2) "5000"
3) "tanet"
4) "500"

#########################################################################################################

移除 rem中的元素

127.0.0.1:6379> ZRANGE salary 0 -1
1) "tanet"
2) "xiaohong"
3) "zhangsan"
127.0.0.1:6379> ZREM salary xiaohong         #移除指定元素操作
(integer) 1
127.0.0.1:6379> ZRANGE salary 0 -1
1) "tanet"
2) "zhangsan"

#########################################################################################################

127.0.0.1:6379> ZCARD salary            #获取有序集合中的个数
(integer) 2


#########################################################################################################

127.0.0.1:6379> clear
127.0.0.1:6379> zadd myset 1 hello
(integer) 1
127.0.0.1:6379> zadd myset 2 world
(integer) 1
127.0.0.1:6379> zadd myset 3 lili
(integer) 1
127.0.0.1:6379> ZCOUNT myset 1 3             #获取指定区间的成员数量
(integer) 3
127.0.0.1:6379> ZCOUNT myset 1 2
(integer) 2

案列： TOP榜

三种特殊数据类型

geospatial地理位置

​ 朋友的位置，打车距离；

​ 只有六个命令

1.GEOADD

#添加城市数据，经纬度
127.0.0.1:6379> GEOADD china:city 116.40 39.90 beijing
(integer) 1
127.0.0.1:6379> GEOADD china:city 121.47 31.23 shanghai
(integer) 1
127.0.0.1:6379> GEOADD china:city 106.50 29.53 chongqing
(integer) 1
127.0.0.1:6379> GEOADD china:city 114.05 22.52 shenzhen
(integer) 1
127.0.0.1:6379> GEOADD china:city 120.16 30.24 hangzhou
(integer) 1
127.0.0.1:6379> GEOADD china:city 108.96 34.26 xian
(integer) 1

2.GEOPOS

获得当前定位，一定是一个坐标值

127.0.0.1:6379> GEOPOS china:city beijing xian     #获取指定城市的经度和纬度
1) 1) "116.39999896287918091"
   2) "39.90000009167092543"
2) 1) "108.96000176668167114"
   2) "34.25999964418929977"
127.0.0.1:6379> GEOPOS china:city beijing
1) 1) "116.39999896287918091"
   2) "39.90000009167092543"

3.GEODIST

返回两人之间的距离！

单位：

• m 表示单位为米。

• km 表示单位为千米。

• mi 表示单位为英里。

• ft 表示单位为英尺。

  127.0.0.1:6379> GEODIST china:city beijing shanghai km   #查看北京到上海的直线距离
  "1067.3788"
  

4.GEORADIUS

​ 以给定的经纬度为中心，找出某一半径内的元素

我附近的人？（获得所有附近的人的地址，定位！）通过半径来进行查询

#以 110，30为中心，查找附近500KM以内的城市
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km
1) "chongqing"
2) "xian"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withdist   #显示到中间距离的位置
1) 1) "chongqing"
   2) "341.9374"
2) 1) "xian"
   2) "483.8340"
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withcoord      #显示他人的定位信息
1) 1) "chongqing"
   2) 1) "106.49999767541885376"
      2) "29.52999957900659211"
2) 1) "xian"
   2) 1) "108.96000176668167114"
      2) "34.25999964418929977"
      
      #筛选指定结果
127.0.0.1:6379> GEORADIUS china:city 110 30 500 km withcoord withdist count 1    
1) 1) "chongqing"
   2) "341.9374"
   3) 1) "106.49999767541885376"
      2) "29.52999957900659211"

5.GEORADIUSBYMEMBER

#找出北京附近方圆1000km在表中的城市的数据
127.0.0.1:6379> GEORADIUSBYMEMBER china:city beijing 1000 km
1) "beijing"
2) "xian"

6.GEOHASH

该命令将返回11个字符的Geohash字符串

#将二维的经纬度转换为一维的字符串，如果两个字符串越接近，那么则距离越近
127.0.0.1:6379> GEOHASH china:city beijing chongqing 
1) "wx4fbxxfke0"
2) "wm5xzrybty0"

Hyperloglog 基数统计的算法

什么是基数？

A{1,3,5,7,8,7}

B{1,3,7,8}

基数（不重复的元素） = 5，可以接受误差

redis优点：占用的内存是固定的，2^64不同的元素的计数，只需要费12kb内存，如果要从内存角度来比较的话Hyperloglog是首选

网页的UV（一个人访问一个网站多次，但是还是算作一个人）

传统的方式，set保存用户的id，然后就可以统计set中的元素数量作为标准判断；

这个方式如果保存大量的用户的id，就会比较麻烦，我们的 目的就是为了计数，而不是保存用户的id；

127.0.0.1:6379> pfadd mykey a b c d e f g h i j       #创建 mykey
(integer) 1
127.0.0.1:6379> pfcount mykey                         #统计mykey 基数数量
(integer) 10
127.0.0.1:6379> pfadd mykey2 i j t y w c b
(integer) 1
127.0.0.1:6379> pfcount mykey2
(integer) 7
127.0.0.1:6379> pfmerge mykey3 mykey mykey2            #合并两组到 mykey3
OK
127.0.0.1:6379> pfcount mykey3
(integer) 12

如果允许容器，可以使用 Hyperloglog 如果不允许，则使用set

Bitmap

位存储

可以用于：

统计疫情感染人数： 0 1 0 1 0

统计用户的信息，活跃，不活跃 ！ 登录，未登录！ 打卡，365打卡

Bitmaps： 位图，数据结构，都是操作二进制位来进行记录，就只有0，1两个状态！

365天 =365bit 1字节=8bit， 46个字节左右

#使用bitmap来记录周一到周日的打开， 周一 1 （打卡）  周二 0 （未打卡）

127.0.0.1:6379> setbit sign 0 1      #第一个值代表周几，第二个值代表是否打卡
(integer) 0
127.0.0.1:6379> setbit sign 1 0
(integer) 0
127.0.0.1:6379> setbit sign 2 0
(integer) 0
127.0.0.1:6379> setbit sign 3 1
(integer) 0
127.0.0.1:6379> setbit sign 4 1
(integer) 0
127.0.0.1:6379> setbit sign 5 0
(integer) 0
127.0.0.1:6379> setbit sign 6 1
(integer) 0

127.0.0.1:6379> getbit sign 6           #查看周日的打卡状态
(integer) 1
127.0.0.1:6379> getbit sign 1
(integer) 0

127.0.0.1:6379> bitcount sign           #统计打卡记录
(integer) 4

127.0.0.1:6379> bitcount sign 0 6        #统计周一到周六的打卡记录
(integer) 4

事务

要么同时成功，要么同时失败 ，原子性；

redis事务本质：一组命令的集合，一块执行；

一个事务中的所有命令都会被序列化，在事务执行的过程中，会按照顺序执行！

一次性，顺序性，执行一些列的命令；

--------队列  set  set   set 执行  -----

Redis 事务没有隔离级别的概念！

所有的命令在事务中，并没有直接被执行！ 只有发起执行命令的时候才会执行！！！ Exec

Redis 单条命令是保存原子性的； 但是事务是不保证原子性的；

redis的事务：

• 开启事务 （MULTI）
• 命令入队 （…）
• 执行事务 （exec）

正常执行事务

127.0.0.1:6379> MULTI                #开启事务
OK
127.0.0.1:6379> set k1 v1             #命令入队
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> get k2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> exec                 #执行事务
1) OK
2) OK
3) "v2"
4) OK

放弃事务

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> 
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> DISCARD                          #取消事务
OK
127.0.0.1:6379> get k4                          #事务中的命令都不会被执行
(nil)

编译型异常 （代码有异常，命令有错！） 事务中所有的命令都不会执行！

127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> set k1 v1
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> getset k3                 #错误的命令
(error) ERR wrong number of arguments for 'getset' command
127.0.0.1:6379> set k4 v4
QUEUED
127.0.0.1:6379> set k5 v5
QUEUED
127.0.0.1:6379> exec                      #执行事务报错，所有事务都不会运行
(error) EXECABORT Transaction discarded because of previous errors.  
127.0.0.1:6379> get k1
(nil

运行时异常（1/0） ，如果事务队列存在语法性错误，那么执行命令时，其他命令是可以正常执行的，错误命令会抛异常

127.0.0.1:6379> set k1 "v1"
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> incr k1            #字符串不能自增
QUEUED
127.0.0.1:6379> set k2 v2
QUEUED
127.0.0.1:6379> set k3 v3
QUEUED
127.0.0.1:6379> get k3
QUEUED
127.0.0.1:6379> exec                  #错误的命令会抛异常，其他的正常执行
1) (error) ERR value is not an integer or out of range
2) OK
3) OK
4) "v3"

监控 Watch （面试常问）

悲观锁：

• 很悲观，认为什么时候都会出问题，无论做什么都会加锁

乐观锁：

• 很乐观，认为什么时候都不会出问题，所以不会上锁，更新数据的时候去判断一下，在此期间是否有人修改过这个数据;
• 获取version
• 更新的时候比较version

Redis的监视测试

正常执行成功！

127.0.0.1:6379> set money 100
OK
127.0.0.1:6379> set out 0
OK
127.0.0.1:6379> WATCH money                                  #监视money对象
OK
127.0.0.1:6379> MULTI                                       #事务正常结束，数据期间没有发生变动，这个时候就正常执行成功！
OK
127.0.0.1:6379> DECRBY money 20
QUEUED
127.0.0.1:6379> INCRBY out 20
QUEUED
127.0.0.1:6379> exec
1) (integer) 80
2) (integer) 20

测试多线程，监视失败，使用watch相当于乐观锁

127.0.0.1:6379> watch money                           #监视 money
OK
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> DECRBY money 10
QUEUED
127.0.0.1:6379> INCRBY out 10
QUEUED
127.0.0.1:6379> exec                         #执行之前另外一个线程会修改money 的值，导致执行失败
(nil)

#如果修改失败，获取最新的值就好

127.0.0.1:6379> UNWATCH                    #1.如果发现事务执行失败，就先解锁
OK
127.0.0.1:6379> WATCH money               #2.获取最新的值，再次监视，select version
OK
127.0.0.1:6379> clear
127.0.0.1:6379> MULTI
OK
127.0.0.1:6379> DECRBY money 1
QUEUED
127.0.0.1:6379> INCRBY out 1
QUEUED
127.0.0.1:6379> EXEC             #对比监视的值是否发生了变化，如果没有变化，那么可以执行成功，如果变化则执行失败
1) (integer) 999
2) (integer) 21



127.0.0.1:6379> get money
"80"
127.0.0.1:6379> set money 1000             #另一个线程修改money为1000 
OK 

Jedis

Jedis是Redis 官方推荐的Java连接开发工具，如果使用java 操作Redis，那么一定要使用Jedis》

1.导入对应的依赖；

 <!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.2.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>

2.编码测试：

• 连接数据库
• 进行连接测试
• 断开连接

常用的API

String

List

Set

Hash

Zset

springBoot 整合

spring 2.x之后，Jedis 被换成lettuce

Jedis ：采用的直连，多个线程操作的话，是不安全的，如果想要避免不安全，使用Jedis连接池，更像BIO模式

lettuce:采用netty,实例可以在多个线程中进行共享，不存在线程不安全的情况，可以减少线程数量，更像NIO模式

源码分析：

#在springboot的 autoconfigure包下找到 spring.factories 配置文件
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration

打开redis 自动配置文件：

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)     //redis的默认配置
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {
   	@Bean
	@ConditionalOnMissingBean(name = "redisTemplate")    //我们可以自己定义
    //默认的RedisTemplate没有过多的设置，redis对象是需要序列化
    //两个泛型都是Object，我们后需要强制转换<String,Object>
    //操作对象
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
		RedisTemplate<Object, Object> template = new RedisTemplate<>();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	}

    //操作String字符串
	@Bean
	@ConditionalOnMissingBean
	@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
	public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
		StringRedisTemplate template = new StringRedisTemplate();
		template.setConnectionFactory(redisConnectionFactory);
		return template;
	} 
    
    

1.导入依赖

2.配置连接

3.测试连接

序列化配置

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MwrIPNUP-1607265283112)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201205160244105.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uAHR0reB-1607265283114)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201205160432697.png)]

对象没有序列化导致编译失败：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-58fJ2nTn-1607265283115)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201205164115987.png)]

解决方案：

public class Book implements Serializable

我们自己编写的RedisTemplate

 @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        //我们为了自己开发方便，一般使用<String,Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        //JackSon序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        //String序列化配置
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();

        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();

        return template;
    }

Redis.Conf详解

启动的时候，就是通过配置文件来启动 ；

单位

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-25O1mWa8-1607265283116)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201205174640714.png)]

1.配置单位Units不区分大小写；

包含

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tmr1Dyx8-1607265283117)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201205174832291.png)]

可以把多个配置文件都配置过来

NetWork 网络

bind 127.0.0.1    #绑定的IP
protected-mode yes  #保护模式
port 6379      #端口

通用 GENERAL

daemoniza yes   #以守护线程的方式运行，默认是no，我们需要自己设为yes
pidfile /var/run/redis_6379.pid     #如果以后台的方式运行，我们需要指定一个pid文件

#日志
# Specify the server verbosity level.
# This can be one of:
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably)   生产环境
# warning (only very important / critical messages are logged)
loglevel notice
logfile ""                 #日志文件的位置
databases 16               #数据库的数量，默认是16个
always-show-logo yes       #是否总是显示LOGO

快照

持久化，在规定的时间内，执行了多少次操作，则会持久化到文件 .rdb.aof

redis是内存数据库，如果没有持久化，那么数据断电及失

#如果900s内，如果至少有一个key进行了修改，我们就进行持久化操作
save 900 1     
#如果300s内，如果至少有一个10 key进行了修改，我们就进行持久化操作
save 300 10
#如果60s内，如果至少有一个10000 key进行了修改，我们就进行持久化操作
save 60 10000

stop-writes-on-bgsave-error yes      #持久化如果出错，是否还需要继续工作
rdbcompression yes                   #是否压缩rdb文件，需要消耗一些CPU资源
rdbchecksum yes                  #保存rdb文件的时候，进行错误检查校验
dir ./                          #rdb文件保存的目录

REPLICATION 复制，讲解主从复制再行讲解

SECURITY 安全

限制 客户端

maxclients 10000             #设置能连接上redis的最大客户端数量
maxmemory <bytes>            #redis 配置最大的内存容量
maxmemory-policy noeviction  #内存到达上限之后的处理策略
1、volatile-lru：只对设置了过期时间的key进行LRU（默认值） 
2、allkeys-lru ： 删除lru算法的key   
3、volatile-random：随机删除即将过期key   
4、allkeys-random：随机删除   
5、volatile-ttl ： 删除即将过期的   
6、noeviction ： 永不过期，返回错误

APPEND ONLY MODE aof模式

appendonly no     #默认是不开启的，默认是使用rdb方式持久化，在大部分情况下，rdb完全够用
appendfilename "appendonly.aof"    #持久化文件的名字

# appendfsync always     #每秒修改都会sync,消耗性能
appendfsync everysec     #每秒执行一次，sync,可能会丢失这1s的数据！
# appendfsync no         #不执行sync,这个时候操作系统自己同步数据，速度最快！

Redis 持久化

Redis是内存数据库，如果不将内存中的数据库状态保存在磁盘，那么一旦服务器进程退出，服务器中的数据库状态也会消失，所有redis 提供了持久化功能！

RDB(Redis DataBase)

什么是RDB

在指定的时间间隔内将内存中的数据集快照写入磁盘，也就是行话讲的 Snapshot快照，它是恢复时将快照文件直接读在内存中；

Redis 会单独创建（fork）一个子进程来进行持久化，会先将数据写入到一个临时文件中，待持久化过程都结束了，再用这个临时文件替换上次持久化的文件。整个过程中，主进程是不进行任何IO操作的。这就确保了极高的性能。如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB方式要比AOF方式更加的高效。RDB的缺点是最后一次持久化后的数据可能丢失。

默认就是RDB，不需要修改

rdb保存的文件是 dump.rdb ,都是在配置文件中的快照进行配置的

触发机制

• save的规则满足的条件下，会自动触发rdb文件
• 执行flushall命令，也会触发我们的rdb文件
• 退出redis，也会产生rdb文件！

备份就自动生成一个dump.rdb

如何恢复rdb文件

• 只需要将rdb文件放在我们redis启动目录就可以，redis启动的时候就会自动检查dump.rdb
• 当前文件位置，Linux： /usr/local/bin

优点：

• 适合大规模的数据恢复
• 对数据的完整性要不高

缺点：

• 需要一定的时间间隔的进程操作！ 如果redis意外宕机了，这个最后一次修改的数据就没有了
• fork进程的时候，会占用一定的内存空间

AOF(Append Only File)

默认的就是对文件的无限追加

将我们的所有命令都记录下来，history，恢复的时候就把这个文件全部执行一遍。

以日志的形式来记录每一个写操作，将Redis执行过的所有指令都记录下来（读操作不记录），只许追加文件但不可以改写文件，redis 启动之初会读取该文件重新构建数据，换言之，redis重启的话就根据日志文件的内容将写指令从前到后执行一次完成数据的恢复工作。

AOF保存的是appendonly.aof 文件

append

默认是不开启的，我们需要手动进行配置，我们只需要将 appendonly yes 即可。

重启我们的redis即可以生效；

如果appendonly.aof 文件有错误，这时候redis是启动不起来的，这时候我们需要修复这个文件；

redis修复工具： redis-check-aof

redis-ckeck-aof --fix appendonly.aof     #修复命令

如果文件正常，重启就可以直接恢复了

AOF的优点：

• 每一次修改都同步，文件的完整性会更好
• 默认是每秒同步一次，可能会丢失一秒的数据

AOF的缺点：

• 相对于数据文件来说，aof远远大于rdb，修复的速度也比rdb慢
• aof运行效率也要比RDB慢，所有redis默认的配置是rdb持久化！

#rewrite 重写：
#如果一个aof是64M,文件太大了，则会fork新的一个进程来对我们的文件进行重写！
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

扩展：

1. RDB 持久化方式能够在指定时间间隔内对你的数据进行快照存储；
2. AOF持久化方式记录每次对服务器写的操作，当服务器重启的时候回重新执行这些命令来恢复原始数据，AOF命令以Redis协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，使得AOF文件的体积不会变的太大；
3. 只做缓存，如果你只希望你的数据在服务器上运行的时候存在，你也可以不用任何持久化；
4. 同时开启量尺持久化方式

• 在这种情况下，当redis重启的时候会优先载入AOF文件来恢复原始的数据，因为在通常情况下AOF文件保存的数据集要比RDB文件保存的数据集要更加完整；

• RDB的数据不实时，同时使用两者时服务器重启也只会找AOF文件，那要不要只使用AOF呢？ 作者建议不要，因为RDB更适合用于备份数据库（AOF在不断变化不好备份），快速重启，而且不会有AOF可能存在的潜在的bug，留着作为一个万一的手段。

  5.性能建议

• 因为RDB文件只用于做后备用途，建议只在Slave上持久化RDB文件，而且只要15分钟一次就够了，只保留slave 900 1 这条规则；

• 如果Enable AOF，好处是在最恶劣情况下也只会丢失不超过2秒的数据，启动脚本较简单只load自己的AOF文件即可，代价是带来了持续的IO，二是AOF rewrite的最后将rewrite过程中产生的新数据写到了新文件当中造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF rewrite的频率，AOF重写的基础大小默认值为64M,可以设到5G以上，默认超过原大小100%大小重写可以改到适当的数值

• 如果不Eable AOF，仅靠Master-slave Repllcation实现高可用性也可以，能省掉一大笔IO，也减少了rewrite时带来的系统波动。代价是如果Master/Slaver同时倒掉（宕机，断电），会丢失十几分钟的数据，启动脚本也要比较两个 Master/slaver中的RDB文件，载入较新的那个，微博就是这种架构。

Redis发布订阅

Redis的发布订阅（pub/sub）是一种消息通信模式，发送者（pub）发送消息，订阅者（sub）接收消息。微信，微博，关注系统！

Redis 客户端可以订阅任意数量的频道。

第一个： 消息发送者 第二个： 频道 第三个:消息接受者

下图展示了频道 channel1 ， 以及订阅这个频道的三个客户端 —— client2 、 client5 和 client1 之间的关系：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IruphFsu-1607265283118)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201205221601569.png)]

当有新消息通过 PUBLISH 命令发送给频道 channel1 时， 这个消息就会被发送给订阅它的三个客户端：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OEydFlal-1607265283119)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201205221618752.png)]

#订阅端
127.0.0.1:6379> SUBSCRIBE tanet                              #订阅一个频道  tanet
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "tanet"
3) (integer) 1
#等待读取推送消息
1) "message"                                #消息
2) "tanet"                                 #订阅频道
3) "hello"                                 #消息内容
1) "message"
2) "tanet"
3) "hello,redis"


#发送端
127.0.0.1:6379> PUBLISH tanet  hello                       #发布者发布消息到频道
(integer) 1
127.0.0.1:6379> PUBLISH tanet  hello,redis
(integer) 1

Redis 订阅指令：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uQTdvLtB-1607265283120)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201205222704050.png)]

原理 https://zhuanlan.zhihu.com/p/77239987

使用场景： 微信公众号； 实时消息系统！ 实时聊天 将信息回显给所以人即可

Redis主从复制

概念

主从复制，是将一台redis服务器的数据，复制到其他redis服务器当中。前者称为（master/leader），后者称为从节点（slave/follower）;数据的复制是单向的 ，只能由主节点到从节点。Master以写为主，slave以读为主；

默认的情况下，每台Redis服务器都是主节点；且一个主节点可以有多个从节点（或没有节点），但一个从节点只能有 一个主节点。

主从复制的作用包括：

1.数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式；

2.故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复，实际上是一种服务的冗余；

3.负载均衡：在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务（即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载；尤其是在写少读多的场景下，通过多个节点分担读负载，可以大大提高Redis服务器的并发量；

4.高可用基石：除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是redis高可用基础；

一般来说，要将Redis运用于工程项目中，只使用一台Redis是万万不能的（宕机），原因如下：

1.从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大；

2.从容量上，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有 的内存都用于Redis存储。 一般来说，单台Redis最大使用内存不应该超过20G;

环境配置

只配置从库，不用配置主库。

127.0.0.1:6379> info replication                                   #查看当前库的信息
# Replication
role:master                                                    #角色 master
connected_slaves:0                                            #没有从机
master_replid:9dee2a6713c100a5984a96b320842a638a896abe
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

复制3个配置文件，然后修改对应的信息

1.修改端口

2.pid的名字

3.log文件的名字

4.dump.rdb的名字

修改完毕之后，启动我们的3个redis服务器：通过进程信息来看

root@test-VirtualBox:/usr/local/bin# ps -ef | grep redis
test       366     1  0 10:54 ?        00:00:03 redis-server 127.0.0.1:6379
root      1815  1385  0 11:21 pts/0    00:00:00 vim redis79.conf
root      2009     1  0 11:23 ?        00:00:00 redis-server 127.0.0.1:6380
root      2280     1  0 11:29 ?        00:00:00 redis-server 127.0.0.1:6381
root      2288  2121  0 11:29 pts/2    00:00:00 grep --color=auto redis

一主二从

config文件配，配置replication

主机断开，从机依旧连接到主机，但是依旧没有写操作；

#主机断开
127.0.0.1:6379> SHUTDOWN
not connected> exit

#从机状态
127.0.0.1:6380> info replication
# Replication
role:slave
master_host:127.0.0.1 
master_port:6379                       #依旧连接主机
master_link_status:down
master_last_io_seconds_ago:-1
master_sync_in_progress:0
slave_repl_offset:3888
master_link_down_since_seconds:20
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:a934dfc9b8c63e159e9b6d8345777d9d5b75a4b1
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:3888
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:3888

127.0.0.1:6380> set k2 v2                     #就算主机断开从机也没有写操作，只能读
(error) READONLY You can't write against a read only replica.   

如果是使用命令行来配置的主从，这个时候如果从机重启，则会变成主机；

但只要变成从机，就能立马从主机中获取到值

127.0.0.1:6381> SHUTDOWN            #6381从机断开
not connected> exit

127.0.0.1:6379> set k3 v3          #主机set新值
OK

127.0.0.1:6380> get k3             #6380从机可以getk3
"v3"

#重新连接从机 6381
root@test-VirtualBox:/usr/local/bin# redis-server kconfig/redis81.conf 
root@test-VirtualBox:/usr/local/bin# redis-cli -p 6381
127.0.0.1:6381> get k3          #无法get到k3的值
(nil)
127.0.0.1:6381> info replication    #查看状态
# Replication

 #发现重启后变为主机，命令行配置主从宕机后会失效，永久主从需在conf文件配置
role:master                       
connected_slaves:0
master_replid:c841d99030e3bdcf88711ecbe845221d96e58a69
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0

 
127.0.0.1:6381> SLAVEOF 127.0.0.1 6379            #重新连接到主机
OK
127.0.0.1:6381> get k3                  #获取k3,发现可以正常获取
"v3"

主机连接状态：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xOL0m8rn-1607265283121)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201206133659772.png)]

从机显示状态：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6fCEMLcD-1607265283122)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201206133809215.png)]

复制原理：

Slave启动成功连接到master后会发送一个sync同步命令

Master接收命令之后，启动后台存盘进程，同时收集所有接收到的用于修改数据集命令，在后台进程执行完毕之后**，master将传送整个数据文件到slave，并完成一次同步。**

全量复制：salve 服务在接收到数据库文件数据后，将其存盘并加载到内存中；

增量复制：master继续将新的所有收集到的修改命令依次传给slave，完成同步

但是只要是重新连接master，一次完成同步（全量复制）将被自动执行！我们的数据一定可以在从机中看到！

层层链路模型

上一个M链接下一个S，也可以完成主从复制

如果主机断开了连接，我们可以使用slaveof no one 让自己变成主机！其他的节点就可以手机的链接到这个最新的主节点；

127.0.0.1:6379> SHUTDOWN                  #主机断开
not connected> exit

127.0.0.1:6380> SLAVEOF no one             #从机6380使用no one让自己变成主机
OK
127.0.0.1:6380> info replication
# Replication
role:master
connected_slaves:1                     #此时6381也归顺于它
slave0:ip=127.0.0.1,port=6381,state=online,offset=1211,lag=0
master_replid:b9a18ab3071a7d90a4d2d96edb27881aba5b3fd7
master_replid2:4d3beb09988e8d11b2fd681842a30e1c25a4dfcf
master_repl_offset:1225
second_repl_offset:1212
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:1225

127.0.0.1:6381> info replication
# Replication
role:slave
master_host:127.0.0.1
master_port:6380                                    #6381的主机节点为6380
master_link_status:up
master_last_io_seconds_ago:7
master_sync_in_progress:0
slave_repl_offset:1393
slave_priority:100
slave_read_only:1
connected_slaves:0
master_replid:b9a18ab3071a7d90a4d2d96edb27881aba5b3fd7
master_replid2:4d3beb09988e8d11b2fd681842a30e1c25a4dfcf
master_repl_offset:1393
second_repl_offset:1212
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:614
repl_backlog_histlen:780

如果这个时候老大修复了，也需要重新进行配置，老大底下没有slave

#6380老大返回
root@test-VirtualBox:/usr/local/bin# redis-server kconfig/redis79.conf 
root@test-VirtualBox:/usr/local/bin# redis-cli -p 6379
127.0.0.1:6379> info replication
# Replication
role:master
connected_slaves:0               #发现底下没有从机
master_replid:51af8bf02bd53f5adc091f37fe1930f153a8adbf
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:0
second_repl_offset:-1
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0

哨兵模式（自动选举老大）

概述

主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。这不是一种推荐的方式，更多时候，我们优先考虑哨兵模式。

可以监控主机是否有故障，如果故障了根据投票自动将从库改为主库。

哨兵模式是一种特殊的模式，首先Redis提供了哨兵的命令，哨兵是一个独立的进程，作为进程，它会独立运行。其原理是哨兵通过发送命令，等待Redis服务器响应，从而监控运行的多个Redis实例。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lmt4kTtF-1607265283123)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201206140834077.png)]

这里的哨兵有两个作用

• 通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器。
• 当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。

然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8OCr4b1P-1607265283124)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201206141705150.png)]

假设主服务器宕机，哨兵1先检测到这个结果，系统不会马上进行failover过程，仅仅是哨兵1主观的认为猪服务器不可用，这个现象称为主观下线，当后面的哨兵也检测到主服务器不可用，并且数量达到一定值时，那么哨兵之间就会进行一次投票，投票的结果由一个哨兵发起，进行failover[故障转移]操作。切换成功后，就会通过发布订阅的模式，让各个哨兵把自己监控的从服务器实现切换主机，这个过程就叫做客观下线。

测试

1.哨兵配置文件：

sentinel.conf
#sentinel monitor 被监控的名称 host port  1
sentinel monitor myredis 127.0.0.1 6379 1

后面这个数字1，代表主机挂了，slave投票看让谁替换称为主机，票数最多的，就会成为主机！

哨兵启动：

redis-sentinel kconfig/sentienl.conf

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0OJF5tDl-1607265283125)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201206143138898.png)]

如果主节点断开了，这个时候就会从 从机中随机选择一个服务器（里边有一个投票算法）

127.0.0.1:6379> SHUTDOWN            #断开主机，老大凉凉
not connected> exit

127.0.0.1:6381> info replication
# Replication
role:master                                   #此时6381变成主机
connected_slaves:1
slave0:ip=127.0.0.1,port=6380,state=online,offset=17523,lag=0
master_replid:9a5e287c24f598783a2de5b361abb04077a95c03
master_replid2:00142ca27bf627ae2726b59bdfac8cf6246104ca
master_repl_offset:17523
second_repl_offset:15479
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:17523

哨兵发现主机挂掉会重新选举一个主机:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-k8MYisuF-1607265283126)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201206143557110.png)]

所以6381就变成了新的主机。

如果主机此时回来了，只能归并到新的主机下，当做从机，这就是哨兵模式的规则

root@test-VirtualBox:/usr/local/bin# redis-server kconfig/redis79.conf     #主机回来
root@test-VirtualBox:/usr/local/bin# redis-cli -p 6379

#哨兵监测到主机回来
5215:X 06 Dec 2020 14:39:38.746 * +convert-to-slave slave 127.0.0.1:6379 127.0.0.1 6379 @ myredis 127.0.0.1 6381

127.0.0.1:6379> info replication
# Replication
role:slave                      
master_host:127.0.0.1
master_port:6381                         #此时主机被归并到新的主机 6381xia
master_link_status:up
master_last_io_seconds_ago:0
master_sync_in_progress:0
slave_repl_offset:43568
slave_priority:100
slave_read_only:1

127.0.0.1:6381> info replication
# Replication
role:master
connected_slaves:2                                #可以看到6381下有两个从机
slave0:ip=127.0.0.1,port=6380,state=online,offset=44256,lag=0
slave1:ip=127.0.0.1,port=6379,state=online,offset=44256,lag=0

哨兵模式

优点：

• 1，哨兵集群，基于主从复制模式，所有的主从配置优点，它都有
• 2，主从可以切换，故障可以转移，系统的可用性就会更好
• 3，哨兵模式就是主从模式的升级，手动到自动，更加健壮！

缺点：

• 1，Redis不好在线扩容，集群容量一旦到达上限，在线扩容就十分麻烦！
• 2，实现哨兵模式的配置其实是很麻烦的，里边有很多选择！

哨兵的全部配置

Redis缓存穿透和雪崩

一、缓存穿透(查不到)

概念

缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中，于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。

解决方案

1. 布隆过滤器

布隆过滤器是一种数据结构，垃圾网站和正常网站加起来全世界据统计也有几十亿个。网警要过滤这些垃圾网站，总不能到数据库里面一个一个去比较吧，这就可以使用布隆过滤器。假设我们存储一亿个垃圾网站地址。

可以先有一亿个二进制比特，然后网警用八个不同的随机数产生器（F1,F2, …,F8） 产生八个信息指纹（f1, f2, …, f8）。接下来用一个随机数产生器 G 把这八个信息指纹映射到 1 到1亿中的八个自然数 g1, g2, …,g8。最后把这八个位置的二进制全部设置为一。过程如下：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MUZOGN3H-1607265283127)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201206150331124.png)]

2.缓存空对象

当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源；

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AOA8viic-1607265283129)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201206150416229.png)]

但是这种方法会存在两个问题：

• 如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的空值的键；
• 即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。

二、缓存雪崩

1、概念

缓存雪崩是指，缓存层出现了错误，不能正常工作了。于是所有的请求都会达到存储层，存储层的调用量会暴增，造成存储层也会挂掉的情况。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5FQ9Rfu3-1607265283130)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201206151654294.png)]

2、解决方案

（1）redis高可用

这个思想的含义是，既然redis有可能挂掉，那我多增设几台redis，这样一台挂掉之后其他的还可以继续工作，其实就是搭建的集群。

（2）限流降级

这个解决方案的思想是，在缓存失效后，通过加锁或者队列来控制读数据库写缓存的线程数量。比如对某个key只允许一个线程查询数据和写缓存，其他线程等待。

（3）数据预热

数据加热的含义就是在正式部署之前，我先把可能的数据先预先访问一遍，这样部分可能大量访问的数据就会加载到缓存中。在即将发生大并发访问前手动触发加载缓存不同的key，设置不同的过期时间，让缓存失效的时间点尽量均匀。

三、缓存击穿

缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。

比如在做电商项目的时候，把这货就成为“爆款”。

其实，大多数情况下这种爆款很难对数据库服务器造成压垮性的压力。达到这个级别的公司没有几家的。所以，本着务实主义，对主打商品都是早早的做好了准备，让缓存永不过期。即便某些商品自己发酵成了爆款，也是直接设为永不过期就好了。

其他方式：

1. 使用互斥锁(mutex key): 这种解决方案思路比较简单，就是只让一个线程构建缓存，其他线程等待构建缓存的线程执行完，重新从缓存获取数据就可以了。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1HdZW7sE-1607265283131)(C:\Users\Cherry\AppData\Roaming\Typora\typora-user-images\image-20201206151943032.png)]

如果是分布式锁，就是用分布式锁来处理就好了。

2. "提前"使用互斥锁(mutex key)：

在value内部设置1个超时值(timeout1), timeout1比实际的memcache timeout(timeout2)小。当从cache读取到timeout1发现它已经过期时候，马上延长timeout1并重新设置到cache。然后再从数据库加载数据并设置到cache中。

3. “永远不过期”：

这里的“永远不过期”包含两层意思：

(1) 从redis上看，确实没有设置过期时间，这就保证了，不会出现热点key过期问题，也就是“物理”不过期。

(2) 从功能上看，如果不过期，那不就成静态的了吗？所以我们把过期时间存在key对应的value里，如果发现要过期了，通过一个后台的异步线程进行缓存的构建，也就是“逻辑”过期

总结

1. 热点key + 过期时间 + 复杂的构建缓存过程 => mutex key问题

2. 构建缓存一个线程做就可以了。

3. 四种解决方案：没有最佳只有最合适。