当前位置:首页 » 《关注互联网》 » 正文

php面试题-Redis篇_qq_43737121的博客

25 人参与  2021年08月04日 15:03  分类 : 《关注互联网》  评论

点击全文阅读


一.为什么使用缓存?

1.高性能

假设这么个场景,有个操作,一个请求过来,耗时 600ms 操作 mysql查出来一个结果,但是这个结果可能接下来几个小时都不会变了,或者变了也可以不会立即反馈给用户。那么此时咋办?

将折腾 600ms 查出来的结果放入缓存里,一个 key 对应一个 value,下次查找时不经过 mysql,直接从缓存里通过一个 key 查出来一个 value,2ms 搞定,性能提升 300 倍。

所以对于一些需要复杂操作耗时查出来的结果,确定后面不怎么变化,但是有很多读请求,直接将查询出来的结果放在缓存中,后面直接读缓存就好。

2.高并发

mysql 数据库对于高并发来说天然支持不好,mysql 单机支撑到 2000QPS 也开始容易报警了。

所以若是系统高峰期一秒钟有1万个请求,那么一个 mysql 单机绝对会死掉。这个时候就只能上缓存,把很多数据放入缓存,别放入 mysql。缓存功能简单,说白了就是 key-value 式操作,单机支撑的并发量一秒可达几万十几万,单机承载并发量是 mysql 单机的几十倍。

缓存是走内存的,内存天然就支撑高并发。

二.什么是缓存穿透?缓存击穿?缓存雪崩?怎么解决?

1.缓存穿透:缓存中查不到,数据库中也查不到。

解决方案:1》对参数进行合法性校验。2》将数据库中没有查到结果的数据也写入到缓存。这是要注意为了防止Redis被无用的key占满,这一类缓存的有效期要设置的短一点。3》引入布隆过滤器,在访问Redis之前判断数据是否存在。要注意布隆过滤器存在一定的误判率,并且,布隆过滤器只能加数据不能减数据。

 2.缓存穿透:缓存中没有,数据库中有。一般是出现在存数据初始化以及key过期了的情况。它的问题在于,重新写入缓存需要一定的时间,如果是在高并发场景下,过多的请求就会瞬间写到DB上,给DB造成很大的压力。

解决方案:1》设置这个热点缓存永不过期,这是要注意在value当中包含一个逻辑上的过期时间,然后另起一个线程,定期重建这些缓存。2》加载DB的时候,要防止并发。可以对数据库加锁。

3.缓存雪崩:缓存大面积过期,导致请求都被转发到DB。

解决方案:1》把缓存的失效时间分散开。例如:在原有的统一失效时间基础上,增加一个随机值。2》对热点数据设置永不过期。

三.如何保证Redis与数据库的数据一致?

当我们对数据进行修改的时候,到底是先删缓存,还是先写数据库?

1.如果先删缓存,在写数据库:在高并发场景下,当第一个线程删除了缓存,还没来得及写数据库,第二个线程来读取数据,会发现缓存中的数据为空,那就会去读数据库中的数据(旧值,脏数据),读完之后,把读到的结果写入缓存(此时,第一个线程已经将新的值写到缓存里面了),这样缓存中的值就会被覆盖为修改前的脏数据。

解决方案:1》先操作缓存,但是不删除缓存,将缓存修改为一个特殊值(-999).客户端读缓存时,发现是默认值,就休眠一会,再去查一次Redis。-》特殊值对业务有侵入。休眠时间,可能会多次重复,对性能有影响。

2》延时双删,先删除缓存,然后再写数据库,休眠一小会,再次删除缓存。

2.先写数据库,再删缓存:如果数据库写完之后,缓存删除失败,数据就会不一致。

总结:始终只能保证一定时间内的最终一致性。

解决方案:1》给缓存设置一个过期时间 问题:过期时间内,缓存数据不会更新。

2》引入MQ,保证原子操作。

四.Redis如何配置key的过期时间?它的实现原理是什么?

redis设置key的过期时间:1.EXPIRE  2.SETEX

实现原理:1.定期删除:每隔一段时间,执行一次删除过期key的操作。

2.懒汉式删除:当使用get、getset等指令去获取数据时,判断key是否过期,过期后,就先把key删除,再执行后面的操作。

Redis是将两种方式结合起来使用。

(1)懒汉式删除

(2)定期删除:平衡控制执行效率和执行时长。遍历每个database(默认16个),检查当前库中指定个数的key(默认是20个),随机抽查这些key,如果有过期的就删除。并且程序中有一个全局变量,用来记录扫描到了哪一个数据库(database)。                                                           

五.Redis的过期键的删除策略

Redis是key-value数据库,我们可以设置Redis中缓存的key的过期时间。Redis的过期策略就是指当Redis中缓存的key过期了,Redis如何处理。

1.惰性过期:只有当访问一个key时,才会判断该key是否已经过期,过期则清除。该策略可以最大化地节省CPU资源,却对内存非常不友好。极端情况可能出现大量的过期key没有再次被访问,从而不会被清除,占用大量内存。

2.定期删除:每隔一定的时间,会扫描一定数量的数据库的expires字典中一定数量的key,并清除其中已过期的key,该策略是前两者的一个折中方案。通过调整定时扫描的时间间隔和每次扫描的限定耗时,可以在不同情况下使得CPU和内存资源达到最优的平衡效果。

(expires字典会保存所有设置了过期时间的key的过期时间数据,其中,key是指向键空间中的某个键的指针,value是该键的毫秒精度的UNIX时间戳表示的过期时间。键空间是指该Redis集群中保存的所有键。)

Redis中同时使用了惰性过期和定时过期两种过期策略。

六.Redis线程模型、单线程快的原因

Redis基于Reactor模式开发了网络事件处理器,这个处理器叫做文件事件处理器file event handler。这个文件事件处理器,它是单线程的,所以Redis才叫做单线程的模型,它采用IO多路复用机制来同时监听多个Socket,根据Socket上的事件类型来选择对应的事件处理器来处理这个事件。可以实现高性能的网络通信,模型,又可以跟内部其他单线程的额模块进行对接,保证了Redis内部的线程模型的简单性。

文件事件处理器的结构包含四个部分L:多个Socket、IO多路复用程序、文件事件分派器以及事件处理器(命令请求处理器、命令回复处理器、连接应答处理器等)。

多个Socket可能并发的产生不同的操作,每个操作对应不同的文件事件,但是IO多路复用程序会监听多个Socket,会将Socke放入一个队列中排队,每次从队列中取出一个Socket给事件分派器,事件分派器把Socket给对应的事件处理器。

然后一个Socket的事件处理完之后,IO多路复用程序才会将队列中的下一个Socket给事件分派器。文件事件分派器会根据每个Socket当前产生的事件,来选择对应的事件处理器来处理。

单线程快的原因:

1.纯内存操作

2.核心是基于非阻塞的IO多路复用机制

3.单线程反而避免了多线程的频繁上下文切换带来的性能问题

 七.简述Redis事务实现

1.事务开始

MULTI命令的执行,标志着一个事务的开始。MULTI命令会将客户端状态的flags属性中打开REDIS_MULTI标识来完成的。

2.命令入队

当一个客户端切换到事务状态之后,服务器会根据这个客户端发送来的命令来执行不同的操作。如果客户端发送的命令为MULTI、EXEC、WATCH、DISCARD中的一个,立即执行这个命令,否则将命令放入一个事务队列里面,然后向客户端返回QUEUED回复

  • 如果客户端发送的命令为EXEC、DISCARD、WATCH、MULTI、四个命令的其中一个,那么服务器立即执行这个命令。
  • 如果客户端发送的是四个命令以外的其他命令,那么服务器并不立即执行这个命令。            首先检查此命令的格式是否正确,如果不正确,服务器会在客户端中状态(redisClient)的flags属性关闭REDIS_MULTI标识,并且返回错误信息给客户端。                                             如果正确,将这个命令放入一个事务队列里面,然后向客户端返回QUEUED回复

  事务队列是按照FIFO的方式保存入队命令

3.事务执行

客户端发送EXEC命令,服务器执行EXEC命令逻辑。

  • 如果客户端状态的flags属性不包括REDIS_MULTI标识,或者包括REDIS_DIRTY_CAS或者REDIS_DIRTY_EXEC标识,那么就取消事务的执行。
  • 否则客户端处于事务状态(flags有REDIS_MULTI标识),服务器会遍历客户端的事务队列,然后执行事务队列中的所有命令,最后将返回结果全部返回给客户端。

 redis不支持事务回滚机制,但是它会检查每一个事务中的命令是否错误。

Redis事务不支持检查那些程序员自己逻辑错误。例如对String类型的数据库键执行对HashMap类型的操作。

  • WATCH命令是一个乐观锁,可以为Redis事务提供check-and-set(CAS)行为。可以监控一个或多个键,一旦其中有一个键被修改(或删除),之后的事务就不会执行,监控一直持续到EXEC命令。
  • MULTI命令用于开启一个事务,它总是返回OK。MULTI执行之后,客户端可以继续向服务器发送任意多条命令。这些命令不会立即被执行,而是被放到一个队列中,当EXEC命令被调用时,所有队列中的命令才会被执行。
  • EXEC:执行所有事务块内的命令,返回事务块内所有命令的返回值,按命令执行的先后顺序排列。当操作被打断时,返回空值nil。
  • 通过调用DISCARD,客户端可以清空事务队列,并放弃执行事务,并且客户端会从事务状态中退出。
  • UNWATCH命令可以取消watch对所有key的监控。

 八.Redis集群方案

主从

哨兵模式:

sentinel,哨兵是redis集群中的非常重要的一个组件,主要有一下功能:

  • 集群监控:负责监控redis master和slave进程是否正常工作。
  • 消息通知:如果某个redis示例有故障,那么哨兵负责发送消息作为报警通知给管理员。
  • 故障转移:如果master node 挂掉了,会自动转移到slave node 上。
  • 配置中心:如果故障转移发生了,通知client客户端的master地址。

 哨兵用于实现redis集群的高可用,本身也是分布式的,作为一个哨兵集群去运行,互相协同工作。

  • 故障转移时,判断一个master node是否宕机了额,需要大部分的哨兵都同意才行,涉及到了分布式选举
  • 即使部分哨兵节点挂掉了,哨兵集群还是能正常工作的
  • 哨兵通常需要三个实例,来保证自己的健壮性
  • 哨兵+redis主从的部署架构,是不保证数据零丢失的,只能保证redis集群的高可用性。
  • 对于哨兵+redis主从这种复杂的部署架构,尽量在测试环境和生成环境,都进行充足的测试和演练

 九.Redis主从复制的核心原理

通过执行slaveof命令或设置slaveof选项,让一个服务器去复制另一个服务器的数据。主数据库可以进行读写操作,当写操作导致数据变化时会自动将数据同步给从数据库。而从数据库一般是只读的,并接受主数据库同步过来的数据。一个主数据库可以拥有多个从数据库,而一个从数据库只能拥有一个主数据库。

全量复制:

(1)主节点通过bgsave命令fork子进程进行RDB持久化,该过程是非常消耗CPU、内存(页表复制)、磁盘IO的

(2)主节点通过网络将RDB文件发送给从节点,对主从节点的带宽都会带来很大的消耗

(3)从节点清空老数据、载入新的RDB文件的过程是阻塞的,无法响应客户端的命令;如果从节点执行bgrewriteaof,也会带来额外的消耗

部分复制(增量复制):

(1)复制偏移量:执行复制的双方,主从节点,分别会维护一个复制偏移量offset

(2)复制积压缓冲区:主节点内部维护了一个固定长度的、先进先出(FIFO)队列作为复制积压缓冲区 ,当主从节点offset的差距过大超过缓冲区长度时,将无法执行部分复制,只能执行全量复制。

(3)服务器运行ID(runid):每个Redis节点,都有其运行ID,运行ID由节点在启动时自动生成,主节点会将自己的运行ID发送给从节点,从节点会将主节点的运行ID存起来。从节点Redis断开重连的时候,就是根据运行ID来判断同步的进度:

  • 如果从节点保存的runid与主节点现在的runid相同,说明主从结点之前同步过,主节点会继续尝试使用部分复制到底能不能部分复制还要看offset和复制积压缓冲区的情况;
  • 如果从节点保存的runid与主节点现在的runid不同,说明从节点在断线前同步的Redis节点并不是当前的主节点,只能进行全量复制。

过程原理:

今天,我不自量力的面试了某大厂的开发岗位,迎面走来一位风尘仆仆的中年男子,手里拿着屏幕还亮着的 Mac。

他冲着我礼貌的笑了笑,然后说了句“不好意思,让你久等了”,然后示意我坐下,说:“我们开始吧,看了你的简历,觉得你对 Redis 应该掌握的不错,我们今天就来讨论下 Redis……”。我想:“来就来,兵来将挡水来土掩”。

Redis 是什么

面试官:你先来说下 Redis 是什么吧!

我:(这不就是总结下 Redis 的定义和特点嘛)Redis 是 C 语言开发的一个开源的(遵从 BSD 协议)高性能键值对(key-value)的内存数据库,可以用作数据库、缓存、消息中间件等。

它是一种 NoSQL(not-only sql,泛指非关系型数据库)的数据库。

我顿了一下,接着说,Redis 作为一个内存数据库:

性能优秀,数据在内存中,读写速度非常快,支持并发 10W QPS。单进程单线程,是线程安全的,采用 IO 多路复用机制。丰富的数据类型,支持字符串(strings)、散列(hashes)、列表(lists)、集合(sets)、有序集合(sorted sets)等。支持数据持久化。可以将内存中数据保存在磁盘中,重启时加载。主从复制,哨兵,高可用。可以用作分布式锁。可以作为消息中间件使用,支持发布订阅。

五种数据类型

面试官:总结的不错,看来是早有准备啊。刚来听你提到 Redis 支持五种数据类型,那你能简单说下这五种数据类型吗?

我:当然可以,但是在说之前,我觉得有必要先来了解下 Redis 内部内存管理是如何描述这 5 种数据类型的。

说着,我拿着笔给面试官画了一张图:

 

  

我:首先 Redis 内部使用一个 redisObject 对象来表示所有的 key 和 value。

redisObject 最主要的信息如上图所示:type 表示一个 value 对象具体是何种数据类型,encoding 是不同数据类型在 Redis 内部的存储方式。

比如:type=string 表示 value 存储的是一个普通字符串,那么 encoding 可以是 raw 或者 int。

我顿了一下,接着说,下面我简单说下 5 种数据类型:

①String 是 Redis 最基本的类型,可以理解成与 Memcached一模一样的类型,一个 Key 对应一个 Value。Value 不仅是 String,也可以是数字。

String 类型是二进制安全的,意思是 Redis 的 String 类型可以包含任何数据,比如 jpg 图片或者序列化的对象。String 类型的值最大能存储 512M。

②Hash是一个键值(key-value)的集合。Redis 的 Hash 是一个 String 的 Key 和 Value 的映射表,Hash 特别适合存储对象。常用命令:hget,hset,hgetall 等。

③List 列表是简单的字符串列表,按照插入顺序排序。可以添加一个元素到列表的头部(左边)或者尾部(右边) 常用命令:lpush、rpush、lpop、rpop、lrange(获取列表片段)等。

应用场景:List 应用场景非常多,也是 Redis 最重要的数据结构之一,比如 Twitter 的关注列表,粉丝列表都可以用 List 结构来实现。

数据结构:List 就是链表,可以用来当消息队列用。Redis 提供了 List 的 Push 和 Pop 操作,还提供了操作某一段的 API,可以直接查询或者删除某一段的元素。

实现方式:Redis List 的是实现是一个双向链表,既可以支持反向查找和遍历,更方便操作,不过带来了额外的内存开销。

④Set 是 String 类型的无序集合。集合是通过 hashtable 实现的。Set 中的元素是没有顺序的,而且是没有重复的。常用命令:sdd、spop、smembers、sunion 等。

应用场景:Redis Set 对外提供的功能和 List 一样是一个列表,特殊之处在于 Set 是自动去重的,而且 Set 提供了判断某个成员是否在一个 Set 集合中。

⑤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,使用跳跃表的结构可以获得比较高的查找效率,并且在实现上比较简单。

数据类型应用场景总结:

  

 

面试官:想不到你平时也下了不少工夫,那 Redis 缓存你一定用过的吧?

我:用过的。

面试官:那你跟我说下你是怎么用的?

我是结合 Spring Boot 使用的。一般有两种方式,一种是直接通过 RedisTemplate 来使用,另一种是使用 Spring Cache 集成 Redis(也就是注解的方式)。

Redis 缓存

直接通过 RedisTemplate 来使用,使用 Spring Cache 集成 Redis pom.xml 中加入以下依赖:

<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.session</groupId><artifactId>spring-session-data-redis</artifactId></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies>

spring-boot-starter-data-redis:在 Spring Boot 2.x 以后底层不再使用 Jedis,而是换成了 Lettuce。

commons-pool2:用作 Redis 连接池,如不引入启动会报错。

spring-session-data-redis:Spring Session 引入,用作共享 Session。

配置文件 application.yml 的配置:

server: port: 8082 servlet: session: timeout: 30msspring:cache:type: redis redis: host: 127.0.0.1 port: 6379password:# redis默认情况下有16个分片,这里配置具体使用的分片,默认为0database: 0 lettuce: pool:# 连接池最大连接数(使用负数表示没有限制),默认8max-active: 100

创建实体类 User.java:

publicclassUserimplementsSerializable{privatestaticfinallong serialVersionUID = 662692455422902539L;private Integer id;private String name;private Integer age;publicUser(){ }publicUser(Integer id, String name, Integer age){this.id = id;this.name = name;this.age = age; }public Integer getId(){return id; }publicvoidsetId(Integer id){this.id = id; }public String getName(){return name; }publicvoidsetName(String name){this.name = name; }public Integer getAge(){return age; }publicvoidsetAge(Integer age){this.age = age; }@Overridepublic String toString(){return"User{" +"id=" + id +", name='" + name + '\'' +", age=" + age +'}'; }}

RedisTemplate 的使用方式

默认情况下的模板只能支持 RedisTemplate<String, String>,也就是只能存入字符串,所以自定义模板很有必要。

添加配置类 RedisCacheConfig.java:

@Configuration@AutoConfigureAfter(RedisAutoConfiguration.class)publicclassRedisCacheConfig { @Beanpublic RedisTemplate<String, Serializable> redisCacheTemplate(LettuceConnectionFactory connectionFactory) { RedisTemplate<String, Serializable> template = new RedisTemplate<>();template.setKeySerializer(new StringRedisSerializer());template.setValueSerializer(new GenericJackson2JsonRedisSerializer());template.setConnectionFactory(connectionFactory);returntemplate; }}

测试类:

@RestController@RequestMapping("/user")publicclassUserController{public static Logger logger = LogManager.getLogger(UserController.class);@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Autowiredprivate RedisTemplate<String, Serializable> redisCacheTemplate;@RequestMapping("/test")public void test() { redisCacheTemplate.opsForValue().set("userkey", new User(1, "张三", 25)); User user = (User) redisCacheTemplate.opsForValue().get("userkey"); http://logger.info("当前获取对象:{}", user.toString()); }

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

使用 Spring Cache 集成 Redis

Spring Cache 具备很好的灵活性,不仅能够使用 SPEL(spring expression language)来定义缓存的 Key 和各种 Condition,还提供了开箱即用的缓存临时存储方案,也支持和主流的专业缓存如 EhCache、Redis、Guava 的集成。

定义接口 UserService.java:

publicinterfaceUserService {User save(User user);voiddelete(int id);User get(Integer id);}

接口实现类 UserServiceImpl.java:

@ServicepublicclassUserServiceImplimplementsUserService{publicstatic Logger logger = LogManager.getLogger(UserServiceImpl.class);privatestatic Map<Integer, User> userMap = new HashMap<>();static { userMap.put(1, new User(1, "肖战", 25)); userMap.put(2, new User(2, "王一博", 26)); userMap.put(3, new User(3, "杨紫", 24)); }@CachePut(value ="user", key = "#user.id")@Overridepublic User save(User user){ userMap.put(user.getId(), user); http://logger.info("进入save方法,当前存储对象:{}", user.toString());return user; }@CacheEvict(value="user", key = "#id")@Overridepublicvoiddelete(int id){ userMap.remove(id); http://logger.info("进入delete方法,删除成功"); }@Cacheable(value = "user", key = "#id")@Overridepublic User get(Integer id){ http://logger.info("进入get方法,当前获取对象:{}", userMap.get(id)==null?null:userMap.get(id).toString());return userMap.get(id); }}

为了方便演示数据库的操作,这里直接定义了一个 Map<Integer,User> userMap。

这里的核心是三个注解:

@Cachable@CachePut@CacheEvict

测试类:UserController

@RestController@RequestMapping("/user")publicclassUserController{publicstatic Logger logger = LogManager.getLogger(UserController.class);@Autowiredprivate StringRedisTemplate stringRedisTemplate;@Autowiredprivate RedisTemplate<String, Serializable> redisCacheTemplate;@Autowiredprivate UserService userService;@RequestMapping("/test")publicvoidtest(){ redisCacheTemplate.opsForValue().set("userkey", new User(1, "张三", 25)); User user = (User) redisCacheTemplate.opsForValue().get("userkey"); http://logger.info("当前获取对象:{}", user.toString()); }@RequestMapping("/add")publicvoidadd(){ User user = userService.save(new User(4, "李现", 30)); http://logger.info("添加的用户信息:{}",user.toString()); }@RequestMapping("/delete")publicvoiddelete(){ userService.delete(4); }@RequestMapping("/get/{id}")publicvoidget(@PathVariable("id") String idStr) throws Exception{if (StringUtils.isBlank(idStr)) {thrownew Exception("id为空"); } Integer id = Integer.parseInt(idStr); User user = userService.get(id); http://logger.info("获取的用户信息:{}",user.toString()); }}

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

@SpringBootApplication(exclude=DataSourceAutoConfiguration.class)@EnableCachingpublicclassApplication{publicstaticvoidmain(String[] args){ SpringApplication.run(Application.class, args); }}

①先调用添加接口:http://localhost:8082/user/add

②再调用查询接口,查询 id=4 的用户信息:

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

④再次调用查询接口,查询 id=4 的用户信息:

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

缓存注解

①@Cacheable

根据方法的请求参数对其结果进行缓存:

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

②@CachePut

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

③@CacheEvict

根据条件对缓存进行清空:

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

缓存问题

面试官:看了一下你的 Demo,简单易懂。那你在实际项目中使用缓存有遇到什么问题或者会遇到什么问题你知道吗?

我:缓存和数据库数据一致性问题:分布式环境下非常容易出现缓存和数据库间数据一致性问题,针对这一点,如果项目对缓存的要求是强一致性的,那么就不要使用缓存。

我们只能采取合适的策略来降低缓存和数据库间数据不一致的概率,而无法保证两者间的强一致性。

合适的策略包括合适的缓存更新策略,更新数据库后及时更新缓存、缓存失败时增加重试机制。

面试官:Redis 雪崩了解吗?

我:我了解的,目前电商首页以及热点数据都会去做缓存,一般缓存都是定时任务去刷新,或者查不到之后去更新缓存的,定时任务刷新就有一个问题。

举个栗子:如果首页所有 Key 的失效时间都是 12 小时,中午 12 点刷新的,我零点有个大促活动大量用户涌入,假设每秒 6000 个请求,本来缓存可以抗住每秒 5000 个请求,但是缓存中所有 Key 都失效了。

此时 6000 个/秒的请求全部落在了数据库上,数据库必然扛不住,真实情况可能 DBA 都没反应过来直接挂了。

此时,如果没什么特别的方案来处理,DBA 很着急,重启数据库,但是数据库立马又被新流量给打死了。这就是我理解的缓存雪崩。

我心想:同一时间大面积失效,瞬间 Redis 跟没有一样,那这个数量级别的请求直接打到数据库几乎是灾难性的。

你想想如果挂的是一个用户服务的库,那其他依赖他的库所有接口几乎都会报错。

如果没做熔断等策略基本上就是瞬间挂一片的节奏,你怎么重启用户都会把你打挂,等你重启好的时候,用户早睡觉去了,临睡之前,骂骂咧咧“什么垃圾产品”。

面试官摸摸了自己的头发:嗯,还不错,那这种情况你都是怎么应对的?

我:处理缓存雪崩简单,在批量往 Redis 存数据的时候,把每个 Key 的失效时间都加个随机值就好了,这样可以保证数据不会再同一时间大面积失效。

setRedis(key, value, time+Math.random()*10000);

如果 Redis 是集群部署,将热点数据均匀分布在不同的 Redis 库中也能避免全部失效。

或者设置热点数据永不过期,有更新操作就更新缓存就好了(比如运维更新了首页商品,那你刷下缓存就好了,不要设置过期时间),电商首页的数据也可以用这个操作,保险。

面试官:那你了解缓存穿透和击穿么,可以说说他们跟雪崩的区别吗?

我:嗯,了解,先说下缓存穿透吧,缓存穿透是指缓存和数据库中都没有的数据,而用户(黑客)不断发起请求。

举个栗子:我们数据库的 id 都是从 1 自增的,如果发起 id=-1 的数据或者 id 特别大不存在的数据,这样的不断攻击导致数据库压力很大,严重会击垮数据库。

我又接着说:至于缓存击穿嘛,这个跟缓存雪崩有点像,但是又有一点不一样,缓存雪崩是因为大面积的缓存失效,打崩了 DB。

而缓存击穿不同的是缓存击穿是指一个 Key 非常热点,在不停地扛着大量的请求,大并发集中对这一个点进行访问,当这个 Key 在失效的瞬间,持续的大并发直接落到了数据库上,就在这个 Key 的点上击穿了缓存。

面试官露出欣慰的眼光:那他们分别怎么解决?

我:缓存穿透我会在接口层增加校验,比如用户鉴权,参数做校验,不合法的校验直接 return,比如 id 做基础校验,id<=0 直接拦截。

面试官:那你还有别的方法吗?

我:我记得 Redis 里还有一个高级用法布隆过滤器(Bloom Filter)这个也能很好的预防缓存穿透的发生。

它的原理也很简单,就是利用高效的数据结构和算法快速判断出你这个 Key 是否在数据库中存在,不存在你 return 就好了,存在你就去查 DB 刷新 KV 再 return。

缓存击穿的话,设置热点数据永不过期,或者加上互斥锁就搞定了。作为暖男,代码给你准备好了,拿走不谢。

publicstatic String getData(String key)throws InterruptedException {//从Redis查询数据 String result = getDataByKV(key);//参数校验if (StringUtils.isBlank(result)) {try {//获得锁if (reenLock.tryLock()) {//去数据库查询 result = getDataByDB(key);//校验if (StringUtils.isNotBlank(result)) {//插进缓存 setDataToKV(key, result); } } else {//睡一会再拿 Thread.sleep(100L); result = getData(key); } } finally {//释放锁 reenLock.unlock(); } }return result; }

面试官:嗯嗯,还不错。

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 呢?

我:原因有如下四点:

存储方式上:Memcache 会把数据全部存在内存之中,断电后会挂掉,数据不能-超过内存大小。Redis 有部分数据存在硬盘上,这样能保证数据的持久性。数据支持类型上:Memcache 对数据类型的支持简单,只支持简单的 key-value,,而 Redis 支持五种数据类型。使用底层模型不同:它们之间底层实现方式以及与客户端之间通信的应用协议不一样。Redis 直接自己构建了 VM 机制,因为一般的系统调用系统函数的话,会浪费一定的时间去移动和请求。Value 的大小:Redis 可以达到 1GB,而 Memcache 只有 1MB。

淘汰策略

面试官:那你说说你知道的 Redis 的淘汰策略有哪些?

我:Redis 有六种淘汰策略,如下图:

  

 

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

持久化

面试官:你对 Redis 的持久化机制了解吗?能讲一下吗?

我:Redis 为了保证效率,数据缓存在了内存中,但是会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件中,以保证数据的持久化。

Redis 的持久化策略有两种:

RDB:快照形式是直接把内存中的数据保存到一个 dump 的文件中,定时保存,保存策略。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 中,配置方式如下:

appendfsyncyesappendfsync always #每次有数据修改发生时都会写入AOF文件。appendfsync everysec #每秒钟同步一次,该策略为AOF的缺省策略。

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 可用性。

从节点仅提供读操作,主节点提供写操作。对于读多写少的状况,可给主节点配置多个从节点,从而提高响应效率。

我顿了一下,接着说:关于复制过程,是这样的:

从节点执行 slaveof[masterIP][masterPort],保存主节点信息。从节点中的定时任务发现主节点信息,建立和主节点的 Socket 连接。从节点发送 Ping 信号,主节点返回 Pong,两边能互相通信。连接建立后,主节点将所有数据发送给从节点(数据同步)。主节点把当前的数据同步给从节点后,便完成了复制的建立过程。接下来,主节点就会持续的把写命令发送给从节点,保证主从数据一致性。

面试官:那你能详细说下数据同步的过程吗?

(我心想:这也问的太细了吧)我:可以。Redis 2.8 之前使用 sync[runId][offset] 同步命令,Redis 2.8 之后使用 psync[runId][offset] 命令。

两者不同在于,Sync 命令仅支持全量复制过程,Psync 支持全量和部分复制。

介绍同步之前,先介绍几个概念:

runId:每个 Redis 节点启动都会生成唯一的 uuid,每次 Redis 重启后,runId 都会发生变化。offset:主节点和从节点都各自维护自己的主从复制偏移量 offset,当主节点有写入命令时,offset=offset+命令的字节长度。从节点在收到主节点发送的命令后,也会增加自己的 offset,并把自己的 offset 发送给主节点。这样,主节点同时保存自己的 offset 和从节点的 offset,通过对比 offset 来判断主从节点数据是否一致。repl_backlog_size:保存在主节点上的一个固定长度的先进先出队列,默认大小是 1MB。

主节点发送数据给从节点过程中,主节点还会进行一些写操作,这时候的数据存储在复制缓冲区中。

从节点同步主节点数据完成后,主节点将缓冲区的数据继续发送给从节点,用于部分复制。

主节点响应写命令时,不但会把命名发送给从节点,还会写入复制积压缓冲区,用于复制命令丢失的数据补救。

上面是 Psync 的执行流程,从节点发送 psync[runId][offset] 命令,主节点有三种响应:

FULLRESYNC:第一次连接,进行全量复制CONTINUE:进行部分复制ERR:不支持 psync 命令,进行全量复制

面试官:很好,那你能具体说下全量复制和部分复制的过程吗?

我:可以!

上面是全量复制的流程。主要有以下几步:

从节点发送 psync ? -1 命令(因为第一次发送,不知道主节点的 runId,所以为?,因为是第一次复制,所以 offset=-1)。主节点发现从节点是第一次复制,返回 FULLRESYNC {runId} {offset},runId 是主节点的 runId,offset 是主节点目前的 offset。从节点接收主节点信息后,保存到 info 中。主节点在发送 FULLRESYNC 后,启动 bgsave 命令,生成 RDB 文件(数据持久化)。主节点发送 RDB 文件给从节点。到从节点加载数据完成这段期间主节点的写命令放入缓冲区。从节点清理自己的数据库数据。从节点加载 RDB 文件,将数据保存到自己的数据库中。如果从节点开启了 AOF,从节点会异步重写 AOF 文件。

关于部分复制有以下几点说明:

①部分复制主要是 Redis 针对全量复制的过高开销做出的一种优化措施,使用 psync[runId][offset] 命令实现。

当从节点正在复制主节点时,如果出现网络闪断或者命令丢失等异常情况时,从节点会向主节点要求补发丢失的命令数据,主节点的复制积压缓冲区将这部分数据直接发送给从节点。

这样就可以保持主从节点复制的一致性。补发的这部分数据一般远远小于全量数据。

②主从连接中断期间主节点依然响应命令,但因复制连接中断命令无法发送给从节点,不过主节点内的复制积压缓冲区依然可以保存最近一段时间的写命令数据。

③当主从连接恢复后,由于从节点之前保存了自身已复制的偏移量和主节点的运行 ID。因此会把它们当做 psync 参数发送给主节点,要求进行部分复制。

④主节点接收到 psync 命令后首先核对参数 runId 是否与自身一致,如果一致,说明之前复制的是当前主节点。

之后根据参数 offset 在复制积压缓冲区中查找,如果 offset 之后的数据存在,则对从节点发送+COUTINUE 命令,表示可以进行部分复制。因为缓冲区大小固定,若发生缓冲溢出,则进行全量复制。

⑤主节点根据偏移量把复制积压缓冲区里的数据发送给从节点,保证主从复制进入正常状态。

哨兵

面试官:那主从复制会存在哪些问题呢?

我:主从复制会存在以下问题:

一旦主节点宕机,从节点晋升为主节点,同时需要修改应用方的主节点地址,还需要命令所有从节点去复制新的主节点,整个过程需要人工干预。主节点的写能力受到单机的限制。主节点的存储能力受到单机的限制。原生复制的弊端在早期的版本中也会比较突出,比如:Redis 复制中断后,从节点会发起 psync。此时如果同步不成功,则会进行全量同步,主库执行全量备份的同时,可能会造成毫秒或秒级的卡顿。

面试官:那比较主流的解决方案是什么呢?

我:当然是哨兵啊。

面试官:那么问题又来了。那你说下哨兵有哪些功能?

我:如图,是 Redis Sentinel(哨兵)的架构图。Redis Sentinel(哨兵)主要功能包括主节点存活检测、主从运行情况检测、自动故障转移、主从切换。

Redis Sentinel 最小配置是一主一从。Redis 的 Sentinel 系统可以用来管理多个 Redis 服务器。

该系统可以执行以下四个任务:

监控:不断检查主服务器和从服务器是否正常运行。通知:当被监控的某个 Redis 服务器出现问题,Sentinel 通过 API 脚本向管理员或者其他应用程序发出通知。自动故障转移:当主节点不能正常工作时,Sentinel 会开始一次自动的故障转移操作,它会将与失效主节点是主从关系的其中一个从节点升级为新的主节点,并且将其他的从节点指向新的主节点,这样人工干预就可以免了。配置提供者:在 Redis Sentinel 模式下,客户端应用在初始化时连接的是 Sentinel 节点集合,从中获取主节点的信息。

面试官:那你能说下哨兵的工作原理吗?

我:话不多说,直接上图:

①每个 Sentinel 节点都需要定期执行以下任务:每个 Sentinel 以每秒一次的频率,向它所知的主服务器、从服务器以及其他的 Sentinel 实例发送一个 PING 命令。(如上图)

②如果一个实例距离最后一次有效回复 PING 命令的时间超过 down-after-milliseconds 所指定的值,那么这个实例会被 Sentinel 标记为主观下线。(如上图)

③如果一个主服务器被标记为主观下线,那么正在监视这个服务器的所有 Sentinel 节点,要以每秒一次的频率确认主服务器的确进入了主观下线状态。

④如果一个主服务器被标记为主观下线,并且有足够数量的 Sentinel(至少要达到配置文件指定的数量)在指定的时间范围内同意这一判断,那么这个主服务器被标记为客观下线。

⑤一般情况下,每个 Sentinel 会以每 10 秒一次的频率向它已知的所有主服务器和从服务器发送 INFO 命令。

当一个主服务器被标记为客观下线时,Sentinel 向下线主服务器的所有从服务器发送 INFO 命令的频率,会从 10 秒一次改为每秒一次。

⑥Sentinel 和其他 Sentinel 协商客观下线的主节点的状态,如果处于 SDOWN 状态,则投票自动选出新的主节点,将剩余从节点指向新的主节点进行数据复制。

⑦当没有足够数量的 Sentinel 同意主服务器下线时,主服务器的客观下线状态就会被移除。

当主服务器重新向 Sentinel 的 PING 命令返回有效回复时,主服务器的主观下线状态就会被移除。

面试官:不错,面试前没少下工夫啊,今天 Redis 这关你过了,明天找个时间我们再聊聊其他的。(露出欣慰的微笑)

我:没问题。

总结

本文在一次面试的过程中讲述了 Redis 是什么,Redis 的特点和功能,Redis 缓存的使用,Redis 为什么能这么快,Redis 缓存的淘汰策略,持久化的两种方式,Redis 高可用部分的主从复制和哨兵的基本原理。


点击全文阅读


本文链接:http://zhangshiyu.com/post/24633.html

节点  缓存  数据  
<< 上一篇 下一篇 >>

  • 评论(0)
  • 赞助本站

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。

关于我们 | 我要投稿 | 免责申明

Copyright © 2020-2022 ZhangShiYu.com Rights Reserved.豫ICP备2022013469号-1