Redis快速上手

一.Redis介绍

1.1引言(解决的问题)

1.由于用户量增大，请求数量也随之增大，数据库压力过大。

2.多台服务器之间，数据不同步

3.多台服务器之间的锁已经不存在互斥性了。

意味着多服务器时，每台服务器单独存在

1.2NoSQL

redis就是一款NoSQL

NoSQL ->非关系型数据库 ->Not Only SQL

1.Key-Value：Redis…

2.文档型：ElasticSearch，solr，MongoDB…

3.面向列：Hbase，Cassandra…

4.图形化：Neo4j…

除了关系型数据库都是非关系型数据库

NoSQL只是一种概念，泛指非关系型数据库

1.3Redis介绍

Redis（remote Dictionary Servr）即远程字典服务；Redis是由C语言编写；Redis是一款Key-Value的NoSQL，而且Redis是基于内存存储数据的；Redis还提供了多种持久化机制，性能可以达到110000/s读取数据以及81000/s写入数据；Redis还提供了主从，哨兵以及集群的搭建方式，可以更方便的横向扩展以及垂直扩展。

二.安装Redis

1.安装redis(服务)

https://github.com/redis/redis

2.安装redis-desktop-Manager(图形化界面)

https://github.com/uglide/RedisDesktopManager/tree/2022

三.Redis常用命令

3.1Redis储存数据的结构

常用的5种数据结构

• key-string：一个key对应一个值
• key-hash：一个key对应一个Map
• key-list：一个key对应一个列表(有序允许重复)
• key-set：一个key对应一个集合(无序不允许重复)
• key-zset：一个key对应一个有序的集合(有序不允许重复)

另外3种不常用的数据结构

• HyperLogLog：计算近似值
• GEO：地理位置
• BIT：一般存储的也是一个字符串，存储的是一个byte[]

常用的5种数据结构图

• key-string：最常用的，一般用于存储一个值
• key-hash：存储一个对象数据的
• key-list：使用list结构实现栈和队列结构
• key-set：交集、差集和并集的操作
• key-zset：排行榜、积分存储等操作

3.2 string常用命令

# 1. 添加值
set key value

# 2. 取值
get key

# 3. 批量操作
mset key value [key value]
mset key [key...]

---

# 4. 自增命令
incr key

# 5. 自减命令
desr key

# 6. 自增或者自减指定数量
incrby key increment
decrby key increment

---

# 7. 设置值的同时指定生存时间(每次向Redis添加数据时，尽量设置生存时间)
setex key second value

# 8. 设置值，如果当前key不存在的话(如果这个key存在，什么也不做。若不存在，和set命令一样)
setnx key value

# 9. 在key对应的value后追加内容
append key value

# 10. 查看value字符串的长度
strlen key

3.3 hash常用命令

# 1. 存储数据
hset key field value

# 2. 获取数据
hget key field

# 3. 批量操作
hmset key field value [field value...]
hmset key field [field...]

---

# 4. 自增(指定自增值(+|-))
hincrby key field increment

---

# 5. 设置值(如果key-field不存在，则正常添加；如果存在则什么也不做)
hsetnx key field value

# 6. 检查field是否存在
hexists key field

# 7. 删除key对应的field，可以删除多个
hdel key field[field...]

---

# 8. 获取当前hash结构中的全部field和value
hgetall key

# 9. 获取当前hash结构中所有的field
hkeys key

# 10. 获取当前hash结果中所有的value
hvals key

# 11. 获取当前hash中field的数量
hlen key

3.4 list常用命令

# 1. 存储数据(从左侧插入数据，从右侧插入数据)
lpush key value [key value...]
rpush key value [key value...]

# 2. 存储数据(如果key不存在则什么也不做；如果key存在但是不是list结构，什么也不做)
lpushx key value
rpushx key value

# 3. 修改数据(在存储数据时指定索引位置，会覆盖之前索引位置的数据，超出长度则失败)
lset key index value

---

# 4. 弹栈方式获取数据(左侧弹出数据，右侧弹出数据)(会移除数据)
lpop key
rpop key

# 5. 获取指定索引范围的数据(start从0开始，stop输入-1代表最后一个，-2代表倒数第二个)
lrange key start stop

# 6. 获取指定索引位置的数据
lindex key index

# 7. 获取整个列表的长度
llen key

---

# 8. 删除列表中的数据(删除当前列表中的count个value值，count>0从左侧向右侧删除，count<0从右侧向左侧删除，count==0删除列表中全部value)
lrem key count value

# 9. 保留列表中的数据(保留你指定索引范围内的数据，超过整个索引范围被移除掉)
ltrim key start stop

# 10. 将一个列表中最后一个数据插入到另一个列表中的头部位置
rpoplpush list1 list2

3.5 set常用命令

# 1. 存储数据
sadd key member [member...]

# 2. 获取数据(获取全部数据)
smembers key

# 3.随机获取一个数据(获取的同时移除数据,count默认为1，代表弹出的数量)
spop key [count]

---

# 4. 交集(取多个set集合交集)
sinter set1 set2...

# 5. 并集(获取全部集合中的数据)
sunion set1 set2...

# 6. 差集(获取多个集合中不一样的数据)
sdiff set1 set2...

---

# 7. 删除数据
srem key member [member...]

# 8. 查看当前的set集合中是否包含这个值
sismember key member

3.6 zset常用命令

# 1. 添加数据(score必须是数值，member不允许重复)
zadd key score member [score member...]

# 2. 修改member的分数
zincrby key increment member

---

# 3. 查看指定的member分数
zscore key member

# 4. 获取zset中数据的数量
zcard key

# 5. 根据score的范围查询member数量
zcount key min max

# 6. 删除zset中的成员
zrem key member [member...]

---

# 7. 根据分数从小到大排序，获取指定范围内的数据(withscores如果添加这个参数，那么会返回member对应的分数)
zrange key start stop [withscores]

# 8. 根据分数从小到大排序，获取指定范围内的数据(withscores如果添加这个参数，那么会返回member对应的分数)
zrevrange key start stop [withscores]

# 9. 根据分数的范围获取数据(withscores代表同时返回score)
zrangebyscore key min max [withscores] [limit offset count]

# 10. 根据分数的范围获取数据(withscores代表同时返回score)
zrangebyscore key max min [withscores] [limit offset count]

3.7 key常用命令

# 1. 查看Redis中全部的key(pattern：*，xxx*，*xxx)
keys pattern

# 2. 查看某一个key是否存在(1存在，0不存在)
exists key

# 3. 删除key
del key [key...]

---

# 4. 设置key的生存时间，单位为秒，单位为毫秒
expire key second
pexpire key millisecond

# 5. 设置key的生存时间，单位为秒，单位为毫秒(活到时间点)
expire key timestamp
pexpire key millisecond

# 6. 查看key的剩余生存时间(-2当前key不存在，-1当前key未设置生存时间)
ttl key
pttl key

# 7. 移除key的生存时间(1移除成功，0key不存在或未设置生存时间)
persist key

---

# 8. 选择操作的库
select 0~15

# 9. 移动key到库中
move key db

3.8 库的常用命令

# 1. 清空当前所在的数据库
flushdb

# 2. 清空全部数据库
flushall

# 3. 查看当前数据库中有多少个key
dbsize

# 4. 查看最后一次操作的时间
lastsave

# 5. 实时监控Redis服务接收到的命令
monitor

四.Java连接Redis

Jedis连接Redis，lettuce连接Redis

4.1 Jedis连接Redis

1.创建Maven项目

2.导入需要的依赖

<dependencies>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.22</version>
    </dependency>
</dependencies>

3.测试

@Test
public void set(){
    //1.连接redis
    Jedis jedis = new Jedis("127.0.0.1",6379);
    //2.操作redis
    jedis.set("name","李四");
    //3.释放资源
    jedis.close();
}

@Test
public void get(){
    //1.连接redis
    Jedis jedis = new Jedis("127.0.0.1",6379);
    //2.操作redis
    String value = jedis.get("name");
    System.out.println(value);
    //3.释放资源
    jedis.close();
}

4.2 Jedis如何存储一个对象到Redis中–byte[]

1.准备一个User实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
    private Integer id;
    private String name;
    private Date birthday;
}

2.导入spring-context依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.3.18.RELEASE</version>
</dependency>

3.创建Demo测试类，编写内容

public class Demo2 {
    //以byte[]形式存储到Redis中
    @Test
    public void setByteArray(){
        //1.连接redis
        Jedis jedis = new Jedis("127.0.0.1",6379);

        //2.1准备key(String)->value(user)
        String key = "user";
        User value = new User(1, "张三", new Date());
        //2.2将key和value转换为byte[]
        byte[] byteKey = SerializationUtils.serialize(key);
        byte[] byteValue = SerializationUtils.serialize(value);
        //2.3将key和value存储到Redis
        jedis.set(byteKey, byteValue);

        //3.释放资源
        jedis.close();
    }

    //以byte[]形式在Redis中获取
    @Test
    public void getByteArray(){
        //1.连接redis
        Jedis jedis = new Jedis("127.0.0.1",6379);

        //2.1准备key
        String key = "user";
        //2.2将key转换为byte[]
        byte[] byteKey = SerializationUtils.serialize(key);
        //2.3Jedis去Redis中获取value
        byte[] value = jedis.get(byteKey);
        //2.4将value反序列化为User对象
        User user = (User) SerializationUtils.deserialize(value);
        //2.5输出
        System.out.println("user："+user);
        //3.释放资源
        jedis.close();
    }
}

4.3 Jedis如何存储一个对象到Redis中–String

1.导入依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
</dependency>

2.测试

public class Demo3 {

    @Test
    public void setString(){
        //1.连接redis
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        //2.1准备key(String)->value(user)
        String stringKey = "stringUser";
        User value = new User(2, "李四", new Date());
        //2.2使用fastJSON将value转化为JSON字符串
        String stringValue = JSON.toJSONString(value);
        //2.3存储到Redis中
        jedis.set(stringKey, stringValue);

        //3.释放资源
        jedis.close();
    }

    @Test
    public void getString(){
        //1.连接redis
        Jedis jedis = new Jedis("127.0.0.1", 6379);

        //2.1准备key
        String key = "stringUser";
        //2.2去Redis中查询value
        String value = jedis.get(key);
        //2.3将value反序列化为一个User对象
        User user = JSON.parseObject(value, User.class);
        //2.4输出
        System.out.println("user:"+user);

        //3.释放资源
        jedis.close();
    }
}

4.4 Jedis连接池

@Test
public void pool2(){
    //1.创建连接池的配置信息
    GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
    poolConfig.setMaxTotal(100); //最大连接数
    poolConfig.setMaxIdle(10); //最大空闲数
    poolConfig.setMinIdle(5); //最小空闲数
    poolConfig.setMaxWaitMillis(3000); //超时异常时间

    //2.获取Jedis
    JedisPool pool2 = new JedisPool(poolConfig, "127.0.0.1", 6379);
    //3.通过连接池获取Jedis对象
    Jedis jedis = pool2.getResource();
    //4.操作
    String value = jedis.get("stringUser");
    System.out.println("user:" + value);
    //5.释放资源
    jedis.close();
}

4.5 Redis管道操作

因为在操作Redis时，执行一个命令需要先发送一个命令道服务器，这个过程需要经过网络的延迟，Redis还需要给客户端一个响应

如果我需要一次性执行很多个命令，上述方式效率很低，可以通过Redis管道，先将命令防盗客户端的一个Pipeline中，之后一次性的将全部命令发送到Redis服务器，Redis服务一次性将全部的返回结果响应给客户端。

//Redsi管道操作
@Test
public void pipeline(){
    //1.创建连接池
    JedisPool pool = new JedisPool("127.0.0.1", 6379);
    long l = System.currentTimeMillis();

    /**
         //==============================================================================//
        //2.获取一个连接对象
        Jedis jedis = pool.getResource();
        //3.执行incr--100000次
        for (int i = 0; i < 100000; i++) {
            jedis.incr("pp");
        }
        //4.释放资源
        jedis.close();
        System.out.println(System.currentTimeMillis()-l); //计算笨方法运行时间(处理时间较长)
        //==============================================================================//
         */

    //2.获取连接对象
    Jedis jedis = pool.getResource();
    //3.创建管道
    Pipeline pipeline = jedis.pipelined();
    //4.执行incr---100000防盗管道中
    for (int i = 0; i < 100000; i++) {
        pipeline.incr("pp");
    }
    //5.执行命令
    pipeline.syncAndReturnAll();
    //6.释放资源
    jedis.close();
    System.out.println(System.currentTimeMillis()-l); //计算管道方法运行时间(处理较快)
}

五.Redis其他配置和集群

5.1 Redis的AUTH

# 设置密码(也可以在redis.conf中修改密码，此方法需要重启服务器)
config set requirepass 123456

# 查看密码
config get requirepass

# 输入密码
auth 123456

---

三种客户端连接方式

1. redis-cli：在输入正常命令前，先输入auth密码(即在cmd中连接redis后输入密码)

2. 图形化界面：在链接redis的信息中添加上连接的密码

3. Jedis客户端：

   第一种：jedis.auth(password)

   第二种：JedisPool pool = new JedisPool(poolConfig, “127.0.0.1”, 6379,3000,“123456”);

5.2 Redis的事务

Redis的事务：一次性操作，该成功成功，该失败失败

先开启事务，执行一系列的事务，但是命令不会立即执行，会被放在一个队列中，如果你执行事务，那么这个队列中的命令全部执行，如果取消事务则一个队列中的命令全部作废

1. 开启事务：multi
2. 输入需要执行的命令–>被放入队列中
3. 执行事务：exec
4. 取消事务：discard

Redis的事务想发挥功能，需要配合watch监听机制

在开启事务之前先通过watch命令去监听一个或多个key，在开启事务后，如果与其他客户端修改了我监听的key，事务会自动取消

如果执行了事务，或者取消了事务，watch监听自动消除，一般不需要手动执行unwatch取消监听

# 监听key
watch key [key...]

# 取消监听key
unwatch key [key...]

# 开启事务
multi

# 执行事务
exec

# 取消事务
discard

5.3 Redis持久化机制

RDB是Redis默认的持久化机制

1. RDB持久化文件，速度比较快，而且存储的是一个二进制文件，传输起来很方便

2. RDB持久化的时机（多少秒内，有多少个key改变了，就执行RDB持久化）

   save 900 1
   save 300 10
   save 60 10000

   rdbcompression yes

   dbfilename dump.rdb

3. RDB无法保证数据的绝对安全

---

AOF持久化机制默认是关闭的，Redis官方推荐同时开始RDB和AOF持久化，更安全，避免数据丢失。

1. AOF持久化速度，相对RDB较慢。存储的是一个文本文件，都来后期文件会比较大，传输困难。

2. AOF持久化时机

   appendfsync always：每执行一个写操作，立即持久化到AOF文件中，性能比较低。

   appendfsync everysec：每秒执行一次持久化

   appendfsync no：会根据你的操作系统不同，环境不同，在一定时间内执行一次持久化。

3. AOF相对RDB更安全，推荐同时开启

---

同时开启RDB和AOF的注意事项！

如果同时开启RDF和AOF持久化，那么Redis宕机重启之后，需要加载一个持久化文件，优先选择AOF文件。

如果先开启RDB，再次开启AOF，如果RDB执行了持久化，那么RDB文件的内容会被AOF覆盖掉

# Redis的AUTH密码
requirepass 123456

####################=====RDB=====############################
# RDB持久化机制的配置
# 代表RDB执行的时机
# 900秒内，有一个key改变了就执行RDB持久化
save 900 1
save 300 10
save 60 10000
# 开启RDB持久化的压缩
rdbcompression yes
# RDB持久化文件的名称
dir ./
dbfilename dump.rdb

####################=====AOF=====#############################
# AOF持久化策略
# 代表开启AOF持久化
appendonly yes
# AOF文件的名称
dir ./
appendfilename "redis.aof"
# AOF持久化执行的时机
# appendfsync always
appendfsync everysec
# appendfsync no

# 运行服务器时加载conf配置文件
redis-server.exe redis.windows.conf

5.4 Redis主从架构

单机版Redis存在瓶颈的问题

搭建主从架构

1. 创建三个配置文件命名为：redis-6379.conf，redis-6380.conf，redis-6381.conf
2. 在三个配置文件中编写以下内容

#redis-6379.conf
port 6379
daemonize no

#redis-6380.conf
port 6380
daemonize no
slaveof 127.0.0.1 6379

#redis-6381.conf
port 6381
daemonize no
slaveof 127.0.0.1 6379

3.分别启动主、从1、从2服务端

• redis-server reids-6379.conf
• redis-server reids-6380.conf
• redis-server reids-6381.conf

4.再启动相应的客户端

• redis-cli -p 6379
• redis-cli -p 6380
• redis-cli -p 6381

6.测试：在主(6379)中写入数据，再在其他两个从客户端中读取

7.查看主从状态：在主(6379)中输入命令— info replication

5.5 哨兵

哨兵可以帮助我们解决主从架构中的单点故障问题。

哨兵之间相互通信，当一个主服务器不能正常工作时，哨兵可以将一个从服务器升级为主服务器， 并对其他从服务器进行配置，让它们使用新的主服务器

哨兵配置

1.基于主从搭建上完成哨兵配置

2.创建三个文件分别为：sentinel1.conf，sentinel2.conf，sentinel3.conf

3.按创建的文件顺序以此添加以下配置

port 26379 #另外两个文件改端口：25380,26381(可以写其他端口)
sentinel monitor mymaster 127.0.0.1 6379 1
sentinel down-after-milliseconds mymaster 5000
sentinel config-epoch mymaster 12
sentinel leader-epoch mymaster 13

4.测试：打开相应的客户端并输入：info replication查看主从状态

5.再次测试：关闭6379服务端，在6380和6381客户端中输入：info replication查看主从状态

5.6 Redis的集群

Redis集群在保证主从加哨兵的基本功能之外，还能够提升Redis存储数据的能力

集群搭建

1.下载环境和应用包

# Ruby语言运行环境安装包（rubyinstaller-3.0.2-1-x64.exe）(先安装)
# msys2-x86_64-20190524 (后安装)
# redis集群安装脚本（redis-trib.rb）
# Redis的Ruby驱动（redis-3.2.2.gem）
链接：https://pan.baidu.com/s/1wm4TOjlEgI4TFyVH8o3ARg?pwd=1234 
提取码：1234 

2.将redis集群安装脚本（redis-trib.rb）和Redis的Ruby驱动（redis-3.2.2.gem）复制到Redis目录下

3.安装–Ruby语言运行环境安装包（rubyinstaller-3.0.2-1-x64.exe）

4.安装–msys2-x86_64-20190524

5.在Redis目录下创建logs文件夹

6.创建配置文件：redis.6379.conf~redis.6383.conf

#redis.6379.conf#####################################################################################
port 6379       
loglevel notice    
logfile "D:/DevelopmentEnvironment/Redis/logs/redis_6379_log.txt"         
appendonly yes
appendfilename "appendonly.6379.aof"    
cluster-enabled yes                                    
cluster-config-file nodes.6379.conf
cluster-node-timeout 15000
cluster-slave-validity-factor 10
cluster-migration-barrier 1
cluster-require-full-coverage yes

#redis.6380.conf#####################################################################################
port 6380       
loglevel notice    
logfile "D:/DevelopmentEnvironment/Redis/logs/redis_6380_log.txt"         
appendonly yes
appendfilename "appendonly.6380.aof"    
cluster-enabled yes                                    
cluster-config-file nodes.6380.conf
cluster-node-timeout 15000
cluster-slave-validity-factor 10
cluster-migration-barrier 1
cluster-require-full-coverage yes

#redis.6381.conf#####################################################################################
port 6381       
loglevel notice    
logfile "D:/DevelopmentEnvironment/Redis/logs/redis_6381_log.txt"         
appendonly yes
appendfilename "appendonly.6381.aof"    
cluster-enabled yes                                    
cluster-config-file nodes.6381.conf
cluster-node-timeout 15000
cluster-slave-validity-factor 10
cluster-migration-barrier 1
cluster-require-full-coverage yes

#redis.6382.conf#####################################################################################
port 6382       
loglevel notice    
logfile "D:/DevelopmentEnvironment/Redis/logs/redis_6382_log.txt"         
appendonly yes
appendfilename "appendonly.6382.aof"    
cluster-enabled yes                                    
cluster-config-file nodes.6382.conf
cluster-node-timeout 15000
cluster-slave-validity-factor 10
cluster-migration-barrier 1
cluster-require-full-coverage yes

#redis.6383.conf#####################################################################################
port 6383       
loglevel notice    
logfile "D:/DevelopmentEnvironment/Redis/logs/redis_6383_log.txt"         
appendonly yes
appendfilename "appendonly.6383.aof"    
cluster-enabled yes                                    
cluster-config-file nodes.6383.conf
cluster-node-timeout 15000
cluster-slave-validity-factor 10
cluster-migration-barrier 1
cluster-require-full-coverage yes

7.打开cmd命令窗口，进入Redis目录，依次执行下列10条命令

redis-server.exe --service-install redis.6379.conf --service-name RedisServer6379
redis-server.exe --service-install redis.6380.conf --service-name RedisServer6380
redis-server.exe --service-install redis.6381.conf --service-name RedisServer6381
redis-server.exe --service-install redis.6382.conf --service-name RedisServer6382
redis-server.exe --service-install redis.6383.conf --service-name RedisServer6383

redis-server.exe --service-start --service-name RedisServer6379
redis-server.exe --service-start --service-name RedisServer6380
redis-server.exe --service-start --service-name RedisServer6381
redis-server.exe --service-start --service-name RedisServer6382
redis-server.exe --service-start --service-name RedisServer6383

8.打开cmd窗口进入，进入Ruby30-x64\bin目录，执行以下命令

gem install --local D:\DevelopmentEnvironment\Redis\redis-3.2.2.gem

10.打开cmd窗口，进入Redis目录，创建Redis集群（之后输入yes）

redis-trib.rb create --replicas 0 127.0.0.1:6379 127.0.0.1:6380 127.0.0.1:6381 127.0.0.1:6382 127.0.0.1:6383

11.cmd窗口Redis目录中输入下列命令，验证是否存在服务器

redis-trib.rb check 127.0.0.1:6379

12.cmd窗口Redis目录中输入下列命令，验证集群是否有用

redis-cli.exe -h 127.0.0.1 -p 6379 -c
set t6379 6379
exit

redis-cli.exe -h 127.0.0.1 -p 6380 -c
set t6380 6380
exit

redis-cli.exe -h 127.0.0.1 -p 6381 -c
set t6381 6381
exit

redis-cli.exe -h 127.0.0.1 -p 6382 -c
set t6382 6382
exit

redis-cli.exe -h 127.0.0.1 -p 6383 -c
set t6383 6383
exit

# 随便选一个节点，查看是否能够获取到其他节点输入的内容
redis-cli.exe -h 127.0.0.1 -p 6381 -c
get t6383

5.7 Jedis连接到集群

public class Demo5 {
    @Test
    public void test(){
        //创建Set<HostAndPort> nodes
        Set<HostAndPort> nodes = new HashSet<HostAndPort>();
        nodes.add(new HostAndPort("127.0.0.1",6379));
        nodes.add(new HostAndPort("127.0.0.1",6380));
        nodes.add(new HostAndPort("127.0.0.1",6381));
        nodes.add(new HostAndPort("127.0.0.1",6382));
        nodes.add(new HostAndPort("127.0.0.1",6383));

        //创建JedisCluster对象
        JedisCluster jedisCluster = new JedisCluster(nodes);

        //操作
        String value = jedisCluster.get("t6379");
        System.out.println(value);
    }
}

六.Redis常见问题

6.1 Key的生存时间到了，Redis会立即删除吗？

不会立即删除

1. 定期删除

   Redis每个一段时间就会去查看Redis设置了过期时间的key，会在100ms的间隔中默认查看3个key。

2. 惰性删除

   如果当你去查询一个已经过了生存时间的key时，Redis会先查看当前key的生存时间，是否已经到了，过了则直接删除当前key，并且给用户返回一个空值

6.2 Redis的淘汰机制

在Redis内存已经满的时候，添加一个新数据，执行淘汰机制

1. volatile-lru：

   在内存不足时，Redis会在设置过了生存时间的key中，干掉一个最近最少使用的key

2. allkeys-lru：

   在内存不足时，在全部的key中，干掉一个最近最少使用的key

3. volatile-lfu：

   在内存不足时，Redis会在设置过了生存时间的key中，干掉一个最近最少频次使用的key

4. allkeys-lfu：

   在内存不足时，Redis会在全部的key中，干掉一个最近最少频次使用的key

5. volatile-random：

   在内存不足时，Redis会在设置过了生存时间的key中，随机干掉一个key

6. allkeys-random：

   在内存不足时，在全部的key中，随机干掉一个key

7. volatile-ttl：

   在内存不足时，Redis会在设置过了生存时间的key中，干掉一个剩余生存时间最少的key

8. noeviction：(默认)

   在内存不足时，直接报错

指定淘汰机制的策略：maxmemory-policy 具体策略

设置Redis的最大内存数：maxmemory

6.3 缓存的常见问题

缓存穿透

缓存击穿

缓存雪崩

缓存倾斜