Redis基本特性问答（面试题）

1.什么是Redis

	Redis(Remote Dictionary Server) 是一个使用 C 语言编写的，开源的（BSD许可）高性能非关系型（NoSQL）的键值对数据库。
	Redis 可以存储键和五种不同类型的值之间的映射。键的类型只能为字符串，值支持五种数据类型：字符串、列表、集合、散列表、有序集合。
	Redis 的数据是存在内存中的，所以读写速度非常快，被广泛应用于缓存方向，每秒可以处理超过 10万次读写操作，是已知性能最快的Key-Value DB。另外，Redis 也经常用来做分布式锁。除此之外，Redis 支持事务 、持久化、LUA脚本、LRU驱动事件、多种集群方案。

2.Redis有哪些优缺点

	**优点**

	1. 读写性能优异， Redis能读的速度是110000次/s，写的速度是81000次/s。
	2. 支持数据持久化，支持AOF和RDB两种持久化方式。
	3. 支持事务，Redis的所有操作都是原子性的，同时Redis还支持对几个操作合并后的原子性执行。
	4. 数据结构丰富，除了支持string类型的value外还支持hash、set、zset、list等数据结构。
	5. 支持主从复制，主机会自动将数据同步到从机，可以进行读写分离。

	**缺点**

	 1. 数据库容量受到物理内存的限制，不能用作海量数据的高性能读写，因此Redis适合的场景主要局限在较小数据量的高性能操作和运算上。
	 2. Redis 不具备自动容错和恢复功能，主机从机的宕机都会导致前端部分读写请求失败，需要等待机器重启或者手动切换前端的IP才能恢复。
	 3. 主机宕机，宕机前有部分数据未能及时同步到从机，切换IP后还会引入数据不一致的问题，降低了系统的可用性。
	4. Redis较难支持在线扩容，在集群容量达到上限时在线扩容会变得很复杂。为避免这一问题，运维人员在系统上线时必须确保有足够的空间，这对资源造成了很大的浪费。

3.为什么要用 Redis /为什么要用缓存

	高性能：直接操作内存，所以速度相当快
	高并发：数据库并发压力转移到缓存，缓存>>数据库并发能力

4.Redis为什么这么快

	1. 完全基于内存，绝大部分请求是纯粹的内存操作，非常快速
	2. 数据结构简单，对数据操作也简单，Redis 中的数据结构是专门进行设计的
	 3. 采用单线程，避免了不必要的上下文切换和竞争条件，也不存在多进程或者多线程导致的切换而消耗CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗
	 4. 使用多路 I/O 复用模型，非阻塞 IO
	5. 使用底层模型不同，它们之间底层实现方式以及与客户端之间通信的应用协议不一样，Redis 直接自己构建了 VM 机制，因为一般的系统调用系统函数的话，会浪费一定的时间去移动和请求

5.Redis有哪些数据类型

	5种主要数据类型：String，Hash，List，Set，Zset

5.1 数据类型有哪些性质/使用场景/操作命令（Linux环境下）

String （可存储字符串、整数或者浮点数）

	使用场景：做简单的键值对缓存
	特性：
	1. value部分是字符串。
	2. 底层存储数据都是字节(byte)数组, 所以可以保存任意数据。只是在表现上是字符串。
	3. value部分最多保存512M数据。
	4. Redis不限制数据的数量，可以存储无限制的数据，只要磁盘和内存足够大。

# 添加或修改
set [key] [value]
# 查询
get [key]
#批量新增或更新(如果数据中有空格,使用双引号界定范围)
mset [key1] [value1] [key2] [value2] [key3] [value3] ...
#批量查询
mget [key1] [key2] [key3] ...

哈希(hash)（包含键值对的无序散列表）

	使用场景：结构化的数据，比如一个对象
	特性：
 	1. 数据可以再次保存若干键值对.没有数量容量限制。redis中保存的数据就类似: Map<String,Map<String,String>>

#新增
hset [key] [field] [value]
#查询
hget [key] [field]
#删除
hdel [key] [field]
#批量新增(如果数据中有空格,使用双引号)
hmset [key] [field1] [value1] [field2] [value2]...
#批量查询(数据中有空格,使用双引号)
hmget [key] [field1] [field2] ...
#批量删除(数据中有空格,使用双引号)
hdel [key] [field1] [field2]...
#查询所有的fields
hkeys [key]
#查询所有的values
hvals [key]
#查询所有的fields-values
hgetall [key]
#检查field是否存在
hexists [key] [field]
#查询hash数据的field-value数据对数量
hlen [key]

链表(list)（列表）

	使用场景：存储一些列表型的数据结构，类似粉丝列表、文章的评论列表之类的数据
	特性：
	1. 有存储顺序. 底层使用链表实现的.
	2. 可以一个key对应若干数据, 数据可重复。类似: Map<String, List>

#将一个或多个值value插入到列表key的表头
lpush [key] [value]
#移除并返回列表key的头元素。
lpop [key]
#根据参数count的值，移除列表中与参数value相等的元素。
#count=0时，删除所有与参数value相等的元素
#count>0时，从左往右删除[count]与参数value相等的元素
#count<0时，从右往左删除[count]与参数value相等的元素
lrem [key] [count] [value]
#返回列表key的长度。
llen [key]
#返回列表key中,下标为index的元素
lindex [key] [index]
# 将列表key下标为index的元素的值设置为value
lset [key] [index] [value]
# 一个列表，包含指定区间内的元素
lrange [key] [start] [stop]

集合(set)（无序集合）

	使用场景：交集、并集、差集的操作，比如交集，可以把两个人的粉丝列表整一个交集
	特性：
	1. 底层使用Hash实现（保证数据唯一性）
	2. 可以一个key对应若干数据, 数据不可重复。类似: Map<String, Set>

#将一个或多个member元素加入到集合key当中，已经存在于集合的 member元素将被忽略
sadd [key] [member1] [member2]
#如果member元素是集合的成员，返回 1 。否则，返回 0
sismemeber [key] [member] ...
#移除并返回集合中的一个随机元素
spop [key]
#移除集合key中的一个或多个member元素，不存在的 member 元素会被忽略
srem [key] [member1] [member2] ...

有序集合(zset)（有序集合）

	使用场景：去重但可以排序，如获取排名前几名的用户
	特性：可排序的set。类似: Map<String, TreeSet>

#将一个或多个member元素及其score值加入到有序集key当中
zadd [key] [member]
#移除有序集key中的一个或多个成员，不存在的成员将被忽略
zrem [key] [member1], [member2] ...

5.2 数据使用场景总结

	1. 计数器：可以对 String 进行自增自减运算，从而实现计数器功能。Redis这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。
	2. 缓存热点数据：将热点数据放到内存中，设置内存的最大使用量以及淘汰策略来保证缓存的命中率。
	3. 消息队列(发布/订阅功能)：List 是一个双向链表，可以通过 lpush 和 rpop 写入和读取消息
	4. 分布式锁实现：使用 SETNX 命令实现分布式锁，还可以使用官方提供的 RedLock 分布式锁实现
	5. Set 可以实现交集、并集等操作，从而实现共同好友等功能
	6. ZSet 可以实现有序性操作，从而实现排行榜等功能。

	其他：
	string——适合最简单的k-v存储，短信验证码，配置信息等，就用这种类型来存储。
	hash——一般key为唯一标示，value对应的详情。如商品详情，个人信息详情，新闻详情等。
	list——因为list是有序的，比较适合存储一些有序且数据相对固定的数据。如省市区表、字典表等。因为list是有序的，适合根据写入的时间来排序，如：最新的***，消息队列等。
	set——可以简单的理解为ID-List的模式，如微博中一个人有哪些好友，set最牛的地方在于，可以对两个set提供交集、并集、差集操作。例如：查找两个人共同的好友等。
	Sorted Set——是set的增强版本，增加了一个score参数，自动会根据score的值进行排序。比较适合类似于top 10等不根据插入的时间来排序的数据。

6.Redis持久化机制是什么

	持久化就是把内存的数据写到磁盘中去，防止服务宕机了内存数据丢失
	提供两种持久化机制 RDB（默认，Redis DataBase） 和 AOF （Append Of File）机制

	RDB：一定的时间将内存的数据以快照的形式保存到硬盘中，生成一个dump.rdb数据文档（可通过配置文件中的save参数来定义快照的周期）
	优点:
	1、只有一个文件 dump.rdb，方便持久化。
	2、容灾性好，一个文件可以保存到安全的磁盘。
	3、性能最大化，fork 子进程来完成写操作，让主进程继续处理命令，所以是 IO 最大化。使用单独子进程来进行持久化，主进程不会进行任何 IO 操作，保证了 redis 的高性能
	4.相对于数据集大时，比 AOF 的启动效率更高。
	缺点：
	1.数据安全性低。RDB 是间隔一段时间进行持久化，如果持久化之间 redis 发生故障，会发生数据丢失。所以这种方式更适合数据要求不严谨的时候

	1). 将数据存储在一个dump.rdb的文件中。文件中保存的数据就是redis中的内存数据。dump.rdb文件保存的位置是启动redis服务时执行命令所在的目录。所以多次启动redis时，一定要在同一个位置启动服务，否则会有数据丢失。
	2). 效率高，对磁盘的访问比较合理，对内存数据的监控也是有一定临界值的，保证数据尽可能不丢失。在绝对意义上，只要是内存行存储数据的存储应用，就一定有数据丢失的可能。
	3). 配置rdb存储的相关信息，在redis.conf文件中配置

# 持久数据的规则. RDB持久规则. 存储数据的文件由dbfilename参数决定
save 900 1
save 300 10
save 60 10000
# RDB持久数据的文件命名. 可以使用绝对路径配置，如果没有路径配置，在命令运行的相对位置开始寻址存在。
dbfilename dump.rdb
#解说：save <指定时间间隔> <执行指定次数更新操作>
#满足条件就将内存中的数据同步到硬盘中。
#官方出厂配置默认是
#900秒内有1个更改，
#300秒内有10个更改
#60秒内有10000个更改
#则将内存中的数据快照写入磁盘。若不想用RDB方案，可以把 save "" 的注释打开，下面三个注释

	AOF(Apend Of File)持久化(推荐)
	优点：
	1.数据安全，aof 持久化可以配置 appendfsync 属性，有 always，每进行一次 命令操作就记录到 aof 文件中一次。
	2、通过 append 模式写文件，即使中途服务器宕机，可以通过 redis-check-aof 工具解决数据一致性问题。
	3、AOF 机制的 rewrite 模式。AOF 文件没被 rewrite 之前（文件过大时会对命令 进行合并重写），可以删除其中的某些命令（比如误操作的 flushall）)

	缺点：
	1、AOF 文件比 RDB 文件大，且恢复速度慢。
	2、数据集大的时候，比 rdb 启动效率低。

	1). 对磁盘和IO的资源需求比rdb方式高很多。对redis服务器的性能有很大的影响。
	2). Redis每秒钟以追加的方式，向一个文件中存储redis的数据变化。
	3). AOF和RDB可以同时开启，但是，在redis重启的时候，会优先读取aof中保存的数据变化日志。不推荐同时启用，对磁盘的压力和IO的压力太高。
	4).在redis.conf配置文件中配置aof相关信息。

# 是否启用append of file持久化方式.默认关闭.
# 每秒持久一次数据. 以追加的方式,持久到数据文件.
appendonly no

# aof持久方式的文件名称.
appendfilename "appendonly.aof"

7.Redis持久化数据和缓存怎么做扩容？

	如果Redis被当做缓存使用，使用一致性哈希实现动态扩容缩容。

	如果Redis被当做一个持久化存储使用，必须使用固定的keys-to-nodes映射关系，节点的数量一旦确定不能变化。否则的话(即Redis节点需要动态变化的情况），必须使用可以在运行时进行数据再平衡的一套系统，而当前只有Redis集群可以做到这样。

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

	定时过期：每个设置过期时间的key都需要创建一个定时器，到过期时间就会立即清除。该策略可以立即清除过期的数据，对内存很友好；但是会占用大量的CPU资源去处理过期的数据，从而影响缓存的响应时间和吞吐量。
	
	惰性过期：只有当访问一个key时，才会判断该key是否已过期，过期则清除。该策略可以最大化地节省CPU资源，却对内存非常不友好。极端情况可能出现大量的过期key没有再次被访问，从而不会被清除，占用大量内存。
	
	定期过期：每隔一定的时间，会扫描一定数量的数据库的expires字典中一定数量的key，并清除其中已过期的key。该策略是前两者的一个折中方案。通过调整定时扫描的时间间隔和每次扫描的限定耗时，可以在不同情况下使得CPU和内存资源达到最优的平衡效果。

8.Redis事务的概念

	通过MULTI、EXEC、WATCH等一组命令的集合，事务支持一次执行多个命令，一个事务中所有命令都会被序列化。在事务执行过程，会按照顺序串行化执行队列中的命令，其他客户端提交的命令请求不会插入到事务执行命令序列中。redis事务就是一次性、顺序性、排他性的执行一个队列中的一系列命令。

9.Redis事务相关命令

	Redis事务功能是通过MULTI、EXEC、DISCARD和WATCH 四个原语实现的
	
	Redis会将一个事务中的所有命令序列化，然后按顺序执行。
	
	redis 不支持回滚，“Redis 在事务失败时不进行回滚，而是继续执行余下的命令”， 所以 Redis 的内部可以保持简单且快速。
	
	如果在一个事务中的命令出现错误，那么所有的命令都不会执行；
	
	如果在一个事务中出现运行错误，那么正确的命令会被执行。
	
	WATCH 命令是一个乐观锁，可以为 Redis 事务提供 check-and-set （CAS）行为。 可以监控一个或多个键，一旦其中有一个键被修改（或删除），之后的事务就不会执行，监控一直持续到EXEC命令。
	
	MULTI命令用于开启一个事务，它总是返回OK。 MULTI执行之后，客户端可以继续向服务器发送任意多条命令，这些命令不会立即被执行，而是被放到一个队列中，当EXEC命令被调用时，所有队列中的命令才会被执行。
	
	EXEC：执行所有事务块内的命令。返回事务块内所有命令的返回值，按命令执行的先后顺序排列。 当操作被打断时，返回空值 nil 。
	
	通过调用DISCARD，客户端可以清空事务队列，并放弃执行事务， 并且客户端会从事务状态中退出。
	
	UNWATCH命令可以取消watch对所有key的监控。
	
	Redis的事务总是具有ACID中的一致性和隔离性，其他特性是不支持的。

10.生产环境中的 redis 是怎么部署的

	redis cluster，10 台机器，5 台机器部署了 redis 主实例，另外 5 台机器部署了 redis 的从实例，每个主实例挂了一个从实例，5 个节点对外提供读写服务，每个节点的读写高峰qps可能可以达到每秒 5 万，5 台机器最多是 25 万读写请求/s。
	
	机器是什么配置？32G 内存+ 8 核 CPU + 1T 磁盘，但是分配给 redis 进程的是10g内存，一般线上生产环境，redis 的内存尽量不要超过 10g，超过 10g 可能会有问题。
	5 台机器对外提供读写，一共有 50g 内存。
	因为每个主实例都挂了一个从实例，所以是高可用的，任何一个主实例宕机，都会自动故障迁移，redis 从实例会自动变成主实例继续提供读写服务。
	你往内存里写的是什么数据？每条数据的大小是多少？商品数据，每条数据是 10kb。100 条数据是 1mb，10 万条数据是 1g。常驻内存的是 200 万条商品数据，占用内存是 20g，仅仅不到总内存的 50%。目前高峰期每秒就是 3500 左右的请求量。
	其实大型的公司，会有基础架构的 team 负责缓存集群的运维。

11.说说Redis哈希槽的概念？

	Redis集群没有使用一致性hash,而是引入了哈希槽的概念，Redis集群有16384个哈希槽，每个key通过CRC16校验后对16384取模来决定放置哪个槽，集群的每个节点负责一部分hash槽。

12.Redis集群会有写操作丢失吗？为什么？

	Redis并不能保证数据的强一致性，这意味这在实际中集群在特定的条件下可能会丢失写操作。
	
	**Redis集群之间是如何复制的？** 异步复制
	**Redis集群最大节点个数是多少？**  16384个
	**Redis集群如何选择数据库？**  Redis集群目前无法做数据库选择，默认在0数据库。
	**Redis是单线程的，如何提高多核CPU的利用率？**
	
	可以在同一个服务器部署多个Redis的实例，并把他们当作不同的服务器来使用，在某些时候，无论如何一个服务器是不够的， 所以，如果你想使用多个CPU，你可以考虑一下分片（shard）。

13.为什么要做Redis分区？

	分区可以让Redis管理更大的内存，Redis将可以使用所有机器的内存。如果没有分区，你最多只能使用一台机器的内存。分区使Redis的计算能力通过简单地增加计算机得到成倍提升，Redis的网络带宽也会随着计算机和网卡的增加而成倍增长。

14.你知道有哪些Redis分区实现方案？

	客户端分区就是在客户端就已经决定数据会被存储到哪个redis节点或者从哪个redis节点读取。大多数客户端已经实现了客户端分区。
	代理分区 意味着客户端将请求发送给代理，然后代理决定去哪个节点写数据或者读数据。代理根据分区规则决定请求哪些Redis实例，然后根据Redis的响应结果返回给客户端。redis和memcached的一种代理实现就是Twemproxy查询路由(Query routing) 的意思是客户端随机地请求任意一个redis实例，然后由Redis将请求转发给正确的Redis节点。Redis Cluster实现了一种混合形式的查询路由，但并不是直接将请求从一个redis节点转发到另一个redis节点，而是在客户端的帮助下直接redirected到正确的redis节点。

15.Redis分区有什么缺点？

	涉及多个key的操作通常不会被支持。例如你不能对两个集合求交集，因为他们可能被存储到不同的Redis实例（实际上这种情况也有办法，但是不能直接使用交集指令）。
	同时操作多个key,则不能使用Redis事务.
	分区使用的粒度是key，不能使用一个非常长的排序key存储一个数据集（The partitioning granularity is the key, so it is not possible to shard a dataset with a single huge key like a very big sorted set）
	当使用分区的时候，数据处理会非常复杂，例如为了备份你必须从不同的Redis实例和主机同时收集RDB / AOF文件。
	分区时动态扩容或缩容可能非常复杂。Redis集群在运行时增加或者删除Redis节点，能做到最大程度对用户透明地数据再平衡，但其他一些客户端分区或者代理分区方法则不支持这种特性。然而，有一种预分片的技术也可以较好的解决这个问题。

分布式问题

16.Redis实现分布式锁

	Redis为单进程单线程模式，采用队列模式将并发访问变成串行访问，且多客户端对Redis的连接并不存在竞争关系Redis中可以使用SETNX命令实现分布式锁。
	当且仅当 key 不存在，将 key 的值设为 value。 若给定的 key 已经存在，则 SETNX 不做任何动作SETNX 是『SET if Not eXists』(如果不存在，则 SET)的简写。
	返回值：设置成功，返回 1 。设置失败，返回 0 。
	使用SETNX完成同步锁的流程及事项如下：
	使用SETNX命令获取锁，若返回0（key已存在，锁已存在）则获取失败，反之获取成功
	为了防止获取锁后程序出现异常，导致其他线程/进程调用SETNX命令总是返回0而进入死锁状态，需要为该key设置一个“合理”的过期时间
	释放锁，使用DEL命令将锁数据删除

17.如何解决 Redis 的并发竞争 Key 问题

	所谓 Redis 的并发竞争 Key 的问题也就是多个系统同时对一个 key 进行操作，但是最后执行的顺序和我们期望的顺序不同，这样也就导致了结果的不同！
	推荐一种方案：分布式锁（zookeeper 和 redis 都可以实现分布式锁）。（如果不存在 Redis 的并发竞争 Key 问题，不要使用分布式锁，这样会影响性能）
	基于zookeeper临时有序节点可以实现的分布式锁。大致思想为：每个客户端对某个方法加锁时，在zookeeper上的与该方法对应的指定节点的目录下，生成一个唯一的瞬时有序节点。 判断是否获取锁的方式很简单，只需要判断有序节点中序号最小的一个。 当释放锁的时候，只需将这个瞬时节点删除即可。同时，其可以避免服务宕机导致的锁无法释放，而产生的死锁问题。完成业务流程后，删除对应的子节点释放锁。在实践中，当然是从以可靠性为主。所以首推Zookeeper。

18.分布式Redis是前期做还是后期规模上来了再做好？为什么？

	既然Redis是如此的轻量（单实例只使用1M内存），为防止以后的扩容，最好的办法就是一开始就启动较多实例。即便你只有一台服务器，你也可以一开始就让Redis以分布式的方式运行，使用分区，在同一台服务器上启动多个实例。
	一开始就多设置几个Redis实例，例如32或者64个实例，对大多数用户来说这操作起来可能比较麻烦，但是从长久来看做这点牺牲是值得的。
	这样的话，当你的数据不断增长，需要更多的Redis服务器时，你需要做的就是仅仅将Redis实例从一台服务迁移到另外一台服务器而已（而不用考虑重新分区的问题）。一旦你添加了另一台服务器，你需要将你一半的Redis实例从第一台机器迁移到第二台机器。

19.什么是 RedLock

	Redis 官方站提出了一种权威的基于 Redis 实现分布式锁的方式名叫 Redlock，此种方式比原先的单节点的方法更安全。它可以保证以下特性：
	
	安全特性：互斥访问，即永远只有一个 client 能拿到锁
	
	避免死锁：最终 client 都可能拿到锁，不会出现死锁的情况，即使原本锁住某资源的 client crash 了或者出现了网络分区
	
	容错性：只要大部分 Redis 节点存活就可以正常提供服务

20.缓存雪崩

	缓存雪崩是指缓存同一时间大面积的失效，所以，后面的请求都会落到数据库上，造成数据库短时间内承受大量请求而崩掉。
	
	*解决方案*
	缓存数据的过期时间设置随机，防止同一时间大量数据过期现象发生。一般并发量不是特别多的时候，使用最多的解决方案是加锁排队。给每一个缓存数据增加相应的缓存标记，记录缓存的是否失效，如果缓存标记失效，则更新数据缓存。

21.缓存穿透

	缓存穿透是指缓存和数据库中都没有的数据，导致所有的请求都落到数据库上，造成数据库短时间内承受大量请求而崩掉。
	
	*解决方案*
	接口层增加校验，如用户鉴权校验，id做基础校验，id<=0的直接拦截；从缓存取不到的数据，在数据库中也没有取到，这时也可以将key-value对写为key-null，缓存有效时间可以设置短点，如30秒（设置太长会导致正常情况也没法使用）。这样可以防止攻击用户反复用同一个id暴力攻击采用布隆过滤器，将所有可能存在的数据哈希到一个足够大的 bitmap 中，一个一定不存在的数据会被这个 bitmap 拦截掉，从而避免了对底层存储系统的查询压力

22.缓存击穿

	缓存击穿是指缓存中没有但数据库中有的数据（一般是缓存时间到期），这时由于并发用户特别多，同时读缓存没读到数据，又同时去数据库去取数据，引起数据库压力瞬间增大，造成过大压力。和缓存雪崩不同的是，缓存击穿指并发查同一条数据，缓存雪崩是不同数据都过期了，很多数据都查不到从而查数据库。
	
	*解决方案*
	设置热点数据永远不过期。
	加互斥锁，互斥锁

23.缓存预热

	缓存预热就是系统上线后，将相关的缓存数据直接加载到缓存系统。这样就可以避免在用户请求的时候，先查询数据库，然后再将数据缓存的问题！用户直接查询事先被预热的缓存数据！
	*解决方案*
	直接写个缓存刷新页面，上线时手工操作一下；
	数据量不大，可以在项目启动的时候自动进行加载；
	定时刷新缓存；

24.缓存降级

	当访问量剧增、服务出现问题（如响应时间慢或不响应）或非核心服务影响到核心流程的性能时，仍然需要保证服务还是可用的，即使是有损服务。系统可以根据一些关键数据进行自动降级，也可以配置开关实现人工降级。
	缓存降级的最终目的是保证核心服务可用，即使是有损的。而且有些服务是无法降级的（如加入购物车、结算）。
	在进行降级之前要对系统进行梳理，看看系统是不是可以丢卒保帅；从而梳理出哪些必须誓死保护，哪些可降级；比如可以参考日志级别设置预案：
	一般：比如有些服务偶尔因为网络抖动或者服务正在上线而超时，可以自动降级；
	警告：有些服务在一段时间内成功率有波动（如在95~100%之间），可以自动降级或人工降级，并发送告警；
	错误：比如可用率低于90%，或者数据库连接池被打爆了，或者访问量突然猛增到系统能承受的最大阀值，此时可以根据情况自动降级或者人工降级；
	严重错误：比如因为特殊原因数据错误了，此时需要紧急人工降级。
	服务降级的目的，是为了防止Redis服务故障，导致数据库跟着一起发生雪崩问题。因此，对于不重要的缓存数据，可以采取服务降级策略，例如一个比较常见的做法就是，Redis出现问题，不去数据库查询，而是直接返回默认值给用户。
	热点数据和冷数据
	热点数据，缓存才有价值
	对于冷数据而言，大部分数据可能还没有再次访问到就已经被挤出内存，不仅占用内存，而且价值不大。频繁修改的数据，看情况考虑使用缓存
	对于热点数据，比如我们的某IM产品，生日祝福模块，当天的寿星列表，缓存以后可能读取数十万次。再举个例子，某导航产品，我们将导航信息，缓存以后可能读取数百万次。
	数据更新前至少读取两次，缓存才有意义。这个是最基本的策略，如果缓存还没有起作用就失效了，那就没有太大价值了。
	那存不存在，修改频率很高，但是又不得不考虑缓存的场景呢？有！比如，这个读取接口对数据库的压力很大，但是又是热点数据，这个时候就需要考虑通过缓存手段，减少数据库的压力，比如我们的某助手产品的，点赞数，收藏数，分享数等是非常典型的热点数据，但是又不断变化，此时就需要将数据同步保存到Redis缓存，减少数据库压力。

25.缓存热点key

	缓存中的一个Key(比如一个促销商品)，在某个时间点过期的时候，恰好在这个时间点对这个Key有大量的并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。
	*解决方案*
	对缓存查询加锁，如果KEY不存在，就加锁，然后查DB入缓存，然后解锁；其他进程如果发现有锁就等待，然后等解锁后返回数据或者进入DB查询

常用工具

Redis支持的Java客户端都有哪些？官方推荐用哪个？

	Redisson、Jedis、lettuce等等，官方推荐使用Redisson。

26.Redis和Redisson有什么关系？

	Redisson是一个高级的分布式协调Redis客服端，能帮助用户在分布式环境中轻松实现一些Java的对象
	 (Bloom filter, BitSet, Set, SetMultimap, ScoredSortedSet, SortedSet, Map, ConcurrentMap, List, 
	 ListMultimap, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, ReadWriteLock, 
	 AtomicLong, CountDownLatch, Publish / Subscribe, HyperLogLog)。

27.Jedis与Redisson对比有什么优缺点？

	Jedis是Redis的Java实现的客户端，其API提供了比较全面的Redis命令的支持；
	Redisson实现了分布式和可扩展的Java数据结构，和Jedis相比，功能较为简单，不支持字符串操作，不支持排序、事务、管道、分区等Redis特性。
	Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。

28.如何保证缓存与数据库双写时的数据一致性？

	你只要用缓存，就可能会涉及到缓存与数据库双存储双写，你只要是双写，就一定会有数据一致性的问题，那么你如何解决一致性问题？
	一般来说，就是如果你的系统不是严格要求缓存+数据库必须一致性的话，缓存可以稍微的跟数据库偶尔有不一致的情况，最好不要做这个方案，
	读请求和写请求串行化，串到一个内存队列里去，这样就可以保证一定不会出现不一致的情况
	串行化之后，就会导致系统的吞吐量会大幅度的降低，用比正常情况下多几倍的机器去支撑线上的一个请求。
	还有一种方式就是可能会暂时产生不一致的情况，但是发生的几率特别小，就是先更新数据库，然后再删除缓存。

29.Redis常见性能问题和解决方案？

	Master最好不要做任何持久化工作，包括内存快照和AOF日志文件，特别是不要启用内存快照做持久化。
	如果数据比较关键，某个Slave开启AOF备份数据，策略为每秒同步一次。
	为了主从复制的速度和连接的稳定性，Slave和Master最好在同一个局域网内。
	尽量避免在压力较大的主库上增加从库
	Master调用BGREWRITEAOF重写AOF文件，AOF在重写的时候会占大量的CPU和内存资源，导致服务load过高，出现短暂服务暂停现象。
	为了Master的稳定性，主从复制不要用图状结构，用单向链表结构更稳定，即主从关系为：Master<–Slave1<–Slave2<–Slave3…，
	这样的结构也方便解决单点故障问题，实现Slave对Master的替换，也即，如果Master挂了，可以立马启用Slave1做Master，其他不变。

30.Redis如何做大量数据插入？

Redis2.6开始redis-cli支持一种新的被称之为pipe mode的新模式用于执行大量数据插入工作。

31.假如Redis里面有1亿个key，其中有10w个key是以某个固定的已知的前缀开头的，如果将它们全部找出来？

	使用keys指令可以扫出指定模式的key列表。
	对方接着追问：如果这个redis正在给线上的业务提供服务，那使用keys指令会有什么问题？
	这个时候你要回答redis关键的一个特性：redis的单线程的。keys指令会导致线程阻塞一段时间，线上服务会停顿，
	直到指令执行完毕，服务才能恢复。这个时候可以使用scan指令，scan指令可以无阻塞的提取出指定模式的key列表，
	但是会有一定的重复概率，在客户端做一次去重就可以了，但是整体所花费的时间会比直接用keys指令长。

32.使用Redis做过异步队列吗，是如何实现的

	使用list类型保存数据信息，rpush生产消息，lpop消费消息，当lpop没有消息时，可以sleep一段时间，
	然后再检查有没有信息，如果不想sleep的话，可以使用blpop, 在没有信息的时候，会一直阻塞，直到信息的到来。
	redis可以通过pub/sub主题订阅模式实现一个生产者，多个消费者，
	当然也存在一定的缺点，当消费者下线时，生产的消息会丢失。

33.Redis如何实现延时队列

	使用sortedset，使用时间戳做score, 消息内容作为key,调用zadd来生产消息，
	消费者使用zrangbyscore获取n秒之前的数据做轮询处理。

34.Redis回收进程如何工作的？

	一个客户端运行了新的命令，添加了新的数据。
	Redis检查内存使用情况，如果大于maxmemory的限制， 则根据设定好的策略进行回收。
	一个新的命令被执行，等等。
	所以我们不断地穿越内存限制的边界，通过不断达到边界然后不断地回收回到边界以下。
	如果一个命令的结果导致大量内存被使用（例如很大的集合的交集保存到一个新的键），
	不用多久内存限制就会被这个内存使用量超越。

35.Redis回收使用的是什么算法

	LRU算法