Redis面试整理

Parzivval

已于 2023-04-12 21:35:28 修改

阅读量588

点赞数

分类专栏： Java面试文章标签： redis 面试缓存

于 2023-04-12 21:32:17 首次发布

本文链接：https://blog.csdn.net/lannister_awalys_pay/article/details/130117319

版权

Java面试专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Redis面试整理（持续更新）

redis为什么比mysql快？

完全基于内存，数据操作都是对内存进行操作，避免了磁盘IO读取到内存这部分开销
数据结构简单，数据操作也简单。Redis中的数据结构是专门进行设计的，每种数据结构都有一种或多种数据结构来支持。Redis正是依赖这些灵活的数据结构，来提升读取和写入的性能。
采用单线程，省去了很多上下文切换的时间以及CPU消耗，不存在竞争条件，不用去考虑各种锁的问题，不存在加锁释放锁操作，也不会出现死锁而导致的性能消耗。
使用基于IO多路复用机制的线程模型，可以处理并发的链接。

Redis 线程模型

Redis 单线程模型了解

SpringBoot如何整合Redis？

添加相关依赖
创建配置类
配置application.yml

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

import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@Configuration
@EnableCaching
public class RedisConfig {

    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory);

        // 设置 key 和 value 的序列化方式
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(jackson2JsonRedisSerializer());

        // 设置 hashKey 和 hashValue 的序列化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jackson2JsonRedisSerializer());

        template.afterPropertiesSet();
        return template;
    }

    @Bean
    public CacheManager cacheManager() {
        RedisCacheConfiguration cacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofSeconds(600))
                .disableCachingNullValues()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer()));

        return RedisCacheManager.builder(redisConnectionFactory)
                .cacheDefaults(cacheConfiguration)
                .build();
    }

    private Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer() {
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.activateDefaultTyping(
                objectMapper.getPolymorphicTypeValidator(),
                ObjectMapper.DefaultTyping.NON_FINAL,
                JsonTypeInfo.As.WRAPPER_ARRAY
        );
        serializer.setObjectMapper(objectMapper);
        return serializer;
    }
}

spring:
  redis:
    host: localhost
    port: 6379

Redis事务三大特性（与MySQL有哪些不同）

单独的隔离操作
- 事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断。
没有隔离级别的概念
- 队列中的命令没有提交之前都不会实际被执行，因为事务提交前任何指令都不会被实际执行
不保证原子性
- 事务中如果有一条命令执行失败，其后的命令仍然会被执行，没有回滚

乐观锁与悲观锁

悲观锁：就是操作之前先上锁，修改之后解锁。基本就串行化了，效率很低，读写不兼容
乐观锁：修改数据同时也修改版本，想修改数据之前先比较和自己读的版本是否一致，不一致也不能修改，读写兼容，多读场景吞吐量大增

Redis持久化方法

RDB持久化流程
AOF持久化流程

RDB持久化更新机制

AOF同步频率设置

AOF的重写压缩机制

对比RDB和AOF

Redis主从复制

哨兵机制Sentinel

Redis应用问题解决

缓存穿透

现象：
1. 应用服务器压力突然变大，大量请求达到
2. redis命中率降低
3. 一直查询数据库，数据库一直承受访问压力，导致崩溃
原因现象：
1. redis查询不到数据
2. 出现很多非正常url访问（一般因为遭受到恶意攻击）
解决方案：
1. 对空值缓存：如果一个查询返回的数据为空（不管是数据是否不存在），我们仍然把这个空结果（null）进行缓存，设置空结果的过期时间会很短，最长不超过五分钟
2. 设置可访问的名单（白名单）：使用bitmaps类型定义一个可以访问的名单，名单id作为bitmaps的偏移量，每次访问和bitmap里面的id进行比较，如果访问id不在bitmaps里面，进行拦截，不允许访问。
3. 采用布隆过滤器：(布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量(位图)和一系列随机映射函数（哈希函数）。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远远超过一般的算法，缺点是有一定的误识别率和删除困难。)将所有可能存在的数据哈希到一个足够大的bitmaps中，一个一定不存在的数据会被这个bitmaps拦截掉，从而避免了对底层存储系统的查询压力。
4. 进行实时监控：当发现Redis的命中率开始急速降低，需要排查访问对象和访问的数据，和运维人员配合，可以设置黑名单限制服务

缓存击穿

解释：key对应的数据存在，但在redis中过期，此时若有大量并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。
现象：
1. 数据库访问压力瞬间增大，导致崩溃
2. redis里并没有出现大量key过期
3. redis正常运行
原因现象：
1. redis某个热门搜索key过期，大量访问中都使用这个key
解决方案：
1. key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题：缓存被“击穿”的问题。
2. 预先设置热门数据：在redis高峰访问之前，把一些热门数据提前存入到redis里面，加大这些热门数据key的时长
3. 实时调整：现场监控哪些数据热门，实时调整key的过期时长
4. 使用锁：
  1. 就是在缓存失效的时候（判断拿出来的值为空），不是立即去load db。
  2. 先使用缓存工具的某些带成功操作返回值的操作（比如Redis的SETNX）去set一个mutex key
  3. 当操作返回成功时，再进行load db的操作，并回设缓存,最后删除mutex key；
  4. 当操作返回失败，证明有线程在load db，当前线程睡眠一段时间再重试整个get缓存的方法。

缓存雪崩

描述：
- key对应的数据存在，但在redis中过期，此时若有大量并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大量并发的请求可能会瞬间把后端DB压垮。
- 缓存雪崩与缓存击穿的区别在于这里针对很多key缓存，前者则是某一个key正常访问
现象：
1. 数据库压力变大，导致服务器、应用、redis全部崩溃
原因：
1. 在极少的时间段内，查询大量key的集中过期情况
解决方案：
1. 构建多级缓存架构：nginx缓存 + redis缓存 +其他缓存（ehcache等）
2. 使用锁或队列：用加锁或者队列的方式保证来保证不会有大量的线程对数据库一次性进行读写，从而避免失效时大量的并发请求落到底层存储系统上。不适用高并发情况
3. 设置过期标志更新缓存：记录缓存数据是否过期（设置提前量），如果过期会触发通知另外的线程在后台去更新实际key的缓存。
4. 将缓存失效时间分散开：比如我们可以在原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。

分布式锁

描述：
- 随着业务发展的需要，原单体单机部署的系统被演化成分布式集群系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，单纯的Java API并不能提供分布式锁的能力。为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题！
主流解决方案：
1. 基于数据库实现分布式锁
2. 基于缓存（Redis等）
3. 基于Zookeeper
对比各自优缺点：
1. 性能：redis最高
2. 可靠性：zookeeper最高
基于redis实现分布式锁
1. 上锁：setnx key value 只有在key为空时才可以赋值，所以设置值的同时上了锁
2. 解锁：del key
3. 超时机制：set key value nx ex time 设置值的同时设置了超时时间，ex后面的值就是超时时间

Java代码：

@GetMapping("testLock")
    public void testLock() {
        //1获取锁，setne ， 同时设置3秒过期，以避免中间出现异常，导致锁一直无法释放
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "111",3, TimeUnit.SECONDS);
        //2获取锁成功、查询num的值
        if (lock) {
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断num为空return
            if (StringUtils.isEmpty(value)) {
                return;
            }
            //2.2有值就转成成int
            int num = Integer.parseInt(value + "");
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num", ++num);
            //2.4释放锁，del
            redisTemplate.delete("lock");

        } else {
            //3获取锁失败、每隔0.1秒再获取
            try {
                Thread.sleep(100);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

对于if段执行如果出现异常导致锁没有被释放的问题：设置超时自动释放

对于释放错锁，和释放别人锁的问题：

描述：a上锁之后遇到卡顿，导致锁超时自动释放；之后b抢到锁进行操作；再之后a的服务器恢复，a操作完成之后释放了b的锁，导致接下来全部错位释放锁。c会抢到b的锁。

解决：

UUID防止误删除：可以防止误删除链，但是依然存在超时误删的问题

第一步：set lock uuid nx ex 10,然后用uuid进行判断。
第二步：释放锁时候，判断当前uuid和锁里面uuid是否一致，一致则释放，不一致则不管

代码改造：

String uuid = UUID.randomUUID().toString();

//1获取锁，setne  ,同时设置3秒过期，以避免中间出现异常，导致锁一直无法释放
Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", uuid,3, TimeUnit.SECONDS);

...
  
//2.4释放锁，del
String lockUuid = (String)redisTemplate.opsForValue().get("lock");
if(uuid.equals(lockUuid)){
   redisTemplate.delete("lock");
 }

遗留问题：当比较uuid结果相等的时候，锁过期了，又会导致误删锁

LUA保证删除原子性操作：

@GetMapping("testLockLua")
    public void testLockLua() {
        //1 声明一个uuid ,将做为一个value 放入我们的key所对应的值中
        String uuid = UUID.randomUUID().toString();
        //2 定义一个锁：lua 脚本可以使用同一把锁，来实现删除！
        String skuId = "25"; // 访问skuId 为25号的商品 100008348542
        String locKey = "lock:" + skuId; // 锁住的是每个商品的数据

        // 3 获取锁
        Boolean lock = redisTemplate.opsForValue().setIfAbsent(locKey, uuid, 3, TimeUnit.SECONDS);

        // 第一种： lock 与过期时间中间不写任何的代码。
        // redisTemplate.expire("lock",10, TimeUnit.SECONDS);//设置过期时间
        // 如果true
        if (lock) {
            // 执行的业务逻辑开始
            // 获取缓存中的num 数据
            Object value = redisTemplate.opsForValue().get("num");
            // 如果是空直接返回
            if (StringUtils.isEmpty(value)) {
                return;
            }
            // 不是空 如果说在这出现了异常！ 那么delete 就删除失败！ 也就是说锁永远存在！
            int num = Integer.parseInt(value + "");
            // 使num 每次+1 放入缓存
            redisTemplate.opsForValue().set("num", String.valueOf(++num));
            /*使用lua脚本来锁*/
            // 定义lua 脚本
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            // 使用redis执行lua执行
            DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
            redisScript.setScriptText(script);
            // 设置一下返回值类型 为Long
            // 因为删除判断的时候，返回的0,给其封装为数据类型。如果不封装那么默认返回String 类型，
            // 那么返回字符串与0 会有发生错误。
            redisScript.setResultType(Long.class);
            // 第一个要是script 脚本 ，第二个需要判断的key，第三个就是key所对应的值。
            redisTemplate.execute(redisScript, Arrays.asList(locKey), uuid);
        } else {
            // 其他线程等待
            try {
                // 睡眠
                Thread.sleep(1000);
                // 睡醒了之后，调用方法。
                testLockLua();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }