Redis常见面试题汇总

Redis

接下来内容概述：

• 安装redis6.0.8

• redis传统五大数据类型的落地应用

• 知道分布式锁吗？有哪些实现方案？你谈谈对redis分布式锁的理解，删key的时候有什么问题?

• redis缓存过期淘汰策略

• redis的LRU算法简介

   

01_redis两个小细节说明

redis基本类型

• string

• list

• set

• zset（sorted set）

• hash

其他redis的类型

• bitmap

• HyperLogLogs

• GEO

• Stream

备注

• 命令不区分大小写，而key是区分大小写的

• help @类型名词

02_redis传统五大类型使用场景

1_string类型使用场景

最常用

• SET key value

• GET key

同时设置/获取多个键值

• MSET key value [key value…]

• MGET key [key…]

数值增减

• 递增数字 INCR key（可以不用预先设置key的数值。如果预先设置key但值不是数字，则会报错)

• 增加指定的整数 INCRBY key increment

• 递减数值 DECR key

• 减少指定的整数 DECRBY key decrement

获取字符串长度

• STRLEN key

分布式锁

• SETNX key value

• SET key value [EX seconds] [PX milliseconds] [NX|XX]

  • EX：key在多少秒之后过期

  • PX：key在多少毫秒之后过期

  • NX：当key不存在的时候，才创建key，效果等同于setnx

  • XX：当key存在的时候，覆盖key

应用场景

• 商品编号、订单号采用INCR命令生成

• 是否喜欢的文章

2_hash类型使用场景--Map>

Redis的Hash类型相当于Java中Map>

一次设置一个字段值 HSET key field value

一次获取一个字段值 HGET key field

一次设置多个字段值 HMSET key field value [field value …]

一次获取多个字段值 HMGET key field [field …]

获取所有字段值 HGETALL key

获取某个key内的全部数量 HLEN key

删除一个key HDEL

应用场景 - 购物车早期，当前小中厂可用

• 新增商品 hset shopcar:uid1024 334488 1

• 新增商品 hset shopcar:uid1024 334477 1

• 增加商品数量 hincrby shopcar:uid1024 334477 1

• 商品总数 hlen shopcar:uid1024

• 全部选择 hgetall shopcar:uid1024

3_list类型使用场景--有序可重复

向列表左边添加元素 LPUSH key value [value …]

向列表右边添加元素 RPUSH key value [value …]

查看列表 LRANGE key start stop

获取列表中元素的个数 LLEN key

应用场景 - 微信文章订阅公众号

• 大V作者李永乐老师和ICSDN发布了文章分别是11和22

• 阳哥关注了他们两个，只要他们发布了新文章，就会安装进我的List

  • lpush likearticle:阳哥id1122

• 查看阳哥自己的号订阅的全部文章，类似分页，下面0~10就是一次显示10条

  • lrange likearticle:阳哥id 0 10

4_set类型使用场景--无序无重复

添加元素 SADD key member [member …]

删除元素 SREM key member [member …]

获取集合中的所有元素 SMEMBERS key

判断元素是否在集合中 SISMEMBER key member

获取集合中的元素个数 SCARD key

从集合中随机弹出一个元素，元素不删除 SRANDMEMBER key [数字]

从集合中随机弹出一个元素，出一个删一个 SPOP key[数字]

集合运算

• 集合的差集运算A - B

  • 属于A但不属于B的元素构成的集合

  • SDIFF key [key …]

• 集合的交集运算A ∩ B

  • 属于A同时也属于B的共同拥有的元素构成的集合

  • SINTER key [key …]

• 集合的并集运算A U B

  • 属于A或者属于B的元素合并后的集合

  • SUNION key [key …]

应用场景

• 微信抽奖小程序

  • 用户ID，立即参与按钮

    • SADD key 用户ID

  • 显示已经有多少人参与了、上图23208人参加

    • SCARD key

  • 抽奖(从set中任意选取N个中奖人)

    • SRANDMEMBER key 2（随机抽奖2个人，元素不删除，可重复抽奖）

    • SPOP key 3（随机抽奖3个人，元素会删除，不能重复抽奖）

• 微信朋友圈点赞

  • 新增点赞

    • sadd pub:msglD 点赞用户ID1 点赞用户ID2

  • 取消点赞

    • srem pub:msglD 点赞用户ID

  • 展现所有点赞过的用户

    • SMEMBERS pub:msglD

  • 点赞用户数统计，就是常见的点赞红色数字

    • scard pub:msgID

  • 判断某个朋友是否对楼主点赞过

    • SISMEMBER pub:msglD用户ID

• 微博好友关注社交关系

  • 共同关注：我去到局座张召忠的微博，马上获得我和局座共同关注的人

    • sadd s1 1 2 3 4 5

    • sadd s2 3 4 5 6 7

    • SINTER s1 s2

  • 我关注的人也关注他(大家爱好相同)

• QQ内推可能认识的人

  • sadd s1 1 2 3 4 5

  • sadd s2 3 4 5 6 7

  • SINTER s1 s2

  • SDIFF s1 s2

  • SDIFF s2 s1

5_zset类型使用场景--有序集合

向有序集合中加入一个元素和该元素的分数

添加元素 ZADD key score member [score member …]

按照元素分数从小到大的顺序返回索引从start到stop之间的所有元素 ZRANGE key start stop [WITHSCORES]

获取元素的分数 ZSCORE key member

删除元素 ZREM key member [member …]

获取指定分数范围的元素 ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

增加某个元素的分数 ZINCRBY key increment member

获取集合中元素的数量 ZCARD key

获得指定分数范围内的元素个数 ZCOUNT key min max

按照排名范围删除元素 ZREMRANGEBYRANK key start stop

获取元素的排名

• 从小到大 ZRANK key member

• 从大到小 ZREVRANK key member

应用场景

• 根据商品销售对商品进行排序显示

  • 定义商品销售排行榜（sorted set集合），key为goods:sellsort，分数为商品销售数量。

    • 商品编号1001的销量是9，商品编号1002的销量是15 - zadd goods:sellsort 9 1001 15 1002

    • 有一个客户又买了2件商品1001，商品编号1001销量加2 - zincrby goods:sellsort 2 1001

    • 求商品销量前10名 - ZRANGE goods:sellsort 0 10 withscores

• 抖音热搜

  • 点击视频

    • ZINCRBY hotvcr:20200919 1 八佰

    • ZINCRBY hotvcr:20200919 15 八佰 2 花木兰

  • 展示当日排行前10条

    • ZREVRANGE hotvcr:20200919 0 9 withscores

03_redis分布式锁前情说明

锁

• JVM层面的加锁，单机版的锁

• 分布式微服务架构，拆分后各个微服务之间为了避免冲突和数据故障而加入的一种锁，分布式锁

分布式锁的实现方案：

• mysql

• zookeeper

• redis 常用 redlock-----redisson lock/unlock

常见的面试题：

• Redis除了拿来做缓存，你还见过基于Redis的什么用法？

• Redis做分布式锁的时候有需要注意的问题？

• 如果是Redis是单点部署的，会带来什么问题？那你准备怎么解决单点问题呢？

• 集群模式下，比如主从模式，有没有什么问题呢？

• 那你简单的介绍一下Redlock吧？你简历上写redisson，你谈谈。

• Redis分布式锁如何续期？看门狗知道吗？

04_boot整合redis搭建超卖程序

使用场景：多个服务间 + 保证同一时刻内 + 同一用户只能有一个请求（防止关键业务出现数据冲突和并发错误）

建两个Module：boot_redis01，boot_redis02

• POM

    org.springframework.boot
    spring-boot-starter-data-redis

• application.properties

server.port=1111
#2222
​
#=========================redis相关配香========================
#Redis数据库索引（默认方0）
spring.redis.database=0
#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码（默认为空）
spring.redis.password=123456
#连接池最大连接数（使用负值表示没有限制）默认8
spring.redis.lettuce.pool.max-active=8
#连接池最大阻塞等待时间（使用负值表示没有限制）默认-1
spring.redis.lettuce.pool.max-wait=-1
#连接池中的最大空闲连接默认8
spring.redis.lettuce.pool.max-idle=8
#连接池中的最小空闲连接默犬认0
spring.redis.lettuce.pool.min-idle=0

• RedisConfig

@Configuration
public class RedisConfig {
​
    @Bean
    public RedisTemplate redisTemplate(LettuceConnectionFactory connectionFactory){
        RedisTemplate redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(connectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return redisTemplate;
    }
​
}

• GoodController

@RestController
public class GoodController{
​
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
​
    @Value("${server.port}")
    private String serverPort;
​
​
    @GetMapping("/buy_goods")
    public String buy_Goods(){
​
        String result = stringRedisTemplate.opsForValue().get("goods:001");// get key ====看看库存的数量够不够
​
        int goodsNumber = result == null ? 0 : Integer.parseInt(result);
​
        if(goodsNumber > 0){
​
            int realNumber = goodsNumber - 1;
​
            stringRedisTemplate.opsForValue().set("goods:001", String.valueOf(realNumber));
​
            System.out.println("成功买到商品，库存还剩下: "+ realNumber + " 件" + "\t服务提供端口" + serverPort);
​
            return "成功买到商品，库存还剩下:" + realNumber + " 件" + "\t服务提供端口" + serverPort;
​
        }else{
​
            System.out.println("商品已经售完/活动结束/调用超时,欢迎下次光临" + "\t服务提供端口" + serverPort);
        }
​
        return "商品已经售完/活动结束/调用超时,欢迎下次光临" + "\t服务提供端口" + serverPort;
    }
​
}

测试

• redis：set goods:001 100

• 浏览器：http://localhost:1111/buy_goods

 

05_redis分布式锁

没有加锁，并发下数字不对，出现超卖现象

1_JVM层面的加锁，单机版的锁

• synchronized

• ReentraLock

class X {
    private final ReentrantLock lock = new ReentrantLock();
    // ...
​
    public void m() {
        lock.lock();  // block until condition holds//不见不散
        try {
            // ... method body
        } finally {
            lock.unlock()
        }
    }
     
     
    public void m2() {
​
        if(lock.tryLock(timeout, unit)){//过时不候
            try {
            // ... method body
            } finally {
                lock.unlock()
            }   
        }else{
            // perform alternative actions
        }
   }
 }
​

2_分布式部署后，单机锁还是出现超卖现象，需要分布式锁

使用Nginx配置负载均衡

Nginx配置文件修改内容：

upstream myserver{
    server 127.0.0.1:1111 weight=1;
    server 127.0.0.1:2222 weight=1;
}
​
server {
    listen       80;
    server_name  localhost;
​
    #charset koi8-r;
​
    #access_log  logs/host.access.log  main;
​
    location / {
        # 负责用到的配置
        proxy_pass  http://myserver;
        root   html;
        index  index.html index.htm;
    }
​
    #error_page  404              /404.html;
​
    # redirect server error pages to the static page /50x.html
    #
    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   html;
    }
}
​

启动两个微服务：1111，2222，多次访问http://localhost/buy_goods，服务提供端口在1111，2222两者之间横跳

上面手点，下面高并发模拟

redis：set goods:001 100，恢复到100

用到Apache JMeter，100个线程同时访问http://localhost/buy_goods。

启动测试，后台打印如下：01和02两个项目都同时买一送一，单机锁还是无法解决超卖现象。

01和02两个项目中有重复的订单号。

 

这就是所谓分布式部署后出现超卖现象。

Redis具有极高的性能，且其命令对分布式锁支持友好，借助SET命令即可实现加锁处理。

SET-----SETNX

• EX seconds – Set the specified expire time, in seconds.

• PX milliseconds – Set the specified expire time, in milliseconds.

• NX – Only set the key if it does not already exist.

• XX – Only set the key if it already exist.

GoodController

public static final String REDIS_LOCK = "redis_lock";
​
@Autowired
private StringRedisTemplate stringRedisTemplate;
​
public void m(){
    String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
​
    Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value);  //SETNX加锁
​
​
    if(!flag) {
        return "抢锁失败";
    }
 
    ...//业务逻辑
    
    stringRedisTemplate.delete(REDIS_LOCK);   //解锁
}
​

3_上述分布式锁带来的几个问题

问题一：出现异常的话，可能无法释放锁，必须要在代码层面finally释放锁。使用try--finally释放锁

public static final String REDIS_LOCK = "redis_lock";
​
@Autowired
private StringRedisTemplate stringRedisTemplate;
​
public void m(){
    String value = UUID.randomUUID().toString() + Thread.currentThread().getName();
​
    try{
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value);
​
        if(!flag) {
            return "抢锁失败";
        }
        
        ...//业务逻辑
            
    }finally{
        stringRedisTemplate.delete(REDIS_LOCK);   
    }
}
​

问题二：部署了微服务jar包的机器挂了，代码层面根本没有走到finally这块，没办法保证解锁，这个key没有被删除，需要加入一个过期时间限定key。

public static final String REDIS_LOCK = "redis_lock";

@Autowired
private StringRedisTemplate stringRedisTemplate;

public void m(){
    String value = UUID.randomUUID().toString() + Thread.currentThread().getName();

    try{
		Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value);
		//设定时间
        stringRedisTemplate.expire(REDIS_LOCK, 10L, TimeUnit.SECONDS);
        
   		if(!flag) {
        	return "抢锁失败";
	    }
        
    	...//业务逻辑
            
    }finally{
	    stringRedisTemplate.delete(REDIS_LOCK);   
    }
}

问题三：设置key（加锁）+设置过期时间分开了，必须要合并成一行具备原子性。

 //使用另一个带有设置超时操作的方法
Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(REDIS_LOCK, value,10L,TimeUnit.SECONDS);

问题四：张冠李戴，删除了别人的锁。A线程执行到一半的时候，A的锁过期了被自动删除了，B线程进来加锁，然后执行命令，此时A线程做完了任务，走到最后一步把B线程的锁给删除了。

 // 解决方法：只能自己删除自己的，不许动别人的。
if (stringRedisTemplate.opsForValue().get(REDIS_LOCK).equals(value)){
    stringRedisTemplate.delete(REDIS_LOCK);  //解锁
}

！！问题五：finally块的判断 + del删除操作不是原子性的

解决方案：

• 用lua脚本

• 用redis自身的事务

事务介绍

• Redis的事条是通过MULTI，EXEC，DISCARD和WATCH这四个命令来完成。

• Redis的单个命令都是原子性的，所以这里确保事务性的对象是命令集合。

• Redis将命令集合序列化并确保处于一事务的命令集合连续且不被打断的执行。

• Redis不支持回滚的操作。

命令	描述
DISCARD	取消事务，放弃执行事务块内的所有命令。
EXEC	执行所有事务块内的命令。
MULTI	标记一个事务块的开始。
UNWATCH	取消 WATCH 命令对所有 key 的监视。
WATCH key [key …]	监视一个(或多个) key ，如果在事务执行之前这个(或这些) key 被其他命令所改动，那么事务将被打断。

finally {

    while (true){

        stringRedisTemplate.watch(REDIS_LOCK);

        if (stringRedisTemplate.opsForValue().get(REDIS_LOCK).equals(value)) {

            stringRedisTemplate.setEnableTransactionSupport(true);  //开启事务
            stringRedisTemplate.multi(); //表示事务的开始
            stringRedisTemplate.delete(REDIS_LOCK);  //解锁
            List