大厂面试！我和面试官之间关于Redis的一场对弈！

  •  Redis是什么
  •  五种数据类型
  •  Redis缓存
  •  缓存问题
  •  Redis为何这么快
  •  Redis和Memcached的区别
  •  淘汰策略
  •  持久化
  •  主从复制
  •  哨兵
  •  总结

今天，我不自量力的面试了某大厂的java开发岗位，迎面走来一位风尘仆仆的中年男子，手里拿着屏幕还亮着的mac，他冲着我礼貌的笑了笑，然后说了句“不好意思，让你久等了”，然后示意我坐下，说：“我们开始吧。看了你的简历，觉得你对redis应该掌握的不错，我们今天就来讨论下redis......”。我想：“来就来，兵来将挡水来土掩”。

10年积累的网站设计、成都网站设计经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站制作后付款的网站建设流程，更有平桥免费网站建设让你可以放心的选择与我们合作。

Redis是什么

  •  面试官：你先来说下redis是什么吧
  •  我：（这不就是总结下redis的定义和特点嘛）Redis是C语言开发的一个开源的（遵从BSD协议）高性能键值对（key-value）的内存数据库，可以用作数据库、缓存、消息中间件等。它是一种NoSQL（not-only sql，泛指非关系型数据库）的数据库。
  •  我顿了一下，接着说：Redis作为一个内存数据库。1、性能优秀，数据在内存中，读写速度非常快，支持并发10W QPS；2、单进程单线程，是线程安全的，采用IO多路复用机制；3、丰富的数据类型，支持字符串（strings）、散列（hashes）、列表（lists）、集合（sets）、有序集合（sorted sets）等；4、支持数据持久化。可以将内存中数据保存在磁盘中，重启时加载；5、主从复制，哨兵，高可用；6、可以用作分布式锁；7、可以作为消息中间件使用，支持发布订阅

五种数据类型

  •  面试官：总结的不错，看来是早有准备啊。刚来听你提到redis支持五种数据类型，那你能简单说下这五种数据类型吗？
  •  我：当然可以，但是在说之前，我觉得有必要先来了解下Redis内部内存管理是如何描述这5种数据类型的。说着，我拿着笔给面试官画了一张图：

  •  我：首先redis内部使用一个redisObject对象来表示所有的key和value，redisObject最主要的信息如上图所示：type表示一个value对象具体是何种数据类型，encoding是不同数据类型在redis内部的存储方式。比如：type=string表示value存储的是一个普通字符串，那么encoding可以是raw或者int。
  •  我顿了一下，接着说：下面我简单说下5种数据类型：
    •   1、string是redis最基本的类型，可以理解成与memcached一模一样的类型，一个key对应一个value。value不仅是string，也可以是数字。string类型是二进制安全的，意思是redis的string类型可以包含任何数据，比如jpg图片或者序列化的对象。string类型的值最大能存储512M。
    •   2、Hash是一个键值（key-value）的集合。redis的hash是一个string的key和value的映射表，Hash特别适合存储对象。常用命令：hget,hset,hgetall等。
    •   3、list列表是简单的字符串列表，按照插入顺序排序  。可以添加一个元素到列表的头部（左边）或者尾部（右边）  常用命令：lpush、rpush、lpop、rpop、lrange(获取列表片段)等。应用场景：list应用场景非常多，也是Redis最重要的数据结构之一，比如twitter的关注列表，粉丝列表都可以用list结构来实现。数据结构：list就是链表，可以用来当消息队列用。redis提供了List的push和pop操作，还提供了操作某一段的api，可以直接查询或者删除某一段的元素。实现方式：redis list的是实现是一个双向链表，既可以支持反向查找和遍历，更方便操作，不过带来了额外的内存开销。
    •   4、set是string类型的无序集合。集合是通过hashtable实现的。set中的元素是没有顺序的，而且是没有重复的。常用命令：sdd、spop、smembers、sunion等。应用场景：redis set对外提供的功能和list一样是一个列表，特殊之处在于set是自动去重的，而且set提供了判断某个成员是否在一个set集合中。
    •   5、zset和set一样是string类型元素的集合，且不允许重复的元素。常用命令：zadd、zrange、zrem、zcard等。使用场景：sorted set可以通过用户额外提供一个优先级（score）的参数来为成员排序，并且是插入有序的，即自动排序。当你需要一个有序的并且不重复的集合列表，那么可以选择sorted set结构。和set相比，sorted set关联了一个double类型权重的参数score，使得集合中的元素能够按照score进行有序排列，redis正是通过分数来为集合中的成员进行从小到大的排序。实现方式：Redis sorted set的内部使用HashMap和跳跃表(skipList)来保证数据的存储和有序，HashMap里放的是成员到score的映射，而跳跃表里存放的是所有的成员，排序依据是HashMap里存的score，使用跳跃表的结构可以获得比较高的查找效率，并且在实现上比较简单。
  •  我：我之前总结了一张图，关于数据类型的应用场景，如果您感兴趣，可以去我的掘金看。。

数据类型应用场景总结

类型 简介 特性 场景
string（字符串） 二进制安全 可以包含任何数据，比如jpg图片或者序列化对象 ---
Hash（字典） 键值对集合，即编程语言中的map类型 适合存储对象，并且可以像数据库中的update一个属性一样只修改某一项属性值 存储、读取、修改用户属性
List（列表） 链表（双向链表） 增删快，提供了操作某一元素的api 最新消息排行；消息队列
set（集合） hash表实现，元素不重复 添加、删除、查找的复杂度都是O(1)，提供了求交集、并集、差集的操作 共同好友；利用唯一性，统计访问网站的所有Ip
sorted set（有序集合） 将set中的元素增加一个权重参数score，元素按score有序排列 数据插入集合时，已经进行了天然排序 排行榜；带权重的消息队列
  •  面试官：想不到你平时也下了不少工夫，那redis缓存你一定用过的吧
  •  我：用过的。。
  •  面试官：那你跟我说下你是怎么用的？
  •  我是结合spring boot使用的。一般有两种方式，一种是直接通过RedisTemplate来使用，另一种是使用spring cache集成Redis（也就是注解的方式）。具体的代码我就不说了，在我的掘金中有一个demo（见下）。

Redis缓存

  •  直接通过RedisTemplate来使用
  •  使用spring cache集成Redis pom.xml中加入以下依赖：
 
 
 
 
    
  
  
  
  
  1.  
    2. 
  
  
  
  
  2.      
    3. 
  
  
  
  
  3.         org.springframework.boot 
    4. 
  
  
  
  
  4.         spring-boot-starter-data-redis 
    5. 
  
  
  
  
  5.      
    6. 
  
  
  
  
  6.      
    7. 
  
  
  
  
  7.         org.apache.commons 
    8. 
  
  
  
  
  8.         commons-pool2 
    9. 
  
  
  
  
  9.      
    10. 
  
  
  
  
  10.      
    11. 
  
  
  
  
  11.         org.springframework.boot 
    12. 
  
  
  
  
  12.         spring-boot-starter-web 
    13. 
  
  
  
  
  13.      
    14. 
  
  
  
  
  14.      
    15. 
  
  
  
  
  15.         org.springframework.session 
    16. 
  
  
  
  
  16.         spring-session-data-redis 
    17. 
  
  
  
  
  17.      
    18. 
  
  
  
  
  18.      
    19. 
  
  
  
  
  19.         org.projectlombok 
    20. 
  
  
  
  
  20.         lombok 
    21. 
  
  
  
  
  21.         true 
    22. 
  
  
  
  
  22.      
    23. 
  
  
  
  
  23.      
    24. 
  
  
  
  
  24.         org.springframework.boot 
    25. 
  
  
  
  
  25.         spring-boot-starter-test 
    26. 
  
  
  
  
  26.         test 
    27. 
  
  
  
  
  27.      
    28. 
  
  
  
  
  28.
  •  spring-boot-starter-data-redis:在spring boot 2.x以后底层不再使用Jedis，而是换成了Lettuce。
  •  commons-pool2：用作redis连接池，如不引入启动会报错
  •  spring-session-data-redis：spring session引入，用作共享session。配置文件application.yml的配置：
 
 
 
 
    
  
  
  
  
  1. server: 
    2. 
  
  
  
  
  2.   port: 8082 
    3. 
  
  
  
  
  3.   servlet: 
    4. 
  
  
  
  
  4.     session: 
    5. 
  
  
  
  
  5.       timeout: 30ms 
    6. 
  
  
  
  
  6. spring: 
    7. 
  
  
  
  
  7.   cache: 
    8. 
  
  
  
  
  8.     type: redis 
    9. 
  
  
  
  
  9.   redis: 
    10. 
  
  
  
  
  10.     host: 127.0.0.1 
    11. 
  
  
  
  
  11.     port: 6379 
    12. 
  
  
  
  
  12.     password: 
    13. 
  
  
  
  
  13.     # redis默认情况下有16个分片，这里配置具体使用的分片，默认为0 
    14. 
  
  
  
  
  14.     database: 0 
    15. 
  
  
  
  
  15.     lettuce: 
    16. 
  
  
  
  
  16.       pool: 
    17. 
  
  
  
  
  17.         # 连接池最大连接数(使用负数表示没有限制),默认8 
    18. 
  
  
  
  
  18.         max-active: 100
    19.

创建实体类User.java

 
 
 
 
    
  
  
  
  
  1. public class User implements Serializable{ 
    2. 
  
  
  
  
  2.     private static final long serialVersionUID = 662692455422902539L; 
    3. 
  
  
  
  
  3.     private Integer id; 
    4. 
  
  
  
  
  4.     private String name; 
    5. 
  
  
  
  
  5.     private Integer age; 
    6. 
  
  
  
  
  6.     public User() { 
    7. 
  
  
  
  
  7.     } 
    8. 
  
  
  
  
  8.     public User(Integer id, String name, Integer age) { 
    9. 
  
  
  
  
  9.         this.id = id; 
    10. 
  
  
  
  
  10.         this.name = name; 
    11. 
  
  
  
  
  11.         this.age = age; 
    12. 
  
  
  
  
  12.     } 
    13. 
  
  
  
  
  13.     public Integer getId() { 
    14. 
  
  
  
  
  14.         return id; 
    15. 
  
  
  
  
  15.     } 
    16. 
  
  
  
  
  16.     public void setId(Integer id) { 
    17. 
  
  
  
  
  17.         this.id = id; 
    18. 
  
  
  
  
  18.     } 
    19. 
  
  
  
  
  19.     public String getName() { 
    20. 
  
  
  
  
  20.         return name; 
    21. 
  
  
  
  
  21.     } 
    22. 
  
  
  
  
  22.     public void setName(String name) { 
    23. 
  
  
  
  
  23.         this.name = name; 
    24. 
  
  
  
  
  24.     } 
    25. 
  
  
  
  
  25.     public Integer getAge() { 
    26. 
  
  
  
  
  26.         return age; 
    27. 
  
  
  
  
  27.     } 
    28. 
  
  
  
  
  28.     public void setAge(Integer age) { 
    29. 
  
  
  
  
  29.         this.age = age; 
    30. 
  
  
  
  
  30.     } 
    31. 
  
  
  
  
  31.     @Override 
    32. 
  
  
  
  
  32.     public String toString() { 
    33. 
  
  
  
  
  33.         return "User{" + 
    34. 
  
  
  
  
  34.                 "id=" + id + 
    35. 
  
  
  
  
  35.                 ", name='" + name + '\'' + 
    36. 
  
  
  
  
  36.                 ", age=" + age +
    37. 
  
  
  
  
  37.                  '}'; 
    38. 
  
  
  
  
  38.     } 
    39. 
  
  
  
  
  39. }
    40.

RedisTemplate的使用方式

默认情况下的模板只能支持RedisTemplate，也就是只能存入字符串，所以自定义模板很有必要。添加配置类RedisCacheConfig.java

 
 
 
 
    
  
  
  
  
  1. @Configuration 
    2. 
  
  
  
  
  2. @AutoConfigureAfter(RedisAutoConfiguration.class) 
    3. 
  
  
  
  
  3. public class RedisCacheConfig { 
    4. 
  
  
  
  
  4.     @Bean 
    5. 
  
  
  
  
  5.     public RedisTemplate redisCacheTemplate(LettuceConnectionFactory connectionFactory) { 
    6. 
  
  
  
  
  6.         RedisTemplate template = new RedisTemplate<>(); 
    7. 
  
  
  
  
  7.         template.setKeySerializer(new StringRedisSerializer()); 
    8. 
  
  
  
  
  8.         template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); 
    9. 
  
  
  
  
  9.         template.setConnectionFactory(connectionFactory); 
    10. 
  
  
  
  
  10.         return template; 
    11. 
  
  
  
  
  11.     } 
    12. 
  
  
  
  
  12. }
    13.

测试类

 
 
 
 
    
  
  
  
  
  1. @RestController 
    2. 
  
  
  
  
  2. @RequestMapping("/user") 
    3. 
  
  
  
  
  3. public class UserController { 
    4. 
  
  
  
  
  4.     public static Logger logger = LogManager.getLogger(UserController.class); 
    5. 
  
  
  
  
  5.     @Autowired 
    6. 
  
  
  
  
  6.     private StringRedisTemplate stringRedisTemplate; 
    7. 
  
  
  
  
  7.     @Autowired 
    8. 
  
  
  
  
  8.     private RedisTemplate redisCacheTemplate;
    9. 
  
  
  
  
  9.     @RequestMapping("/test") 
    10. 
  
  
  
  
  10.     public void test() { 
    11. 
  
  
  
  
  11.         redisCacheTemplate.opsForValue().set("userkey", new User(1, "张三", 25)); 
    12. 
  
  
  
  
  12.         User user = (User) redisCacheTemplate.opsForValue().get("userkey"); 
    13. 
  
  
  
  
  13.         logger.info("当前获取对象：{}", user.toString()); 
    14. 
  
  
  
  
  14.     }
    15.

然后在浏览器访问，观察后台日志 http://localhost:8082/user/test

使用spring cache集成redis

spring cache具备很好的灵活性，不仅能够使用SPEL(spring expression language)来定义缓存的key和各种condition，还提供了开箱即用的缓存临时存储方案，也支持和主流的专业缓存如EhCache、Redis、Guava的集成。定义接口UserService.java

 
 
 
 
    
  
  
  
  
  1. public interface UserService { 
    2. 
  
  
  
  
  2.     User save(User user); 
    3. 
  
  
  
  
  3.     void delete(int id); 
    4. 
  
  
  
  
  4.     User get(Integer id); 
    5. 
  
  
  
  
  5. }
    6.

接口实现类UserServiceImpl.java

 
 
 
 
    
  
  
  
  
  1. @Service 
    2. 
  
  
  
  
  2. public class UserServiceImpl implements UserService{ 
    3. 
  
  
  
  
  3.     public static Logger logger = LogManager.getLogger(UserServiceImpl.class); 
    4. 
  
  
  
  
  4.     private static Map userMap = new HashMap<>(); 
    5. 
  
  
  
  
  5.     static { 
    6. 
  
  
  
  
  6.         userMap.put(1, new User(1, "肖战", 25)); 
    7. 
  
  
  
  
  7.         userMap.put(2, new User(2, "王一博", 26)); 
    8. 
  
  
  
  
  8.         userMap.put(3, new User(3, "杨紫", 24)); 
    9. 
  
  
  
  
  9.     } 
    10. 
  
  
  
  
  10.     @CachePut(value ="user", key = "#user.id") 
    11. 
  
  
  
  
  11.     @Override 
    12. 
  
  
  
  
  12.     public User save(User user) { 
    13. 
  
  
  
  
  13.         userMap.put(user.getId(), user); 
    14. 
  
  
  
  
  14.         logger.info("进入save方法，当前存储对象：{}", user.toString()); 
    15. 
  
  
  
  
  15.         return user; 
    16. 
  
  
  
  
  16.     } 
    17. 
  
  
  
  
  17.     @CacheEvict(value="user", key = "#id") 
    18. 
  
  
  
  
  18.     @Override 
    19. 
  
  
  
  
  19.     public void delete(int id) { 
    20. 
  
  
  
  
  20.         userMap.remove(id); 
    21. 
  
  
  
  
  21.         logger.info("进入delete方法，删除成功"); 
    22. 
  
  
  
  
  22.     }
    23. 
  
  
  
  
  23.     @Cacheable(value = "user", key = "#id") 
    24. 
  
  
  
  
  24.     @Override 
    25. 
  
  
  
  
  25.     public User get(Integer id) { 
    26. 
  
  
  
  
  26.         logger.info("进入get方法，当前获取对象：{}", userMap.get(id)==null?null:userMap.get(id).toString()); 
    27. 
  
  
  
  
  27.         return userMap.get(id); 
    28. 
  
  
  
  
  28.     } 
    29. 
  
  
  
  
  29. }
    30.

为了方便演示数据库的操作，这里直接定义了一个Map userMap，这里的核心是三个注解@Cachable、@CachePut和@CacheEvict。测试类：UserController

 
 
 
 
    
  
  
  
  
  1. @RestController 
    2. 
  
  
  
  
  2. @RequestMapping("/user") 
    3. 
  
  
  
  
  3. public class UserController { 
    4. 
  
  
  
  
  4.     public static Logger logger = LogManager.getLogger(UserController.class); 
    5. 
  
  
  
  
  5.     @Autowired 
    6. 
  
  
  
  
  6.     private StringRedisTemplate stringRedisTemplate; 
    7. 
  
  
  
  
  7.     @Autowired 
    8. 
  
  
  
  
  8.     private RedisTemplate redisCacheTemplate; 
    9. 
  
  
  
  
  9.     @Autowired 
    10. 
  
  
  
  
  10.     private UserService userService; 
    11. 
  
  
  
  
  11.     @RequestMapping("/test") 
    12. 
  
  
  
  
  12.     public void test() { 
    13. 
  
  
  
  
  13.         redisCacheTemplate.opsForValue().set("userkey", new User(1, "张三", 25)); 
    14. 
  
  
  
  
  14.         User user = (User) redisCacheTemplate.opsForValue().get("userkey"); 
    15. 
  
  
  
  
  15.         logger.info("当前获取对象：{}", user.toString()); 
    16. 
  
  
  
  
  16.     }  
    17. 
  
  
  
  
  17.     @RequestMapping("/add") 
    18. 
  
  
  
  
  18.     public void add() { 
    19. 
  
  
  
  
  19.         User user = userService.save(new User(4, "李现", 30)); 
    20. 
  
  
  
  
  20.         logger.info("添加的用户信息：{}",user.toString()); 
    21. 
  
  
  
  
  21.     } 
    22. 
  
  
  
  
  22.     @RequestMapping("/delete") 
    23. 
  
  
  
  
  23.     public void delete() { 
    24. 
  
  
  
  
  24.         userService.delete(4); 
    25. 
  
  
  
  
  25.     } 
    26. 
  
  
  
  
  26.     @RequestMapping("/get/{id}") 
    27. 
  
  
  
  
  27.     public void get(@PathVariable("id") String idStr) throws Exception{ 
    28. 
  
  
  
  
  28.         if (StringUtils.isBlank(idStr)) { 
    29. 
  
  
  
  
  29.             throw new Exception("id为空"); 
    30. 
  
  
  
  
  30.         } 
    31. 
  
  
  
  
  31.         Integer id = Integer.parseInt(idStr); 
    32. 
  
  
  
  
  32.         User user = userService.get(id); 
    33. 
  
  
  
  
  33.         logger.info("获取的用户信息：{}",user.toString()); 
    34. 
  
  
  
  
  34.     } 
    35. 
  
  
  
  
  35. }
    36.

用缓存要注意，启动类要加上一个注解开启缓存

 
 
 
 
    
  
  
  
  
  1. @SpringBootApplication(exclude=DataSourceAutoConfiguration.class) 
    2. 
  
  
  
  
  2. @EnableCaching 
    3. 
  
  
  
  
  3. public class Application { 
    4. 
  
  
  
  
  4.     public static void main(String[] args) { 
    5. 
  
  
  
  
  5.         SpringApplication.run(Application.class, args); 
    6. 
  
  
  
  
  6.     } 
    7. 
  
  
  
  
  7. }
    8.

1、先调用添加接口：http://localhost:8082/user/add

2、再调用查询接口，查询id=4的用户信息：

可以看出，这里已经从缓存中获取数据了，因为上一步add方法已经把id=4的用户数据放入了redis缓存 3、调用删除方法，删除id=4的用户信息，同时清除缓存

3、调用删除方法，删除id=4的用户信息，同时清除缓存

4、再次调用查询接口，查询id=4的用户信息：

没有了缓存，所以进入了get方法，从userMap中获取。

缓存注解

1、@Cacheable 根据方法的请求参数对其结果进行缓存

  •  key：缓存的key，可以为空，如果指定要按照SPEL表达式编写，如果不指定，则按照方法的所有参数进行组合。
  •  value：缓存的名称，必须指定至少一个（如 @Cacheable (value='user')或者@Cacheable(value={'user1','user2'})）
  •  condition：缓存的条件，可以为空，使用SPEL编写，返回true或者false，只有为true才进行缓存。

2、@CachePut 根据方法的请求参数对其结果进行缓存，和@Cacheable不同的是，它每次都会触发真实方法的调用。参数描述见上。

3、@CacheEvict 根据条件对缓存进行清空

  •  key：同上
  •  value：同上
  •  condition：同上
  •  allEntries：是否清空所有缓存内容，缺省为false，如果指定为true，则方法调用后将立即清空所有缓存
  •  beforeInvocation：是否在方法执行前就清空，缺省为false，如果指定为true，则在方法还没有执行的时候就清空缓存。缺省情况下，如果方法执行抛出异常，则不会清空缓存。

缓存问题

  •  面试官：看了一下你的demo，简单易懂。那你在实际项目中使用缓存有遇到什么问题或者会遇到什么问题你知道吗？
  •  我：缓存和数据库数据一致性问题：分布式环境下非常容易出现缓存和数据库间数据一致性问题，针对这一点，如果项目对缓存的要求是强一致性的，那么就不要使用缓存。我们只能采取合适的策略来降低缓存和数据库间数据不一致的概率，而无法保证两者间的强一致性。合适的策略包括合适的缓存更新策略，更新数据库后及时更新缓存、缓存失败时增加重试机制。
  •  面试官：Redis雪崩了解吗？
  •  我：我了解的，目前电商首页以及热点数据都会去做缓存，一般缓存都是定时任务去刷新，或者查不到之后去更新缓存的，定时任务刷新就有一个问题。举个栗子：如果首页所有Key的失效时间都是12小时，中午12点刷新的，我零点有个大促活动大量用户涌入，假设每秒6000个请求，本来缓存可以抗住每秒5000个请求，但是缓存中所有Key都失效了。此时6000个/秒的请求全部落在了数据库上，数据库必然扛不住，真实情况可能DBA都没反应过来直接挂了，此时，如果没什么特别的方案来处理，DBA很着急，重启数据库，但是数据库立马又被新流量给打死了。这就是我理解的缓存雪崩。
  •  我心想：同一时间大面积失效，瞬间Redis跟没有一样，那这个数量级别的请求直接打到数据库几乎是灾难性的，你想想如果挂的是一个用户服务的库，那其他依赖他的库所有接口几乎都会报错，如果没做熔断等策略基本上就是瞬间挂一片的节奏，你怎么重启用户都会把你打挂，等你重启好的时候，用户早睡觉去了，临睡之前，骂骂咧咧“什么垃圾产品”。
  •  面试官摸摸了自己的头发：嗯，还不错，那这种情况你都是怎么应对的？
  •  我：处理缓存雪崩简单，在批量往Redis存数据的时候，把每个Key的失效时间都加个随机值就好了，这样可以保证数据不会再同一时间大面积失效。
 
 
 
 
    
  
  
  
  
  1. setRedis（key, value, time+Math.random()*10000）;
    2.

如果Redis是集群部署，将热点数据均匀分布在不同的Redis库中也能避免全部失效。或者设置热点数据永不过期，有更新操作就更新缓存就好了（比如运维更新了首页商品，那你刷下缓存就好了，不要设置过期时间），电商首页的数据也可以用这个操作，保险。

  •  面试官：那你了解缓存穿透和击穿么，可以说说他们跟雪崩的区别吗？
  •  我：嗯，了解，先说下缓存穿透吧，缓存穿透是指缓存和数据库中都没有的数据，而用户（黑客）不断发起请求，举个栗子：我们数据库的id都是从1自增的，如果发起id=-1的数据或者id特别大不存在的数据，这样的不断攻击导致数据库压力很大，严重会击垮数据库。
  •  我又接着说：至于缓存击穿嘛，这个跟缓存雪崩有点像，但是又有一点不一样，缓存雪崩是因为大面积的缓存失效，打崩了DB，而缓存击穿不同的是缓存击穿是指一个Key非常热点，在不停地扛着大量的请求，大并发集中对这一个点进行访问，当这个Key在失效的瞬间，持续的大并发直接落到了数据库上，就在这个Key的点上击穿了缓存。
  •  面试官露出欣慰的眼光：那他们分别怎么解决？
  •  我：缓存穿透我会在接口层增加校验，比如用户鉴权，参数做校验，不合法的校验直接return，比如id做基础校验，id<=0直接拦截。
  •  面试官：那你还有别的方法吗？
  •  我：我记得Redis里还有一个高级用法**布隆过滤器（Bloom Filter）**这个也能很好的预防缓存穿透的发生，他的原理也很简单，就是利用高效的数据结构和算法快速判断出你这个Key是否在数据库中存在，不存在你return就好了，存在你就去查DB刷新KV再return。缓存击穿的话，设置热点数据永不过期，或者加上互斥锁就搞定了。作为暖男，代码给你准备好了，拿走不谢。
 
 
 
 
    
  
  
  
  
  1. public static String getData(String key) throws InterruptedException { 
    2. 
  
  
  
  
  2.         //从Redis查询数据 
    3. 
  
  
  
  
  3.         String result = getDataByKV(key); 
    4. 
  
  
  
  
  4.         //参数校验 
    5. 
  
  
  
  
  5.         if (StringUtils.isBlank(result)) { 
    6. 
  
  
  
  
  6.             try { 
    7. 
  
  
  
  
  7.                 //获得锁 
    8. 
  
  
  
  
  8.                 if (reenLock.tryLock()) { 
    9. 
  
  
  
  
  9.                     //去数据库查询 
    10. 
  
  
  
  
  10.                     result = getDataByDB(key); 
    11. 
  
  
  
  
  11.                     //校验 
    12. 
  
  
  
  
  12.                     if (StringUtils.isNotBlank(result)) { 
    13. 
  
  
  
  
  13.                         //插进缓存 
    14. 
  
  
  
  
  14.                         setDataToKV(key, result); 
    15. 
  
  
  
  
  15.                     } 
    16. 
  
  
  
  
  16.                 } else { 
    17. 
  
  
  
  
  17.                     //睡一会再拿 
    18. 
  
  
  
  
  18.                     Thread.sleep(100L); 
    19. 
  
  
  
  
  19.                     result = getData(key); 
    20. 
  
  
  
  
  20.                 } 
    21. 
  
  
  
  
  21.             } finally { 
    22. 
  
  
  
  
  22.                 //释放锁 
    23. 
  
  
  
  
  23.                 reenLock.unlock(); 
    24. 
  
  
  
  
  24.             } 
    25. 
  
  
  
  
  25.         } 
    26. 
  
  
  
  
  26.         return result;
    27. 
  
  
  
  
  27.      }
    28.
  •  面试官：嗯嗯，还不错。

Redis为何这么快

  •  面试官：redis作为缓存大家都在用，那redis一定很快咯？
  •  我：当然了，官方提供的数据可以达到100000+的QPS（每秒内的查询次数），这个数据不比Memcached差！
  •  面试官：redis这么快，它的“多线程模型”你了解吗？（露出邪魅一笑）
  •  我：您是想问Redis这么快，为什么还是单线程的吧。Redis确实是单进程单线程的模型，因为Redis完全是基于内存的操作，CPU不是Redis的瓶颈，Redis的瓶颈最有可能是机器内存的大小或者网络带宽。既然单线程容易实现，而且CPU不会成为瓶颈，那就顺理成章的采用单线程的方案了（毕竟采用多线程会有很多麻烦）。
  •  面试官：嗯，是的。那你能说说Redis是单线程的，为什么还能这么快吗？
  •  我：可以这么说吧。第一：Redis完全基于内存，绝大部分请求是纯粹的内存操作，非常迅速，数据存在内存中，类似于HashMap，HashMap的优势就是查找和操作的时间复杂度是O(1)。第二：数据结构简单，对数据操作也简单。第三：采用单线程，避免了不必要的上下文切换和竞争条件，不存在多线程导致的CPU切换，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有死锁问题导致的性能消耗。第四：使用多路复用IO模型，非阻塞IO。

Redis和Memcached的区别

  •     面试官：嗯嗯，说的很详细。那你为什么选择Redis的缓存方案而不用memcached呢
  •     我：
    •   1、存储方式上：memcache会把数据全部存在内存之中，断电后会挂掉，数据不能超过内存大小。redis有部分数据存在硬盘上，这样能保证数据的持久性。
    •   2、数据支持类型上：memcache对数据类型的支持简单，只支持简单的key-value，，而redis支持五种数据类型。
    •   3、使用底层模型不同：它们之间底层实现方式以及与客户端之间通信的应用协议不一样。redis直接自己构建了VM机制，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求。
    •   4、value的大小：redis可以达到1GB，而memcache只有1MB。

淘汰策略

  •  面试官：那你说说你知道的redis的淘汰策略有哪些？
  •  我：Redis有六种淘汰策略
策略 描述
volatile-lru 从已设置过期时间的KV集中优先对最近最少使用(less recently used)的数据淘汰
volitile-ttl 从已设置过期时间的KV集中优先对剩余时间短(time to live)的数据淘汰
volitile-random 从已设置过期时间的KV集中随机选择数据淘汰
allkeys-lru 从所有KV集中优先对最近最少使用(less recently used)的数据淘汰
allKeys-random 从所有KV集中随机选择数据淘汰
noeviction 不淘汰策略，若超过最大内存，返回错误信息

补充一下：Redis4.0加入了LFU(least frequency use)淘汰策略，包括volatile-lfu和allkeys-lfu，通过统计访问频率，将访问频率最少，即最不经常使用的KV淘汰。

持久化

  •  面试官：你对redis的持久化机制了解吗？能讲一下吗？
  •  我：redis为了保证效率，数据缓存在了内存中，但是会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件中，以保证数据的持久化。Redis的持久化策略有两种：1、RDB：快照形式是直接把内存中的数据保存到一个dump的文件中，定时保存，保存策略。2、AOF：把所有的对Redis的服务器进行修改的命令都存到一个文件里，命令的集合。Redis默认是快照RDB的持久化方式。当Redis重启的时候，它会优先使用AOF文件来还原数据集，因为AOF文件保存的数据集通常比RDB文件所保存的数据集更完整。你甚至可以关闭持久化功能，让数据只在服务器运行时存。
  •  面试官：那你再说下RDB是怎么工作的？
  •  我：默认Redis是会以快照"RDB"的形式将数据持久化到磁盘的一个二进制文件dump.rdb。工作原理简单说一下：当Redis需要做持久化时，Redis会fork一个子进程，子进程将数据写到磁盘上一个临时RDB文件中。当子进程完成写临时文件后，将原来的RDB替换掉，这样的好处是可以copy-on-write。
  •  我：RDB的优点是：这种文件非常适合用于备份：比如，你可以在最近的24小时内，每小时备份一次，并且在每个月的每一天也备份一个RDB文件。这样的话，即使遇上问题，也可以随时将数据集还原到不同的版本。RDB非常适合灾难恢复。RDB的缺点是：如果你需要尽量避免在服务器故障时丢失数据，那么RDB不合适你。
  •  面试官：那你要不再说下AOF？？
  •  我：（说就一起说下吧）使用AOF做持久化，每一个写命令都通过write函数追加到appendonly.aof中，配置方式如下：
 
 
 
 
    
  
  
  
  
  1. appendfsync yes 
    2. 
  
  
  
  
  2. appendfsync always     #每次有数据修改发生时都会写入AOF文件。 
    3. 
  
  
  
  
  3. appendfsync everysec   #每秒钟同步一次，该策略为AOF的缺省策略。
    4.

AOF可以做到全程持久化，只需要在配置中开启 appendonly yes。这样redis每执行一个修改数据的命令，都会把它添加到AOF文件中，当redis重启时，将会读取AOF文件进行重放，恢复到redis关闭前的最后时刻。

  •  我顿了一下，继续说：使用AOF的优点是会让redis变得非常耐久。可以设置不同的fsync策略，aof的默认策略是每秒钟fsync一次，在这种配置下，就算发生故障停机，也最多丢失一秒钟的数据。缺点是对于相同的数据集来说，AOF的文件体积通常要大于RDB文件的体积。根据所使用的fsync策略，AOF的速度可能会慢于RDB。
  •  面试官又问：你说了这么多，那我该用哪一个呢？
  •  我：如果你非常关心你的数据，但仍然可以承受数分钟内的数据丢失，那么可以额只使用RDB持久。AOF将Redis执行的每一条命令追加到磁盘中，处理巨大的写入会降低Redis的性能，不知道你是否可以接受。数据库备份和灾难恢复：定时生成RDB快照非常便于进行数据库备份，并且RDB恢复数据集的速度也要比AOF恢复的速度快。当然了，redis支持同时开启RDB和AOF，系统重启后，redis会优先使用AOF来恢复数据，这样丢失的数据会最少。

主从复制

  •  面试官：redis单节点存在单点故障问题，为了解决单点问题，一般都需要对redis配置从节点，然后使用哨兵来监听主节点的存活状态，如果主节点挂掉，从节点能继续提供缓存功能，你能说说redis主从复制的过程和原理吗？
  •  我有点懵，这个说来就话长了。但幸好提前准备了：主从配置结合哨兵模式能解决单点故障问题，提高redis可用性。从节点仅提供读操作，主节点提供写操作。对于读多写少的状况，可给主节点配置多个从节点，从而提高响应效率。
  •  我顿了一下，接着说：关于复制过程，是这样的：1、从节点执行slaveof[masterIP][masterPort]，保存主节点信息 2、从节点中的定时任务发现主节点信息，建立和主节点的socket连接 3、从节点发送Ping信号，主节点返回Pong，两边能互相通信 4、连接建立后，主节点将所有数据发送给从节点（数据同步） 5、主节点把当前的数据同步给从节点后，便完成了复制的建立过程。接下来，主节点就会持续的把写命令发送给从节点，保证主从数据一致性。
  •  面试官：那你能详细说下数据同步的过程吗？
  •  （我心想：这也问的太细了吧）我：可以。redis2.8之前使用sync[runId][offset]同步命令，redis2.8之后使用psync[runId][offset]命令。两者不同在于，sync命令仅支持全量复制过程，psync支持全量和部分复制。介绍同步之前，先介绍几个概念：runId：每个redis节点启动

    分享名称：大厂面试！我和面试官之间关于Redis的一场对弈！
    文章分享：http://www.csdahua.cn/qtweb/news12/261062.html

    网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

    广告

    声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

ChatGPT知识

同城分类信息

网络营销推广　　 　达州网站设计　　 　香港虚拟主机　　 　成都小程序开发　　 　网络营销公司　　 　网站建设公司　　 　重庆电信回兴机房　　 　微信小程序公众号开发　　 　重庆水土双线托管　　 　成都微信小程序开发　　 　成都企业网站维护　　 　网站排名优化　　 　成都柴油发电机租用　　 　彭山网站制作　　 　四川绵阳主机托管　　 　品牌网站建设　　 　重庆花箱　　 　营销型网站建设　　 　四川中建建业　　 　草坪音箱