Redis从浅入深

1. redis安装

wget https://download.redis.io/releases/redis-6.2.6.tar.gz

解压缩包
```
tar -zxvf redis-6.2.6.tar.gz
```

安装gcc-c++，并编译

# 1. 安装gcc-c++ 不同的linux不一样，这里是centos安装命令
yum install gcc-c++
# 2. 进入目录下
cd redis-6.2.6
#3. 编译
make 
make install

redis默认安装目录/usr/local/bin

redis-benchmark:性能测试工具，可以在自己本子运行，看看自己本子性能如何
redis-check-aof：修复有问题的AOF文件，rdb和aof后面讲
redis-check-dump：修复有问题的dump.rdb文件
redis-sentinel：Redis集群使用
redis-server：Redis服务器启动命令
redis-cli：客户端，操作入口

把配置文件redis.conf 复制到我们相应的目录下，启动时指定配置文件路径即可
```
redis-server /root/conf/redis/redis.conf
```
连接客户端
```
redis-cli -p 6379
```
redis-benchmark是官方测试性能用的，可以看看

2. Redis基础知识

数据库说明
- redis默认有16个库，默认选中db 0
- 简单命令：
  - select 切换数据库
  - dbsize 查看数据库大小
  - flushdb 清除当前数据库
  - flushall 清除全部数据库
内存模型

redis是基于内存的，CPU不是redis的性能瓶颈，Redis的性能瓶颈主要在内存和网络带宽，既然可以用单线程就用单线程实现了。

redis单线程为什么快?

redis 是将所有的数据全部放在内存中的，所以说使用单线程去操作效率就是最高的，多线程（CPU上下文会切换：耗时的操作！！！），对于内存系统来说，如果没有上下文切换效率就是最高

的！多次读写都是在一个CPU上的，在内存情况下，这个就是最佳的方案！
数据类型及常用命令
1. keys相关
  - keys * 查看所有的key值
  - set [key] [value] 设置键值
  - exists [key] 判断键值是否存在
  - move [key] [db] 移动某个键值到其他库
  - clear 清屏
  - get [key] 获取键值
  - expire [key] [time] 设置key的过期时间，单位为秒
  - ttl [key] 查看当前key的过期时间
  - type [key] 查看key的数据类型
2. String字符串
  - set [key] [value] 设置键值对
  - append [key] [value] 往后追加字符串，没有会新建
  - strlen [key] 查看键值长度
  - incr [key] 自增1
  - incrby [key] [step] 设置步长自增
  - decr [key] 自减1
  - decrby [key] [step] 设置步长自减
  - getrange [key] [start] [end] 截取字符串
  - setrange [key] [start] [value] 替换指定未知开始的字符串
  - setex [key] [expire] [value] 设置值并设置过期时间
  - setnx [key] [value] 不存在就设值
  - mset [key1] [value1] [key2] [value2] ..... 批量设置键值
  - mget [key1] [key2] 批量查询键值
  - msetnx [key1] [value1] [key2] [value2] ..... 批量设置键值,不存在就塞值
  - getset [key] [value] 获取老的值并设置新值
3. List 列表
  
  命令都是以L，R开头
  - lpush [key] [value] 插入列表头
  - lrange [key] [start] [end] 获取列表中的元素
  - rpush [key] [value] 插入列表尾
  - lpop [key] 移除第一个元素
  - rpop [key] 移除最后一个元素
  - lindex [key] [index] 获取第index个元素
  - lrem [key] [num] [value] 精确匹配删除指定的元素
  - ltrim [key] [start] [end] 截取指定长度，缓存中的值也会改变
  - rpoplpush [key1] [key2] 移除列表key1尾部的一个元素并放入列表key2的头部
  - lset [key] [index] [value] 修改指定索引值
4. Set集合
  - sadd [key] [value] 往集合中插入值
  - smembers [key] 查看指定set的值
  - sismember [key] [value] 查看某个值是否在set中
  - scard [key] 返回集合大小
  - srem [key] [value] 移除集合指定元素
  - srandmember [key] 随机取出一个元素
  - srandmember [key] [num] 随机取出num个元素
  - spop [key] 随机取出某个元素并删除
  - smove [key1] [key2] [value] 移除key1的元素到key2中
  - sdiff [key1] [key2] 差集
  - sinter [key1] [key2] 交集
  - sunion [key1] [key2] 并集
5. hash哈希
  - hset [key] [mkey] [mvalue] 往哈希中插入值
  - hset [key] [mkey] 获取哈希中的某个值
  - hset [key] [mkey1] [mvalue1] [mkey2] [mvalue2] ... 往哈希中批量插入值
  - hset [key] [mkey1] [mkey2] 获取哈希中的多个值
  - hgetall [key] 获取哈希中的所有值
  - hdel [key] [mkey] 删除hash中的某个值
  - hlen [key] 获取哈希中的字段数量
  - hexists [key] [mkey] 判断是否存在某个key值
  - hkeys [key] 获取哈希中的所有字段
  - hvals [key] 获取哈希中的所有值
  - hincyby [key] [mkey] 哈希中对应的字段值自增
  - hsetnx [key] [mkey] [mvalue] 不存在可以设置，存在就不能设置
6. zset有序集合
  - zadd [key] [score] [value] 往有序集合中添加元素，并添加排序指标
  - zrange [key] [start] [end] 获取有序集合元素
  - zrangebyscore [key]-inf +inf 获取全部的集合，从小到大
  - zrevrange [key] [start] [end] 倒序获取集合元素
  - zrem [key] [value] 移除某个元素
  - zcard [key] 获取集合中的元素
  - zcount [key] [start] [end] 指定区间的成员数量

3. Redis特殊数据类型

Geospatial 地理位置

geoadd [key] [longitude] [latitude] [city] 添加地理位置
geopos [key] [city] 获取城市的经纬度
geodist [key] [city1] [city2] [m] 获取两个位置的直线距离，[m] 单位
georadius [key] [longitude] [latitude] [radius] [m] 获取以给定的经纬度为中心，找出某个半径内的元素
georadiusbymember [key] [city] [radius] [m] 找出位于指定元素周围的其他元素！

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

pfadd [key] [value1] [value2] 创建一组元素
pfcount [key] 统计基数数量
pfmerge [key3] [key1] [key2] 合并两组到第三组

Bitmap位存储

setbit [key] [index] [0|1] 设置位值
getbit [key] [index] 获取位值
bitcount [key] 统计为1的值

4. Redis事务

本质：一组命令的集合，一个事务中的所有命令都会被序列化，在事务执行的过程汇总，会按照顺序执行

redis事务没有隔离级别的概念
Redis单条命令式保存原子性的，但是事务不保证原子性！

事务流程：

开启事务 multi
命令入队
执行事务（exec）取消事务（discard）

锁

悲观锁：比较悲观，认为什么时候都会出问题，无论做什么都会枷锁
乐观锁: 一般不会出问题，只有在更新数据的时候才去判断一下是否有人修改过数据，这里一般都使用版本号version控制

watch

监控某个值，开启事务，如果在事务内值被改变，提交事务会发生异常，事务回滚
可以使用unwatch接触监控‘
另外调用exec或者discard之后，监控自动移除

5. Redis在java中使用

jedis

maven 依赖

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.2.0</version>
</dependency>

连接使用

Jedis jedis = new Jedis("127.0.0.1", 6379);

spring-boot

maven 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

在application.ymal中增加配置

spring: 
	redis:
		host: 127.0.0.1 
		port: 6379

自动以redis配置

@Configuration
public class RedisConfig {
    // 这是我给大家写好的一个固定模板，大家在企业中，拿去就可以直接使用！
    // 自己定义了一个 RedisTemplate
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 我们为了自己开发方便，一般直接使用
        //<String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        // Json序列化配置
        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;
    }
}

启动类

@SpringBootApplication
public class WebApplication {
    public static void main(String[] args) {
        SpringApplication.run(WebApplication.class, args);
    }
}

测试类

@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    public void test() {
        redisTemplate.opsForValue().set("myKey","myValue");
        System.out.println(redisTemplate.opsForValue().get("myKey"));
    }
}

6. Redis配置文件详解

设置外网可以访问
- 开放端口
  - 关闭防火墙：systemctl stop firewalld.service
  - 开放6379端口：iptables -I INPUT -p tcp --dport 6379 -j ACCEPT
- 修改redis.conf
```
bind 127.0.0.1 # 注释这一行
protected-mode no # 关闭保护模式
```
- 重启redis

单位

1k => 1000 bytes
1kb => 1024 bytes
1m => 1000000 bytes
1mb => 1024*1024 bytes
1g => 1000000000 bytes
1gb => 1024*1024*1024 bytes

大小不敏感

网络

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

通用

daemonize yes # 以守护进程的方式运行，默认是 no，我们需要自己开启为yes！ 
pidfile /var/run/redis_6379.pid # 如果以后台的方式运行，我们就需要指定一个 pid 文件！
loglevel notice logfile "" # 日志的文件位置名 
databases 16 # 数据库的数量，默认是 16 个数据库 
always-show-logo yes # 是否总是显示LOGO

快照

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

# 如果900s内，如果至少有一个1 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 文件保存的目录！

安全
```
requirepass foobared # 设置密码
```

限制

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 模式 aof配置

appendonly no # 默认是不开启aof模式的，默认是使用rdb方式持久化的，在大部分所有的情况下， rdb完全够用！ 
appendfilename "appendonly.aof" # 持久化的文件的名字 
#appendfsync always # 每次修改都会 sync。消耗性能 
appendfsync everysec # 每秒执行一次 sync，可能会丢失这1s的数据！ 
# appendfsync no # 不执行 sync，这个时候操作系统自己同步数据，速度最快！

7. Redis持久化

RDB

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

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

触发机制：

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

恢复机制：

只需要将rdb文件放在我们redis启动目录就可以，redis启动的时候会自动检查dump.rdb 恢复其中的数据！

优点：

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

缺点：

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

AOF

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

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

如果aof有问题，配置了appendonly为yes，那么启动redis就会报错，通过redis-check-aof--fix 修复

aof文件是追加的，如果超出了指定大小，会fork一个新的进程将我们的文件进行重写

appendonlyno  #默认是不开启aof模式的，默认是使用rdb方式持久化的，在大部分所有的情况下，rdb完全够用！
appendfilename"appendonly.aof" #持久化的文件的名字
#appendfsyncalways #每次修改都会sync。消耗性能
appendfsynceverysec #每秒执行一次sync，可能会丢失这1s的数据！
#appendfsyncno   #不执行sync，这个时候操作系统自己同步数据，速度最快！

优点：

每一次修改都同步，文件的完整会更加好！
每秒同步一次，可能会丢失一秒的数据
从不同步，效率最高的！

缺点：

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

说明

RDB 持久化方式能够在指定的时间间隔内对你的数据进行快照存储
AOF 持久化方式记录每次对服务器写的操作，当服务器重启的时候会重新执行这些命令来恢复原始的数据，AOF命令以Redis 协议追加保存每次写的操作到文件末尾，Redis还能对AOF文件进行后台重写，使得AOF文件的体积不至于过大。
只做缓存，如果你只希望你的数据在服务器运行的时候存在，你也可以不使用任何持久化
同时开启两种持久化方式：
- 在这种情况下，当redis重启的时候会优先载入AOF文件来恢复原始的数据，因为在通常情况下AOF 文件保存的数据集要比RDB文件保存的数据集要完整。
- RDB 的数据不实时，同时使用两者时服务器重启也只会找AOF文件，那要不要只使用AOF呢？作者建议不要，因为RDB更适合用于备份数据库（AOF在不断变化不好备份），快速重启，而且不会有AOF可能潜在的Bug，留着作为一个万一的手段。
性能建议：
- 因为RDB文件只用作后备用途，建议只在Slave上持久化RDB文件，而且只要15分钟备份一次就够了，只保留 save 900 1 这条规则。
- 如果Enable AOF ，好处是在最恶劣情况下也只会丢失不超过两秒数据，启动脚本较简单只load自己的AOF文件就可以了，代价一是带来了持续的IO，二是AOF rewrite 的最后将 rewrite 过程中产生的新数据写到新文件造成的阻塞几乎是不可避免的。只要硬盘许可，应该尽量减少AOF rewrite 的频率，AOF重写的基础大小默认值64M太小了，可以设到5G以上，默认超过原大小100%大小重写可以改到适当的数值。
- 如果不Enable AOF ，仅靠 Master-Slave Repllcation 实现高可用性也可以，能省掉一大笔IO，也减少了rewrite时带来的系统波动。代价是如果Master/Slave 同时倒掉，会丢失十几分钟的数据，启动脚本也要比较两个 Master/Slave 中的 RDB文件，载入较新的那个，微博就是这种架构。

8. Redis发布订阅

命令

PSUBSCRIBE pattern [pattern ...] 订阅一个或多个符合给定模式的频道。
PUBSUB subcommand [argument [argument ...] 查看订阅与发布系统状态。
PUBLISH channel message 将信息发送到指定的频道。
PUNSUBSCRIBE [pattern [pattern ...] 退订所有给定模式的频道。
SUBSCRIBE channel [channel ...] 订阅给定的一个或多个频道的信息。
UNSUBSCRIBE [channel [channel ...] 指退订给定的频道。

9. Redis主从复制

主从复制，是指将一台Redis服务器的数据，复制到其他的Redis服务器。前者称为主节点(master/leader)，后者称为从节点(slave/follower)；数据的复制是单向的，只能由主节点到从节点。Master以写为主，Slave 以读为主。一个主节点可以有多个从节点(或没有从节点)，但一个从节点只能有一个主节点

作用：

数据冗余：主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。
故障恢复：当主节点出现问题时，可以由从节点提供服务，实现快速的故障恢复；实际上是一种服务的冗余
负载均衡：在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务。即写Redis数据时应用连接主节点，读Redis数据时应用连接从节点），分担服务器负载；尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高Redis服务器的并发量。
高可用（集群）基石：除了上述作用以外，主从复制还是哨兵和集群能够实施的基础，因此说主从复制是Redis高可用的基础。

单机redis的缺点：

从结构上，单个Redis服务器会发生单点故障，并且一台服务器需要处理所有的请求负载，压力较大；
从容量上，单个Redis服务器内存容量有限，就算一台Redis服务器内存容量为256G，也不能将所有内存用作Redis存储内存，一般来说，单台Redis最大使用内存不应该超过20G

主从复制，读写分离！ 80% 的情况下都是在进行读操作！减缓服务器的压力！架构中经常使用！一主二从！

编写三个配置文件

redis6380.conf

include ./redis.conf
pidfile ./redis_6380.pid
port 6380
dbfilename dump6380.rdb

redis6381.conf

include ./redis.conf
pidfile ./redis_6381.pid
port 6381
dbfilename dump6381.rdb

redis6382.conf

include ./redis.conf
pidfile ./redis_6382.pid
port 6382
dbfilename dump6382.rdb

依次启动

redis-server redis6380conf
redis-server redis6381conf
redis-server redis6382.conf

redis启动时默认都是主库，只需要把主库配置成从库就好了

slaveof  <ip> <port> # 配置为某个主机的从库
slaveof 127.0.0.1 6380 # 连接81,82客户端后执行，将其配置为80的从库，也可以直接在配置文件中指定主库

查看配置

127.0.0.1:6380> info replication
# Replication
role:master
connected_slaves:2
slave0:ip=127.0.0.1,port=6381,state=online,offset=476,lag=1
slave1:ip=127.0.0.1,port=6382,state=online,offset=476,lag=1
master_failover_state:no-failover
master_replid:fdc8bb26197a9e2f00c17c7fcff5ea8974a5faf8
master_replid2:0000000000000000000000000000000000000000
master_repl_offset:476
second_repl_offset:-1
repl_backlog_active:1
repl_backlog_size:1048576
repl_backlog_first_byte_offset:1
repl_backlog_histlen:476

主机可以读写，从机只能读
从机第一次连接到主机会进行全量复制，后续的写操作都会是增量复制
如果主机宕机，需要手动设置主机，手动设置主机之后，也需要主动将从机设置为新主机的从机

10. Redis哨兵模式

自动选举主机，是对主从复制，主机宕机的一种优化。主从切换技术的方法是：当主服务器宕机后，需要手动把一台从服务器切换为主服务器，这就需要人工干预，费事费力，还会造成一段时间内服务不可用。

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

作用：

通过发送命令，让Redis服务器返回监控其运行状态，包括主服务器和从服务器
当哨兵监测到master宕机，会自动将slave切换成master，然后通过发布订阅模式通知其他的从服务器，修改配置文件，让它们切换主机。
然而一个哨兵进程对Redis服务器进行监控，可能会出现问题，为此，我们可以使用多个哨兵进行监控。各个哨兵之间还会进行监控，这样就形成了多哨兵模式。

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

配置哨兵

sentinel.conf

sentinel monitor myredis 127.0.0.1 6379 1

启动哨兵

redis-sentinel sentinel.conf #启动哨兵

原理

如果Master 节点断开了，这个时候就会从从机中随机选择一个服务器！

如果主机此时回来了，只能归并到新的主机下，当做从机，这就是哨兵模式的规则！
优点
- 哨兵集群，基于主从复制模式，所有的主从配置优点，它全有
- 主从可以切换，故障可以转移，系统的可用性就会更好
- 哨兵模式就是主从模式的升级，手动到自动，更加健壮！

缺点

Redis 不好啊在线扩容的，集群容量一旦到达上限，在线扩容就十分麻烦！

实现哨兵模式的配置其实是很麻烦的，里面有很多选择！

#哨兵sentinel实例运行的端口默认26379 
port 26379
#quorum配置多少个sentinel哨兵统一认为master主节点失联那么这时客观上认为主节点失联了
#sentinelmonitor<master-name><ip><redis-port><quorum>
sentinel monitor mymaster 127.0.0.1 63792
#当在Redis实例中开启了requirepassfoobared授权密码这样所有连接Redis实例的客户端都要提供密码
#设置哨兵sentinel连接主从的密码注意必须为主从设置一样的验证密码
#sentinelauth-pass<master-name><password>
sentinel auth -pass mymasterMySUPER--secret-0123passw0rd
#指定多少毫秒之后主节点没有应答哨兵sentinel此时哨兵主观上认为主节点下线默认30秒
#sentineldown-after-milliseconds<master-name><milliseconds>
sentineldown-after-millisecondsmymaster30000
#这个配置项指定了在发生failover主备切换时最多可以有多少个slave同时对新的master进行同步，这个数字越小，完成failover所需的时间就越长，但是如果这个数字越大，就意味着越多的slave因为replication而不可用。可以通过将这个值设为1来保证每次只有一个slave处于不能处理命令请求的状态。
#sentinelparallel-syncs<master-name><numslaves>
sentinel parallel-syncs mymaster 1
#故障转移的超时时间failover-timeout可以用在以下这些方面：
#1.同一个sentinel对同一个master两次failover之间的间隔时间。
#2.当一个slave从一个错误的master那里同步数据开始计算时间。直到slave被纠正为向正确的master那里同步数据时。
#3.当想要取消一个正在进行的failover所需要的时间。 
#4.当进行failover时，配置所有slaves指向新的master所需的最大时间。不过，即使过了这个超时，slaves依然会被正确配置为指向master，但是就不按parallel-syncs所配置的规则来了
#默认三分钟
#sentinelfailover-timeout<master-name><milliseconds>
sentinelfailover-timeoutmymaster180000
#通知脚本
sentinelnotification-scriptmymaster/var/redis/notify.sh

11. Redis缓存穿透和雪崩

Redis缓存的使用，极大的提升了应用程序的性能和效率，特别是数据查询方面。但同时，它也带来了一些问题。其中，最要害的问题，就是数据的一致性问题，从严格意义上讲，这个问题无解。如果对数据的一致性要求很高，那么就不能使用缓存。

另外的一些典型问题就是，缓存穿透、缓存雪崩和缓存击穿。目前，业界也都有比较流行的解决方案。

缓存穿透
- 产生原因：缓存穿透的概念很简单，用户想要查询一个数据，发现redis内存数据库没有，也就是缓存没有命中，于是向持久层数据库查询。发现也没有，于是本次查询失败。当用户很多的时候，缓存都没有命中（秒杀！），于是都去请求了持久层数据库。这会给持久层数据库造成很大的压力，这时候就相当于出现了缓存穿透。
- 解决方案：布隆过滤器是一种数据结构，对所有可能查询的参数以hash形式存储，在控制层先进行校验，不符合则丢弃，从而避免了对底层存储系统的查询压力；当存储层不命中后，即使返回的空对象也将其缓存起来，同时会设置一个过期时间，之后再访问这个数据将会从缓存中获取，保护了后端数据源；
- 产生的新问题：1. 如果空值能够被缓存起来，这就意味着缓存需要更多的空间存储更多的键，因为这当中可能会有很多的空值的键 2. 即使对空值设置了过期时间，还是会存在缓存层和存储层的数据会有一段时间窗口的不一致，这对于需要保持一致性的业务会有影响。
缓存击穿
- 产生云因：缓存击穿，是指一个key非常热点，在不停的扛着大并发，大并发集中对这一个点进行访问，当这个key在失效的瞬间，持续的大并发就穿破缓存，直接请求数据库，就像在一个屏障上凿开了一个洞。
- 解决方案： 1. 设置热点数据永不过期 2.加互斥锁
缓存雪崩
- 产生原因：在某一个时间段，缓存集中过期失效。Redis 宕机！
- 解决方案：1. redis高可用 2.限流降级 3. 数据预热

12 redis集群

Redis集群是一个由多个主从节点群组成的分布式服务集群，它具有复制、高可用和分片特性。Redis集群不需要sentinel哨兵也能完成节点移除和故障转移的功能。需要将每个节点设置成集群模式，这种集群模式没有中心节点，可水平扩展，据官方文档称可以线性扩展到上万个节点(官方推荐不超过1000个节点)。redis集群的性能和高可用性均优于之前版本的哨兵模式，且集群配置非常简单。

Redis集群的优点：

（1）Redis集群有多个master，可以减小访问瞬断问题的影响；

　　若集群中有一个master挂了，正好需要向这个master写数据，这个操作需要等待一下；但是向其他master节点写数据是不受影响的。

（2）Redis集群有多个master，可以提供更高的并发量；　　

（3）Redis集群可以分片存储，这样就可以存储更多的数据；

Redis集群的搭建(三主三从)

需要六个单独配置文件，配置文件修改相应的端口

[root@localhost cluster]# cat cluster1/8000/redis8000.conf
include /root/conf/redis/cluster/redis.conf
pidfile ./redis_8000.pid
port 8000
dbfilename dump8000.rdb
cluster-enabled yes
cluster-config-file nodes-8000.conf
cluster-node-timeout 5000
appendonly yes
requirepass redis-pw
masterauth redis-pw
dir /root/conf/redis/cluster/cluster1/8000

复制到对应目录下，然后修改配置

:%s/8000/8001/g

启动六个服务

[root@localhost cluster]# redis-server /root/conf/redis/cluster/cluster1/8000/redis8000.conf
[root@localhost cluster]# redis-server /root/conf/redis/cluster/cluster1/8001/redis8001.conf
[root@localhost cluster]# redis-server /root/conf/redis/cluster/cluster2/8010/redis8010.conf
[root@localhost cluster]# redis-server /root/conf/redis/cluster/cluster2/8011/redis8011.conf
[root@localhost cluster]# redis-server /root/conf/redis/cluster/cluster3/8020/redis8020.conf
[root@localhost cluster]# redis-server /root/conf/redis/cluster/cluster3/8021/redis8021.conf

搭建集群

redis-cli -a redis-pw --cluster create --cluster-replicas 1 192.168.148.130:8000 192.168.148.130:8001 192.168.148.130:8010  192.168.148.130:8011 192.168.148.130:8020 192.168.148.130:8021

-a 集群密码
--cluster-replicas 1 集群副本数量

客户端连接命令：src/redis‐cli --cluster help

create：创建一个集群环境host1:port1 ... hostN:portN
call：可以执行redis命令
add-node：将一个节点添加到集群里，第一个参数为新节点的ip:port，第二个参数为集群中任意一个已经存在的节点的ip:port
del-node：移除一个节点
reshard：重新分片
check：检查集群状态

#‐a表示服务端密码；‐c表示集群模式；-h指定ip地址；-p表示端口号
redis-cli -a redis-pw -c -h 192.168.1.1 -p 8001

192.168.148.130:8000>
cluster info # 集群信息
cluster nodes # 查看集群节点信息

注意点

杀掉所有的redis服务

ps -ef|grep redis|grep -v grep|cut -c 9-15|xargs kill -9

如果服务不同可以尝试关闭防火墙

systemctl stop firewalld # 临时关闭防火墙
systemctl disable firewalld # 禁止开机启动

Redis集群原理分析

Redis Cluster 将所有数据划分为 16384 个 slots（槽位），每个节点负责其中一部分槽位。槽位的信息存储于每个节点中。只有master节点会被分配槽位，slave节点不会分配槽位。

当Redis Cluster 的客户端来连接集群时，它也会得到一份集群的槽位配置信息，并将其缓存在客户端本地。这样当客户端要查找某个 key 时，可以直接定位到目标节点。同时因为槽位的信息可能会存在客户端与服务器不一致的情况，还需要纠正机制来实现槽位信息的校验调整。

posted @ 2021-10-18 20:25 雾里看花的少年阅读(51) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

雾里看花

云上看景