一、常用五大数据类型及其数据结构

redis常见数据类型操作命令http://www.redis.cn/commands.html

1.Redis键(key)常见命令操作

keys *查看当前库所有key

exists key判断某个key是否存在

type key 查看你的key是什么类型

del key 删除指定的key数据(后根据keys *查看k1已经不存在)

unlink key 根据value选择非阻塞删除仅将keys从keyspace元数据中删除，真正的删除会在后续异步操作。

expire key 10 10秒钟：为给定的key设置过期时间
ttl key 查看还有多少秒过期，-1表示永不过期，-2表示已过期
过期后通过keys *查看库为空

dbsize查看当前数据库的key的数量

flushdb清空当前库

select命令切换数据库
flushall通杀全部库

2.1 Redis字符串(String)

String是Redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。
String类型是二进制安全的。意味着Redis的string可以包含任何数据。比如jpg图片或者序列化的对象。
String类型是Redis最基本的数据类型，一个Redis中字符串value最多可以是512M

2.1.1 常用命令
set key value 添加键值对(再次set相同key则 value就将被覆盖)

*NX：当数据库中key不存在时，可以将key-value添加数据库
*XX：当数据库中key存在时，可以将key-value添加数据库，与NX参数互斥
*EX：key的超时秒数
*PX：key的超时毫秒数，与EX互斥
get key查询对应键值
append key value将给定的value追加到原值的末尾
strlen key 获得值的长度
setnx key value只有在 key 不存在时设置key的值
(integer) 0表示设置不成功

incr key 将 key 中储存的数字值增1只能对数字值操作，如果为空，新增值为1

decr key 将 key 中储存的数字值减1只能对数字值操作，如果为空，新增值为-1

incrby / decrby key 步长将 key 中储存的数字值增减。自定义步长。

getrange key 起始位置 结束位置 获得值的范围，类似java中的substring，前包，后包

setrange key 起始位置 value用 value覆写key所储存的字符串值，从 起始位置 开始(索引从0开始)。

setex key 过期时间value设置键值的同时，设置过期时间，单位秒。

getset key value以新换旧，设置了新值同时获得旧值。

String的数据结构为简单动态字符串(Simple Dynamic String,缩写SDS)。是可以修改的字符串，内部结构实现上类似于Java的ArrayList，采用预分配冗余空间的方式来减少内存的频繁分配.

如图中所示，内部为当前字符串实际分配的空间capacity一般要高于实际字符串长度len。当字符串长度小于1M时，扩容都是加倍现有的空间，如果超过1M，扩容时一次只会多扩1M的空间。需要注意的是字符串最大长度为512M。
应用场景：计数的场景，用户的访问次数、热点文章的点赞转发数量

2.2 Redis列表(List)

2.2.1 简介
单键多值
Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部(左边)或者尾部(右边)它的底层实际是个双向链表，对两端的操作性能很高，通过索引下标的操作中间的节点性能会较差。

2.2.2 常用命令
lpush/rpush key value1 value2 value3 从左边/右边插入一个或多个值。

lpop/rpop key从左边/右边吐出一个值。值在键在，值光键亡。

rpoplpush key1 key2从 key1列表右边吐出一个值，插到 key2列表左边。
lrange key start stop
按照索引下标获得元素(从左到右)
lrange k1 0 -1 0左边第一个，-1右边第一个，（0-1表示获取所有）
lindex key index按照索引下标获得元素(从左到右)
llen key获得列表长度
linsert key before value newvalue在value的后面插入newvalue插入值
lrem key n value从左边删除n个value(从左到右)
lset key index value将列表key下标为index的值替换成value

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> keys *
(empty array)
127.0.0.1:6379> lpush k1 v1 v2 v3
(integer) 3
127.0.0.1:6379> rpush k2 v11 v12 v13
(integer) 3
127.0.0.1:6379> rpoplpush k1 k2
"v1"
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "v11"
3) "v12"
4) "v13"
127.0.0.1:6379> lindex k2 2
"v12"
127.0.0.1:6379> llen k2
(integer) 4
127.0.0.1:6379> linsert k2 before "v11" "newv11"
(integer) 5
127.0.0.1:6379> lrange k2 0 -1 
1) "v1"
2) "newv11"
3) "v11"
4) "v12"
5) "v13"
127.0.0.1:6379> linsert k2 before "v12" "newv12"
(integer) 6
127.0.0.1:6379> linsert k2 before "v13" "newv13"
(integer) 7
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "newv11"
3) "v11"
4) "newv12"
5) "v12"
6) "newv13"
7) "v13"
127.0.0.1:6379> lrem k2 1 "newv11"
(integer) 1
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "v11"
3) "newv12"
4) "v12"
5) "newv13"
6) "v13"
127.0.0.1:6379> lset k2 1 athuigu
OK
127.0.0.1:6379> lrange k2 0 -1
1) "v1"
2) "athuigu"
3) "newv12"
4) "v12"
5) "newv13"
6) "v13"
127.0.0.1:6379> 

2.2.3 数据结构
List的数据结构为快速链表quickList。首先在列表元素较少的情况下会使用一块连续的内存存储，这个结构是ziplist，也即是压缩列表。它将所有的元素紧挨着一起存储，分配的是一块连续的内存。当数据量比较多的时候才会改成quicklist。因为普通的链表需要的附加指针空间太大，会比较浪费空间。比如这个列表里存的只是int类型的数据，结构上还需要两个额外的指针prev和next。

Redis将链表和ziplist结合起来组成了quicklist。也就是将多个ziplist使用双向指针串起来使用。这样既满足了快速的插入删除性能，又不会出现太大的空间冗余
应用场景：发布与订阅或者说消息队列、慢查询。

2.3 Redis集合(Set)

2.3.1 简介
Redis set对外提供的功能与list类似是一个列表的功能，特殊之处在于set是可以自动排重的，当你需要存储一个列表数据，又不希望出现重复数据时，set是一个很好的选择，并且set提供了判断某个成员是否在一个set集合内的重要接口，这个也是list所不能提供的。
Redis的Set是string类型的无序集合。它底层其实是一个value为null的hash表，所以添加，删除，查找的复杂度都是O(1)。一个算法，随着数据的增加，执行时间的长短，如果是O(1)，数据增加，查找数据的时间不变

2.3.2 常用命令

sadd key value1 value2 将一个或多个 member 元素加入到集合 key 中，已经存在的 member 元素将被忽略
smembers key取出该集合的所有值。
sismember key value判断集合 key是否为含有该value值，有1，没有0
scard key返回该集合的元素个数。
srem key value1 value2 删除集合中的某个元素。
spop key 随机从该集合中吐出一个值。
srandmember key n随机从该集合中取出n个值。不会从集合中删除 。
smove source destination value把集合中一个值从一个集合移动到另一个集合
sinter key1 key2返回两个集合的交集元素。
sunion key1 key2返回两个集合的并集元素。
sdiff key1 key2返回两个集合的差集元素(key1中的，不包含key2中的)

127.0.0.1:6379> flushdb
OK
127.0.0.1:6379> sadd k1 v1 v2 v3
(integer) 3
127.0.0.1:6379> smembers k1
1) "v3"
2) "v2"
3) "v1"
127.0.0.1:6379> sismember k1 v1
(integer) 1
127.0.0.1:6379> sismember k1 v4
(integer) 0
127.0.0.1:6379> srem k1 v1 v2
(integer) 2
127.0.0.1:6379> smembers k1
1) "v3"
127.0.0.1:6379> sadd k2 v1 v2 v3 v4
(integer) 4
127.0.0.1:6379> spop k2
"v2"
127.0.0.1:6379> spop k2
"v4"
127.0.0.1:6379> srandmember k2 2
1) "v3"
2) "v1"
127.0.0.1:6379> smembers k1
1) "v33"
2) "v11"
3) "v22"
127.0.0.1:6379> smembers k2
1) "v3"
2) "v2"
3) "v4"
4) "v1"
127.0.0.1:6379> smove k1 k2 v11
(integer) 1
127.0.0.1:6379> smembers k2
1) "v3"
2) "v2"
3) "v4"
4) "v1"
5) "v11"
127.0.0.1:6379> sadd k1 v1
(integer) 1
127.0.0.1:6379> smembers k1
1) "v33"
2) "v22"
3) "v1"
127.0.0.1:6379> sinter k1 k2
1) "v1"
127.0.0.1:6379> sunion k1 k2
1) "v33"
2) "v2"
3) "v11"
4) "v3"
5) "v22"
6) "v4"
7) "v1"
127.0.0.1:6379> sdiff k1 k2
1) "v22"
2) "v33"

3.3.3 数据结构
Set数据结构是dict字典，字典是用哈希表实现的。Java中HashSet的内部实现使用的是HashMap，只不过所有的value都指向同一个对象。Redis的set结构也是一样，它的内部也使用hash结构，所有的value都指向同一个内部值。
使用场景：数据不重复+可以判断一个成员是否存在+交集并集（共同关注、粉丝，两个集合求交集）

2.4 Redis哈希(Hash)

2.4.1 简介
Redis hash 是一个键值对集合。
Redis hash是一个string类型的field和value的映射表，hash特别适合用于存储对象。类似Java里面的Map<String,Object>用户ID为查找的key，存储的value用户对象包含姓名，年龄，生日等信息，如果用普通的key/value结构来存储主要有以下2种存储方式：

通过 key(用户ID) + field(属性标签) 就可以操作对应属性数据了，既不需要重复存储数据，也不会带来序列化和并发修改控制的问题

2.4.2 常用命令
hset key field value给key集合中的field键赋值value
hget key1 field从key1集合field取出 value
hmset key1 field value1 field value2 批量设置hash的值
hexists key1 field查看哈希表 key 中，给定域 field 是否存在。
hkeys key1列出该hash集合的所有field
hvals key1列出该hash集合的所有value
hincrby key1 field increment为哈希表 key 中的域 field 的值加上增量 1 -1
hsetnx key1 field value将哈希表 key 中的域 field 的值设置为 value ，当且仅当域 field 不存在

127.0.0.1:6379> hset user:1001 id 1
(integer) 1
127.0.0.1:6379> hset user:1001 name zhangsan
(integer) 1
127.0.0.1:6379> hget user:1001 id
"1"
127.0.0.1:6379> hget user:1001 name
"zhangsan"
127.0.0.1:6379> hmset user:1002 id 2 name lisha age 22
OK
127.0.0.1:6379> hexists user:1002 id
(integer) 1
127.0.0.1:6379> hexists user:1002 name 
(integer) 1
127.0.0.1:6379> hexists user:1002 gender
(integer) 0
127.0.0.1:6379> hkeys user:1002
1) "id"
2) "name"
3) "age"
127.0.0.1:6379> hvals user:1002
1) "2"
2) "lisha"
3) "22"
127.0.0.1:6379> hincrby user:1002 age 2
(integer) 24
127.0.0.1:6379> hsetnx user:1002 age 23
(integer) 0
127.0.0.1:6379> hsetnx user:1002 gender 1
(integer) 1
127.0.0.1:6379> 

2.4.3 数据结构
Hash类型对应的数据结构是两种：ziplist（压缩列表），hashtable（哈希表）。当field-value长度较短且个数较少时，使用ziplist，否则使用hashtable。

2.5 Redis有序集合Zset(sorted set)

2.5.1 简介
Redis有序集合zset与普通集合set非常相似，是一个没有重复元素的字符串集合。
不同之处是有序集合的每个成员都关联了一个评分（score）,这个评分（score）被用来按照从最低分到最高分的方式排序集合中的成员。集合的成员是唯一的，但是评分可以是重复了。因为元素是有序的, 所以你也可以很快的根据评分（score）或者次（position）来获取一个范围的元素。访问有序集合的中间元素也是非常快的,因此你能够使用有序集合作为一个没有重复成员的智能列表
2.5.2 常见命令
1.zadd key score1 value1 score2 value2 …将一个或多个 member 元素及其 score 值加入到有序集 key 当中。
2.zrange key start stop [WITHSCORES]返回有序集 key 中，下标在 start stop之间的元素带WITHSCORES，可以让分数一起和值返回到结果集。
3.zrangebyscore key minmax [withscores] [limit offset count]中，所有 score 值介于 min 和 max 之间(包括等于 min 或 max )的成员。有序集成员按 score 值递增(从小到大)次序排列。
4.zrevrangebyscore key maxmin [withscores] [limit offset count] 同上，改为从大到小排列。
5.zincrby key increment value 为元素的score加上增量
6.zrem key value 删除该集合下，指定值的元素
7.zcount key min max统计该集合，分数区间内的元素个数
8.zrank key value 返回该值在集合中的排名，从0开始,所以mysql为第三名
9.案例：如何利用zset实现一个文章访问量的排行榜？

127.0.0.1:6379> zadd topn 200 java 300 C++ 400 mysql 500 PHP
(integer) 4
127.0.0.1:6379> zrange topn 0 -1 withscores
1) "java"
2) "200"
3) "C++"
4) "300"
5) "mysql"
6) "400"
7) "PHP"
8) "500"
127.0.0.1:6379> zrangebyscore topn 300 500 withscores
1) "C++"
2) "300"
3) "mysql"
4) "400"
5) "PHP"
6) "500"
127.0.0.1:6379> zrevrangebyscore topn 500 200 withscores
1) "PHP"
2) "500"
3) "mysql"
4) "400"
5) "C++"
6) "300"
7) "java"
8) "200"
127.0.0.1:6379> zincrby topn 50 java
"250"
127.0.0.1:6379> zrem topn PHP
(integer) 1
127.0.0.1:6379> zrevrangebyscore topn 500 200 withscores
1) "mysql"
2) "400"
3) "C++"
4) "300"
5) "java"
6) "250"
127.0.0.1:6379> zrank topn java
(integer) 0
127.0.0.1:6379> zcount topn 200 400
(integer) 3
127.0.0.1:6379> zadd top 1000 v1 2000 v2 3000 v3
(integer) 3
127.0.0.1:6379> zrevrange top 0 9withscores
(error) ERR value is not an integer or out of range
127.0.0.1:6379> zrevrange top 0 9 withscores
1) "v3"
2) "3000"
3) "v2"
4) "2000"
5) "v1"
6) "1000"
127.0.0.1:6379> 

2.5.3 数据结构
SortedSet(zset)是Redis提供的一个非常特别的数据结构，一方面它等价于Java的数据结构Map<String, Double>，可以给每一个元素value赋予一个权重score，另一方面它又类似于TreeSet，内部的元素会按照权重score进行排序，可以得到每个元素的名次，还可以通过score的范围来获取元素的列表。
zset底层使用了两个数据结构
（1）hash，hash的作用就是关联元素value和权重score，保障元素value的唯一性，可以通过元素value找到相应的score值。
（2）跳跃表，跳跃表的目的在于给元素value排序，根据score的范围获取元素列表。

跳跃表（跳表）
1、简介
有序集合在生活中比较常见，例如根据成绩对学生排名，根据得分对玩家排名等。对于有序集合的底层实现，可以用数组、平衡树、链表等。数组不便元素的插入、删除；平衡树或红黑树虽然效率高但结构复杂；链表查询需要遍历所有效率低。Redis采用的是跳跃表。跳跃表效率堪比红黑树，实现远比红黑树简单。
2、实例
对比有序链表和跳跃表，从链表中查询出51
(1)有序链表

要查找值为51的元素，需要从第一个元素开始依次查找、比较才能找到。共需要6次比较。
(2)跳跃表

从第2层开始，1节点比51节点小，向后比较。
21节点比51节点小，继续向后比较，后面就是NULL了，所以从21节点向下到第1层
在第1层，41节点比51节点小，继续向后，61节点比51节点大，所以从41向下
在第0层，51节点为要查找的节点，节点被找到，共查找4次。
从此可以看出跳跃表比有序链表效率要高

二、常见面试题总结

2.1 什么是Redis?

Redis 是一个使用 C 语言写成的，开源的高性能key-value非关系缓存数据库。它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。Redis的数据都基于缓存的，所以很快，每秒可以处理超过 10万次读写操作，是已知性能最快的Key-Value DB。Redis也可以实现数据写入磁盘中，保证了数据的安全不丢失(持久化)，而且Redis的操作是原子性的。

2.2 Redis有哪些优缺点?

优点:
1.读写性能优异， Redis能读的速度是110000次/s，写的速度是81000次/s。
2.支持数据持久化，支持AOF和RDB两种持久化方式。
3.支持事务，Redis的所有操作都是原子性的，同时Redis还支持对几个操作合并后的原子性执行。
4.数据结构丰富，除了支持string类型的value外还支持hash、set、zset、list等数据结构(redis 6出现新的数据类型Bitmaps HyperLogLog Geospatial)。
5.支持主从复制，主机会自动将数据同步到从机，可以进行读写分离。
缺点:
1.数据库容量受到物理内存的限制，不能用作海量数据的高性能读写，因此Redis适合的场景主要局限在较小数据量的高性能操作和运算上。
2.Redis 不具备自动容错和恢复功能，主机从机的宕机都会导致前端部分读写请求失败，需要等待机器重启或者手动切换前端的IP才能恢复。
3.主机宕机，宕机前有部分数据未能及时同步到从机，切换IP后还会引入数据不一致的问题，降低了系统的可用性。
4.Redis 较难支持在线扩容，在集群容量达到上限时在线扩容会变得很复杂。为避免这一问题，运维人员在系统上线时必须确保有足够的空间，这对资源造成了很大的浪费。

2.3 为什么要用Redis/为什么要用缓存?

主要从“高性能”和“高并发”这两点来看待这个问题。
高性能:
假如用户第一次访问数据库中的某些数据。这个过程会比较慢，因为是从硬盘上读取的。将该用户访问的数据存在数缓存中，这样下一次再访问这些数据的时候就可以直接从缓存中获取了。操作缓存就是直接操作内存，所以速度相当快。如果数据库中的对应数据改变的之后，同步改变缓存中相应的数据即可！
高并发:
直接操作缓存能够承受的请求是远远大于直接访问数据库的，所以我们可以考虑把数据库中的部分数据转移到缓存中去，这样用户的一部分请求会直接到缓存这里而不用经过数据库。

2.4 Redis为什么这么快?

1.完全基于内存，绝大部分请求是纯粹的内存操作，非常快速。数据存在内存中，类似于 HashMap，HashMap 的优势就是查找和操作的时间复杂度都是O(1)；
2.数据结构简单，对数据操作也简单，Redis 中的数据结构是专门进行设计的；
3.采用单线程，避免了不必要的上下文切换和竞争条件，也不存在多进程或者多线程导致的切换而消耗 CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗；
4.使用多路 I/O 复用模型，非阻塞 IO效率高；

2.5 Redis有哪些数据类型?

Redis主要有5种数据类型，包括String，List，Set，Zset，Hash满足大部分的使用要求。(redis 6出现新的数据类型Bitmaps HyperLogLog Geospatial)。

2.6 Redis的应用场景?

1.计数器。可以对 String 进行自增自减运算，从而实现计数器功能。Redis 这种内存型数据库的读写性能非常高，很适合存储频繁读写的计数量。
2.缓存。将热点数据放到内存中，设置内存的最大使用量以及淘汰策略来保证缓存的命中率。
3.会话缓存。可以使用 Redis 来统一存储多台应用服务器的会话信息。当应用服务器不再存储用户的会话信息，也就不再具有状态，一个用户可以请求任意一个应用服务器，从而更容易实现高可用性以及可伸缩性。
4.分布式锁实现。在分布式场景下，无法使用单机环境下的锁来对多个节点上的进程进行同步。可以使用 Redis 自带的 SETNX 命令实现分布式锁，除此之外，还可以使用官方提供的 RedLock 分布式锁实现。
5.消息队列(发布/订阅功能)。List 是一个双向链表，可以通过 lpush 和 rpop 写入和读取消息。不过最好使用 Kafka、RabbitMQ 等消息中间件。
6.查找表。例如 DNS 记录就很适合使用 Redis 进行存储。查找表和缓存类似，也是利用了 Redis 快速的查找特性。但是查找表的内容不能失效，而缓存的内容可以失效，因为缓存不作为可靠的数据来源。

2.7 Redis的持久化方式？优缺点？

什么是Redis持久化？
持久化就是把内存的数据写到磁盘中去，防止服务宕机了内存数据丢失。
Redis 提供两种持久化机制 RDB（默认） 和 AOF 机制
RDB是Redis默认的持久化方式。按照一定的时间将内存的数据以快照的形式保存到硬盘中，对应产生的数据文件为dump.rdb。通过配置文件中的save参数来定义快照的周期。

优点：
1.只有一个文件 dump.rdb，方便持久化。
2.容灾性好，一个文件可以保存到安全的磁盘。
3.性能最大化，fork 子进程来完成写操作，让主进程继续处理命令，所以是 IO 最大化。4.使用单独子进程来进行持久化，主进程不会进行任何 IO 操作，保证了 redis 的高性能。相对于数据集大时，比 AOF 的启动效率更高。

缺点：
1.数据安全性低。RDB 是间隔一段时间进行持久化，如果持久化之间 redis 发生故障，会发生数据丢失。所以这种方式更适合数据要求不严谨的时候)
2.AOF（Append-only file)持久化方式：是指所有的命令行记录以 redis 命令请 求协议的格式完全持久化存储)保存为 aof 文件。
3.AOF：持久化。AOF持久化(即Append Only File持久化)，则是将Redis执行的每次写命令记录到单独的日志文件中，当重启Redis会重新将持久化的日志中文件恢复数据。当两种方式同时开启时，数据恢复Redis会优先选择AOF恢复。

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

缺点：
1.AOF 文件比 RDB 文件大，且恢复速度慢。
2.数据集大的时候，比 rdb 启动效率低。
俩种持久化的优缺点是什么？
AOF文件比RDB更新频率高，优先使用AOF还原数据。
AOF比RDB更安全也更大。
RDB性能比AOF好。
如果两个都配了优先加载AOF。

2.8 Redis的过期键的删除策略?

我们都知道，Redis是基于内存的key-value数据库，我们可以设置Redis中缓存的key的过期时间。Redis的过期策略就是指当Redis中缓存的key过期了，Redis如何处理。
过期策略通常有以下三种：
定时过期： 每个设置过期时间的key都需要创建一个定时器，到过期时间就会立即清除。该策略可以立即清除过期的数据，对内存很友好；但是会占用大量的CPU资源去处理过期的数据，从而影响缓存的响应时间和吞吐量。
惰性过期： 只有当访问一个key时，才会判断该key是否已过期，过期则清除。该策略可以最大化地节省CPU资源，却对内存非常不友好。极端情况可能出现大量的过期key没有再次被访问，从而不会被清除，占用大量内存。
定期过期： 每隔一定的时间，会扫描 expires 字典中一定数量的key，并清除其中已过期的key。该策略是前两者的一个折中方案。通过调整定时扫描的时间间隔和每次扫描的限定耗时，可以在不同情况下使得CPU和内存资源达到最优的平衡效果。(expires字典会保存所有设置了过期时间的key的过期时间数据，其中，key是指向键空间中的某个键的指针，value是该键的毫秒精度的UNIX时间戳表示的过期时间。键空间是指该Redis集群中保存的所有键。)
Redis中同时使用了惰性过期和定期过期两种过期策略。

2.9 MySQL里有2000w数据，Redis中只存20w的数据，如何保证Redis中的数据都是热点数据?

Redis内存数据集大小上升到一定大小的时候，就会施行数据淘汰策略。

2.10 Redis 内存满了怎么办？

我们知道Redis是基于内存的key-value数据库，因为系统的内存大小有限，所以我们在使用Redis的时候可以配置Redis能使用的最大的内存大小。
1、通过配置文件配置 通过在Redis安装目录下面的redis.conf配置文件中添加以下配置设置内存大小

//设置Redis最大占用内存大小为100M
maxmemory 100mb

redis的配置文件不一定使用的是安装目录下面的redis.conf文件，启动redis服务的时候是可以传一个参数指定redis的配置文件的

2、通过命令修改 Redis支持运行时通过命令动态修改内存大小

//设置Redis最大占用内存大小为100M
127.0.0.1:6379> config set maxmemory 100mb
//获取设置的Redis能使用的最大内存大小
127.0.0.1:6379> config get maxmemory

如果不设置最大内存大小或者设置最大内存大小为0，在64位操作系统下不限制内存大小，在32位操作系统下最多使用3GB内存

3.Redis的内存淘汰
既然可以设置Redis最大占用内存大小，那么配置的内存就有用完的时候。那在内存用完的时候，还继续往Redis里面添加数据不就没内存可用了吗？实际上Redis定义了几种策略用来处理这种情况：

当使用volatile-lru、volatile-random、volatile-ttl这三种策略时，如果没有key可以被淘汰，则和noeviction一样返回错误
如何获取及设置内存淘汰策略?
获取当前内存淘汰策略：

127.0.0.1:6379> config get maxmemory-policy

通过配置文件设置淘汰策略（修改redis.conf文件）：

maxmemory-policy allkeys-lru

通过命令修改淘汰策略：

127.0.0.1:6379> config set maxmemory-policy allkeys-lru

LRU算法?什么是LRU?
上面说到了Redis可使用最大内存使用完了，是可以使用LRU算法进行内存淘汰的，那么什么是LRU算法呢？
LRU(Least Recently Used)，即最近最少使用，是一种缓存置换算法。在使用内存作为缓存的时候，缓存的大小一般是固定的。当缓存被占满，这个时候继续往缓存里面添加数据，就需要淘汰一部分老的数据，释放内存空间用来存储新的数据。
这个时候就可以使用LRU算法了。其核心思想是：如果一个数据在最近一段时间没有被用到，那么将来被使用到的可能性也很小，所以就可以被淘汰掉。

2.11 Redis 击穿、穿透、雪崩产生原因以及解决思路?

1.缓存击穿
大家都知道,计算机的瓶颈之一就是 IO,为了解决内存与磁盘速度不匹配的问题,产生了缓存,将一些热点数据放在内存中,随用随取,降低连接到数据库的请求链接,避免数据库挂掉。需要注意的是,无论是击穿还是后面谈到的穿透与雪崩,都是在高并发前提下,当缓存中某一个热点 key 失效,

2.为什么会有击穿发生呢?
有两个主要原因:
1、Key 过期
2、Key 被页面置换淘汰
对于第一个原因是因为在 Redis 中,Key 有过期时间,如果某一个时刻(假如商城做活动,零点开始)key 失效,那么零点之后对某一个商品查询请求将全都压到数据库上,导致数据库崩。
对于第二个原因，因为内存是有限的，要时时刻刻缓存新的数据，淘汰旧的数据，所以在一定的页面置换策略(常见页面置换算法图解)中，淘汰数据，如果某些商品做活动之前无人问津，势必会被淘汰。

3.应对击穿的处理思路

由于 key 过期在所难免，高流量来到 Redis 时,根据 Redis 的单线程特性，可以认为任务是在队列里依次执行的，当请求到达 Redis 发现 Key 过期时，进行一个操作：设置锁。

但是引出了一个新的问题,如果拿到锁去拿数据的请求然后挂了怎么办?也就是锁没有释放,其他进程都在等锁,解决办法是:
对锁设置一个过期时间,如果到达了过期时间还没释放就自动释放,问题又来了,锁挂了好说,但是如果是锁超时呢?也就是在设定的时间里数据没有取出来,但是锁由过期了,常见的思路是,锁过期时间值递增,但是想想不靠谱,因为第一个请求可能超时,如果后面的也超时呢,接连多次超时之后,锁过期时间值势必特别大了,这样做弊端太多。

另外一个思路是,再开启一个线程,进行监控,如果取数据的线程没有挂的话,就适当延迟锁的过期时间。

4.穿透
穿透主要原因是很多请求都在访问数据库不存在的数据,例如一个卖书的商城一直被请求查询茶叶产品,由于 Redis 缓存主要是用来缓存热点数据,对于数据库都不存在的数据,是没法缓存的,这种异常流量就会直接到达数据库并且返回"没有"的查询结果。
应对这种请求,处理办法是对访问请求加一层过滤器,例如布隆过滤器、增强版布隆过滤器、布谷鸟过滤器,详情见:Redis 布隆过滤器与布谷鸟过滤器

除了布隆过滤器,可以增加一些参数检验,例如数据库数据 id 一般都是递增的,如果请求 id = -10 这种参数,势必绕过 Redis,避免这种情况,可以对用户真实性检验等操作。

5.雪崩
雪崩,和击穿类似,不同的是击穿是一个热点 Key 某时刻失效,而雪崩是大量的热点 Key 在一瞬间失效,网络上很多博客都在强调解决雪崩的策略是随机过期时间,这个非常不准确,举个例子,银行做活动,之前这个利息系数为 2%,过了零点系数改为 3%,这种情况能将用户的对应的 key 改为随机过期吗?如果用的过去的数据叫脏数据。明显不可以,同样存钱,你存到年底利息 300 万,隔壁才 200 万,这不得打架啊,开玩笑~正确的思路是,首先要看看这个 Key 过期是不是时点性有关,时点性无关的话,可以随机过期时间解决。如果是时点性有关,例如刚刚说的银行某一天改变某系数,那么就要利用强依赖击穿方案,策略是先过去的线程更新一下所有 key

在后台更新热点 key 的同时,业务层将进来的请求延时一下,例如短暂的睡几毫秒或者秒,给后面的更新热点 key 分散压力。

2.12 Redis事务

2.12.1 什么是事务？
1.事务是一个单独的隔离操作：事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中，不会被其他客户端发送来的命令请求所打断
2.事务是一个原子操作：事务中的命令要么全部被执行，要么全部都不执行。
2.12.2 Redis事务的概念
1.Redis 事务的本质是通过MULTI、EXEC、WATCH等一组命令的集合。事务支持一次执行多个命令，一个事务中所有命令都会被序列化。在事务执行过程，会按照顺序串行化执行队列中的命令，其他客户端提交的命令请求不会插入到事务执行命令序列中。
2.redis事务就是一次性、顺序性、排他性的执行一个队列中的一系列命令。
2.12.3 Redis事务的三个阶段
Multi、Exec、discard
从输入Multi命令开始，输入的命令都会依次进入命令队列中，但不会执行，直到输入Exec后，Redis会将之前的命令队列中的命令依次执行。
组队的过程中可以通过discard来放弃组队。

multi：开启事务 后组队操作在执行exec

组队的过程中可以通过discard来放弃组队如下操作：

事务的错误处理组队中某个命令出现了报告错误，执行时整个的所有队列都会被取消

如果执行阶段某个命令报出了错误，则只有报错的命令不会被执行，而其他的命令都会执行，不会回滚。

1.组队阶段报错，提交失败。都不提交

2.组队阶段成功，提交时失败。哪个错哪个就不显示ok 就不成功