Redis实战原理解析

最新推荐文章于 2025-04-01 09:47:31 发布

joybinny

最新推荐文章于 2025-04-01 09:47:31 发布

阅读量9.5k

点赞数

文章标签： Redis io多路复用内存淘汰策略自动过期机制缓存雪崩

本文链接：https://blog.youkuaiyun.com/AkiraNicky/article/details/103301777

版权

Redis简介：Redis 是完全开源免费的，是一个高性能的key-value数据库，目前市面上主流的no-sql数据库有Redis、Memcache、Tair(淘宝自研发)，Redis的官网：https://redis.io/

之前的博客已经写过redis的搭建，主从复制以及哨兵机制，本篇博客侧重于讲解底层原理，实战等...开始吧那就

1. Redis应用场景

相信我们程序员都用过或者听过Redis，那么我们首先谈下它有哪些应用场景，博主总结了以下几点：

① Token令牌的生成
② 短信验证码的code
③ 可以实现缓存查询数据，减轻我们的数据库的访问压力 Redis与mysql数据库不同步的问题
④ 分布式锁
⑤ 延迟操作（案例：订单超时未支付，也可以用RabbitMQ解决）
⑥ 分布式消息中间件（发布订阅，一般用的很少）

2. Redis线程模型

首先Redis官方是没有windows版本的，只有Linux版本，那么问题来了，为什么我们Windows本地可以安装？答案：一些大牛把Linux版的epoll机制改成Select轮训，从而发布到github供我们下载，所以我们Windows上的Redis并不是官方的。

Redis的底层采用NIO中的多路IO复用的机制，能够非常好的支持这样的并发，从而保证线程安全问题；Redis单线程，也就是底层采用一个线程维护多个不同的客户端IO操作。但是Nio在不同的操作系统上实现的方式有所不同，在我们Windows操作系统使用Selector实现轮训时间复杂度是为O(N),而且还存在空轮训的情况，效率非常低，其次是默认对我们轮训的数据有一定限制，所以支持上万的TCP连接是非常难。所以在Linux操作系统采用epoll实现事件驱动回调，不会存在空轮训的情况，只对活跃的 Socket连接实现主动回调这样在性能上有大大的提升，所以时间复杂度是为O(1)。

所以为什么单线程的Nginx、Redis都能够非常高支持高并发，最终都是Linux中的IO多路复用机制epoll。

Windows - 空轮训，相当于在Selector写了个for循环，一直在轮训，万一别人不给我发数据也去轮训一下，效率非常低；

Linux - epoll，给每一个TCP连接注册一个事件回调，一旦有人给我发数据，我就走我的事件回调，没给我发数据，我就不用去轮训，不会存在空轮训的情况，只对活跃的 Socket连接实现主动回调这样在性能上有大大的提升。

3. Redis - Value的五种数据类型

① String类型 - <key，value> 【用的最多】

String是Redis最基本的类型，一个key对应一个value，String类型是二进制安全的。意思是Redis的String可以包含任何数据。比如Jpg图片或者序列化的对象, String类型是Redis最基本的数据类型，一个键最大能存储512MB。

命令：set name zhangsan，get name

② hash类型 - <key，<key1，value>> 案例：购物车

我们可以将Redis中的Hash类型看成具有<key,<key1,value>>,其中同一个key可以有多个不同key值的<key1,value>，所以该类型非常适合于存储值对象的信息。如Username、Password和Age等。如果Hash中包含很少的字段，那么该类型的数据也将仅占用很少的磁盘空间。

命令：hmset user name zhangsan 【解读：key为user，value为hashmap<name,zhangsan>】，hgetall user
可以支持多个key-hmset user name zhangsan age 22

③ list类型 - 案例：秒杀时一个库存对应多个令牌桶token

Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）

命令：lpush userlist zhangsan lisi wangwu

④ set - 特点：value不允许重复，如果重复则覆盖【基本不用】

Redis 的 Set 是 String 类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据。

⑤ zset - 【基本不用】

Redis 有序集合和集合一样也是string类型元素的集合,且不允许重复的成员。不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。

拓展：Redis如何存放一个java对象？

答案： ① json（即String类型），② 二进制

方式①实现：Redis Desktop Manager工具不会乱码

@Component
public class RedisUtils {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public void setString(String key, String value) {
        setString(key, value, null);
    }
    public void setString(String key, String value, Long timeOut) {
        stringRedisTemplate.opsForValue().set(key, value);
        if (timeOut != null) {
            stringRedisTemplate.expire(key, timeOut, TimeUnit.SECONDS);
        }
    }
    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
}

@RestController
public class RedisController {
    @Autowired
    private RedisUtils redisUtils;

    @GetMapping("/addUser")
    public String addUser(UserEntity userEntity) {
        String json = JSONObject.toJSONString(userEntity);
        redisUtils.setString("userEntity", json);
        return "success";
    }
    @RequestMapping("/getUser")
    public UserEntity getUser(String key) {
        String json = redisUtils.getString(key);
        UserEntity userEntity = JSONObject.parseObject(json, UserEntity.class);
        return userEntity;
    }
}

方式②实现：（注意：需要序列化的对象(如UserEntity)一定要实现Serializable接口） Redis Desktop Manager会乱码

@Component
public class RedisTemplateUtils {
    @Resource //@Resource通过名称注入，注意这里不能用@Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void setObject(String key, Object value) {
        setObject(key, value, null);
    }
    public void setObject(String key, Object value, Long timeOut) {
        redisTemplate.opsForValue().set(key, value);
        if (timeOut != null) {
            redisTemplate.expire(key, timeOut, TimeUnit.SECONDS);
        }
    }
    public Object getObject(String key) {
        return redisTemplate.opsForValue().get(key);
    }
}

@RestController
public class RedisController {
    @Autowired
    private RedisTemplateUtils redisTemplateUtils;

    @GetMapping("/addUser")
    public String addUser(UserEntity userEntity) {
        redisTemplateUtils.setObject("userEntity", userEntity);
        return "success";
    }
    @RequestMapping("/getUser")
    public UserEntity getUser(String key) {
        return (UserEntity) redisTemplateUtils.getObject(key);
    }
}

两种方式区别：二进制只适合于Java对象，json是通用的。

4. Mysql与Redis数据同步解决方案

方式①：当数据库有数据变动时，直接清空Redis对应的该数据，此次或下次再同步到Redis
方式②：直接采用MQ订阅MySQL binlog日志文件增量同步到Redis中，整个过程采用最终一致性方案。类似于之前博客的主从复制
方式③：使用阿里巴巴的开源框架Canal（后期单独拿一篇博客讲述）

5. Redis的持久化机制

Redis因为某种原因的情况下宕机之后，数据是不会丢失的，原理就是持久化机制 ~

同理，我们用的ehcache也有持久化机制，大部分的缓存框架都会有基本功能：淘汰策略、持久机制。

Redis的持久化的机制有两种：aof、rdb（默认），下面分别讲解：

Redis提供了两种持久化的机制，分别为RDB、AOF实现，RDB采用定时（全量）持久化机制，但是服务器因为某种原因宕机后可能数据会丢失，AOF是基于数据日志操作实现的持久化（增量）。

RDB：（全量同步）

Redis已经帮助我默认开启了rdb存储，以快照的形式将数据持久化到磁盘的是一个二进制的文件dump.rdb，可以在redis.conf中搜索到，生成的rdb文件为，存放的目录为

Redis会将数据集的快照dump到dump.rdb文件中。此外，我们也可以通过配置文件来修改Redis服务器dump快照的频率，在打开6379.conf文件之后，我们搜索save，可以看到下面的配置信息：

save 900 1 # 在900秒(15分钟)之后，如果至少有1个key发生变化，则dump内存快照。
save 300 10 # 在300秒(5分钟)之后，如果至少有10个key发生变化，则dump内存快照。
save 60 10000 # 在60秒(1分钟)之后，如果至少有10000个key发生变化，则dump内存快照。

AOF：（增量同步）

AOF在Redis的配置文件中存在三种同步策略，它们分别是：

appendfsync always #每次有数据修改发生时都会写入AOF文件，能够保证数据不丢失，但是效率非常低。

appendfsync everysec #每秒钟同步一次，可能会丢失1s内的数据，但是效率非常高。【默认 - 建议使用】

appendfsync no #从不同步。高效但是数据不会被持久化。

Redis默认没有开启aof存储，那么如何开启aof？非常简单，只需要在redis.conf中把默认的配置改为yes即可，aof同步的文件为

原理：aof是以执行命令的形式实现同步。每次执行都会记录写的操作，如set name zhangsan等都会被记录下来，appendfsync everysec一秒后从缓冲区同步到aof文件中去。

拓展：全量同步（rdb）与增量同步（aof）区别：

① 就是每天定时(避开高峰期)或者是采用一种周期的实现将数据拷贝另外一个地方。频率不是很大，但是可能会造成数据的丢失。
② 增量同步采用行为操作对数据实现同步，频率非常高、对服务器同步的压力也是非常大的、保证数据不丢失。

6. Redis内存淘汰策略

概念：将Redis用作缓存时，如果内存空间用满，就会自动驱逐老的数据，防止内存撑爆。

Redis默认有六种淘汰策略：

noeviction：当内存使用达到阈值的时候，执行命令直接报错

allkeys-lru：在所有的key中，优先移除最近未使用的key。(推荐)

volatile-lru：在设置了过期时间的键空间中，优先移除最近未使用的key。

allkeys-random：在所有的key中，随机移除某个key。

volatile-random：在设置了过期时间的键空间中，随机移除某个key。

volatile-ttl：在设置了过期时间的键空间中，具有更早过期时间的key优先移除。

在redis.conf文件中，设置Redis 内存大小的限制，比如：

当数据达到限定大小后，会选择配置的策略淘汰数据，通过配置maxmemory-policy置Redis的淘汰策略，默认也是注掉的，如果自定义内存大小的话，建议使用allkeys-lru，即。
【关于maxmemory的设置，如果redis的应用场景是作为db使用，那不要设置这个选项，因为db是不能容忍丢失数据的。

如果作为cache使用，则可以启用这个选项（其实既然有淘汰策略，那就是cache了。。。），默认官方没有对maxmemory做限制，理论上默认最大内存限制为当前机器可用内存】

7. Redis自动过期机制

在实际开发过程中经常会遇到一些有时效性数据，比如订单超时功能，30分钟未支付应该将订单改为已失效状态。在关系型数据库中一般都要增加一个字段记录数据的到期时间，然后通过定时任务周期性的进行检查，这种方式性能太差了。Redis本身就对键过期提供了很好的支持。

实现需求：处理订单过期自动取消，比如下单30分钟未支付自动更改订单状态为已失效（超时）

解决方案：① 定时器 ② RabbitMQ的死信/延时队列 ③ 利用Redis的过期机制

Redis过期机制：在Redis中可以使用expire命令设置一个键的存活时间(ttl: time to live)，过了这段时间，该键就会自动被删除，EXPIRE命令的使用方法如下：
expire key ttl(单位秒) 【命令返回1表示设置ttl成功，返回0表示键不存在或者设置失败。】

key失效监听实战：

把RedisMessageListenerContainer注入到Spring容器

@Configuration
public class RedisListenerConfig {
    @Bean
    RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        return container;
    }
}

编写Redis监听器

@Component
public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {

    public RedisKeyExpirationListener(RedisMessageListenerContainer listenerContainer) {
        super(listenerContainer);
    }
    @Autowired
    private OrderMapper orderMapper;
    /**
     * 【监听】 - 当我们key失效的时候执行该方法
     */
    @Override
    public void onMessage(Message message, byte[] pattern) {
        String expireKey = message.toString();
        System.out.println(expireKey + "失效啦~");
        // 前缀判断 - 每个服务，前缀事先商量好，防止冲突 eg:orderToken_XXXXXXX  // 或者是根据库区分
        OrderEntity orderEntity = orderMapper.getOrderNumber(expireKey);
        if (orderEntity == null) {
            return;
        }
        // 获取订单状态
        Integer orderStatus = orderEntity.getOrderStatus();
        // 如果该订单状态为待支付的情况下，直接将该订单修改为已经超时 （0待支付 1已支付 2已失效）
        if (orderStatus == 0) {
            orderMapper.updateOrderStatus(expireKey, 2);
            // 库存在加上1...此处省略，自行实现
        }
        // 不设置超时时间，但是可能被淘汰回收策略回收掉，也会走回调方法
    }
}

@Data
public class OrderEntity {
    private Long id;
    private String orderName;
    private Integer orderStatus;
    private String orderToken;
    private String orderNumber;
    public OrderEntity(Long id, String orderName, String orderNumber, String orderToken) {
        this.id = id;
        this.orderName = orderName;
        this.orderNumber = orderNumber;
        this.orderToken = orderToken;
    }
}

@Mapper
public interface OrderMapper {
    @Insert("insert into order_table values (null,#{orderName},0,#{orderToken},#{orderNumber})")
    int insertOrder(OrderEntity OrderEntity);

    @Select("SELECT id,order_name,order_status,order_token,order_number  FROM order_table " +
            "where order_token=#{orderToken};")
    OrderEntity getOrderNumber(String orderToken);

    @Update("update order_table set order_status=#{orderStatus} where order_token=#{orderToken}")
    int updateOrderStatus(String orderToken, Integer orderStatus);
}

@Component
public class RedisUtils {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public void setString(String key, String value) {
        setString(key, value, null);
    }
    public void setString(String key, String value, Long timeOut) {
        stringRedisTemplate.opsForValue().set(key, value);
        if (timeOut != null) {
            stringRedisTemplate.expire(key, timeOut, TimeUnit.SECONDS);
        }
    }
    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }
}

@RestController
public class OrderController {
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RedisUtils redisUtils;

    @RequestMapping("/addOrder")
    public String addOrder() {
        // 1.提前生成订单token 临时且唯一
        String orderToken = UUID.randomUUID().toString();
        Long orderNumber = System.currentTimeMillis();
        // 2.将我们的token存放到redis中
        redisUtils.setString(orderToken, orderNumber + "", 60L); // 60秒
        OrderEntity orderEntity = new OrderEntity(null, "腾讯视频年度vip", orderNumber + "", orderToken);
        return orderMapper.insertOrder(orderEntity) > 0 ? "success" : "fail";
    }
}

启动项目，调用addOrder接口，会看到数据库新增一条数据：

60秒后，redis中的该key删除，进入监听器，并根据该key判断订单状态，如果为1，则不操作，如果依旧为0，则改为2：

【原理】：

① 创建订单的时候绑定一个订单token 存放在redis中(有效期只有30分钟) key为token，value为订单编号。

② 对该key绑定过期事件回调，判断状态从而修改订单状态。

8. Redis缓存雪崩&缓存击穿&缓存穿透

【缓存穿透】

缓存穿透是指定key不存在的key，频繁的高并发查询，导致缓存是无法命中，如上图所示，当黑客利用for循环，随机生成orderNumber去访问getOrder接口，则每次大概率会穿透Redis进入MySQL数据库，导致大量IO操作，从而会导致数据库的压力非常大。

解决方案：

① 接口实现api的限流、防御ddos（模拟请求）、接口频率限制、网关实现黑名单（核心）
② 从数据库和Redis如果都查询不到数据的情况下，将数据库的空值写入到缓存中，加上短时间的有效期【针对于黑客使用相同的key进行攻击，一定程度上可以减轻频繁数据库IO操作】
③ 布隆过滤器

默认情况下，数组值为0，数组取值（0或1）
为什么要有三个hash函数计算出3个hash值？防止冲突，减少重叠的概率

布隆过滤器：布隆过滤器适用于判断一个元素在集合中是否存在，但是可能会存在误判的问题。

Bloom Filter基本实现原理采用位数组与联合函数一起实现，实现的原理采用二进制向量数组和随机映射hash函数。

为什么存在误判问题?

因为有可能在查询的时候，会根据key计算hash值，该值可能与布隆过滤器存放的其它元素的hash值产生重叠，即上图中的sex，hash值数组对应的下标都为1，即代表布隆过滤器中存在该key，而实际上该key是不存在的。

如何减少冲突（误判）概率？

二进制数组长度设置大一点，代码直接把fpp调低一点即可：

BloomFilter<Integer> integerBloomFilter = BloomFilter.create(Funnels.integerFunnel(), size, 0.001);

代码实现&应用场景：

在上图代码中我们可以用redis很好的降低数据库访问压力，那么用户频繁访问redis，也会对redis造成很大压力，这时候我们就引入布隆过滤器，如果不存在直接不走redis，直接返回null给客户端即可：

<!--引入布隆过滤器 -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>22.0</version>
</dependency>

@Mapper
public interface OrderMapper {

    @Insert("insert into order_table values (null,#{orderName},0,#{orderToken},#{orderNumber})")
    int insertOrder(OrderEntity OrderEntity);

    @Select("select * from order_table where id=#{id}")
    OrderEntity getById(Integer orderId);

    @Select("select id from order_table")
    List<Integer> getOrderIds();
}

@RestController
public class OrderController {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RedisUtils redisUtils;
    @Autowired
    private RedisTemplateUtils redisTemplateUtils;

    BloomFilter<Integer> integerBloomFilter;

    @RequestMapping("/addOrder")
    public String addOrder() {
        // 1.提前生成订单token 临时且唯一
        String orderToken = UUID.randomUUID().toString();
        Long orderNumber = System.currentTimeMillis();
        // 2.将我们的token存放到rdis中
        redisUtils.setString(orderToken, orderId + "", 10L);
        OrderEntity orderEntity = new OrderEntity(null, "QQ黄钻", orderNumber + "", orderToken);
        return orderMapper.insertOrder(orderEntity) > 0 ? "success" : "fail";
    }

    @RequestMapping("/getOrder")
    public OrderEntity getOrder(Integer orderId) {
        // 0.判断我们的布隆过滤器
        if (!integerBloomFilter.mightContain(orderId)) {
            System.out.println("从布隆过滤器中查询不存在");
            return null;
        }
        // 如果正好碰巧，orderId在redis和mysql都没有，也没关系，
        // 就算布隆过滤器产生了误判的情况，也不会影响整个业务，顶多穿透了布隆而已

        // 1.先查询Redis中数据是否存在
        OrderEntity orderRedisEntity = (OrderEntity) redisTemplateUtils.getObject(orderId + "");
        if (orderRedisEntity != null) {
            System.out.println("直接从Redis中返回数据");
            return orderRedisEntity;
        }
        // 2. 查询数据库的内容
        System.out.println("从DB查询数据");
        OrderEntity orderDBEntity = orderMapper.getOrderById(orderId);
        if (orderDBEntity != null) {
            System.out.println("将Db数据放入到Redis中");
            redisTemplateUtils.setObject(orderId + "", orderDBEntity);
        }
        return orderDBEntity;
    }

    /**
     * 从数据库预热id到布隆过滤器中（预热机制）
     * @return
     */
    @RequestMapping("/dbToBulong")
    public String dbToBulong() {
        List<Integer> orderIds = orderMapper.getOrderIds();
        integerBloomFilter = BloomFilter.create(Funnels.integerFunnel(), orderIds.size(), 0.01);
        for (int i = 0; i < orderIds.size(); i++) {
            // 添加到我们的布隆过滤器中
            integerBloomFilter.put(orderIds.get(i));
        }
        return "success";
    }
}

首先用预热机制，把所有订单id存到布隆过滤器