Redis nx分布式锁-缓存击穿解决方案（demo）

最新推荐文章于 2024-04-28 22:41:00 发布

ReoShine

最新推荐文章于 2024-04-28 22:41:00 发布

阅读量908

点赞数 1

分类专栏： Redis 文章标签： java redis nx锁缓存击穿

本文链接：https://blog.csdn.net/weixin_42229668/article/details/101163488

版权

Redis 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、缓存穿透

缓存穿透是指查询一个一定不存在的数据，由于缓存是不命中，将去查询数据库，但是数据库也无此记录，并且处于容错考虑，我们没有将这次查询的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。在流量大时，可能DB就挂掉了，要是有人利用不存在的key频繁攻击我们的应用，这就是漏洞。

解决方案：空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。

二、缓存雪崩

缓存雪崩是指在我们设置缓存时采用了相同的过期时间，导致缓存在某一时刻同时失效，请求全部打到DB上，DB瞬时压力过重雪崩。

解决方案：原有的失效时间基础上增加一个随机值，比如1-5分钟随机，这样每一个缓存的过期时间的重复率就会降低，就很难引发集体失效的事件。

三、缓存击穿

对于一些设置了过期时间的key，如果这些key可能会在某些时间点被超高并发地访问，是一种非常“热点”的数据。这个时候，需要考虑一个问题：如果这个key在大量请求同时进来前正好失效，那么所有对这个key的数据查询都落到db，我们称为缓存击穿。和缓存雪崩的区别：

击穿是一个热点key失效
雪崩是很多key集体失效

缓存在某个时间点过期的时候，恰好在这个时间点对这个Key有大量的并发请求过来，这些请求发现缓存过期一般都会从后端DB加载数据并回设到缓存，这个时候大并发的请求可能会瞬间把后端DB压垮。

解决方案：
使用redis数据库的分布式锁，解决mysql的访问压力问题
第一种分布式锁：redis自带的分布式锁：set ex nx
第二种分布式锁：redisson 框架，一个redis的带有JUC的lock功能的客户端的实现

四、代码案例

1、pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.roshine</groupId>
    <artifactId>redis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>redis</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!-- alibaba druid依赖 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>2.9.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.7</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.58</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.5.0</version>
        </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>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

2、application.yml

server:
  port: 8081
spring:
  #数据源配置
  datasource:
    username: XXXXXXX
    password: XXXXXXX
    url: jdbc:mysql://localhost:3306/redis?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC
    type: com.alibaba.druid.pool.DruidDataSource
  #Redis配置
  redis:
    host: localhost
    port: 6379
    database: 0
  #热部署
  devtools:
    livereload:
      enabled: true
    restart:
      enabled: true

#Mybatis配置
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.roshine.redis.entity
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

3、serviceImpl

package com.roshine.redis.impl;

import com.alibaba.fastjson.JSON;
import com.roshine.redis.entity.User;
import com.roshine.redis.mapper.UserMapper;
import com.roshine.redis.service.UserService;
import com.roshine.redis.utils.RedisUtil;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import redis.clients.jedis.Jedis;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

/**
 * @author roshine
 * @version 1.0.0
 * @date 2019-07-30 10:03
 * @Description
 */
@Service
public class UserServiceImpl implements UserService {

    private final UserMapper userMapper;
    private final RedisUtil redisUtil;

    @Autowired
    public UserServiceImpl(UserMapper userMapper, RedisUtil redisUtil) {
        this.userMapper = userMapper;
        this.redisUtil = redisUtil;
    }

    @Override
    public List<User> selectAll() {
        String usersKey = "users::info";
        String usersLockKey = "users::lock";
        Jedis jedis = redisUtil.getJedis();
        List<User> userList = new ArrayList<>();
        String token = UUID.randomUUID().toString();
        String redisToken = jedis.get(usersLockKey);
        try {
            List<String> lrange = jedis.lrange(usersKey, 0, -1);
            //不为空说明redis里面有值,直接返回userList
            if (!lrange.isEmpty()) {
                for (String userData : lrange) {
                    userList.add(JSON.parseObject(userData, User.class));
                }
                //否则说明redis没有,需要查询数据库
                //防止大量请求瞬间全部打在DB上，设置分布式锁(redis 自带的 nx)
            } else {
                //key, value, nx:仅设置不存在的密钥(可以写xx:仅设置已存在的密钥), px:毫秒级别(可以写ex:设置指定的终止时间，以秒为单位), 时间
                String OK = jedis.set(usersLockKey, token, "nx", "px", 10 * 1000);
                //说明设置锁成功,开始查询数据库
                if (StringUtils.isNotBlank(OK) && "OK".equals(OK)) {
                    userList = userMapper.selectAll();
                    //查询到数据并存入redis
                    if (userList != null) {
                        for (User user : userList) {
                            jedis.lpush(usersKey, JSON.toJSONString(user));
                        }
                    } else {
                        //否则数据库没有该数据，防止缓存穿透将null作为usersKey 的值存入redis
                        jedis.setex(usersKey, 60 * 3, JSON.toJSONString(""));
                    }
                } else {
                    //设置锁失败，说明key已存在，自旋操作
                    //自旋：该线程在睡眠几秒后重新尝试访问本selectAll()
                    try {
                        Thread.sleep(3000);
                        userList = userMapper.selectAll();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //返回本方法
                    return selectAll();
                }
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
            //并且释放锁
            if (StringUtils.isNotBlank(redisToken) && redisToken.equals(token)) {
                //用token确认删除的是自己的锁
                jedis.del(usersLockKey);
            }
            jedis.close();
        }
        return userList;
    }

    @Cacheable(value = "user", key = "#id")
    @Override
    public User selectById(Integer id) {
        return userMapper.selectById(id);
    }
}

五、锁中加UUID的作用

当a线程访问redis时，拿到了锁（过期时间为5s），然后去访问mysql，同时b线程进来又去拿redis锁，刚开始拿不到，因为锁被a线程拿了，由于mysql卡顿或者a线程自身等原因导致访问mysql超过5s还没有结束，这时锁释放又被b线程拿了，b线程拿到锁开始访问mysql或者redis，这时a线程操作完毕，回来删除锁，因为a线程拿锁超过5s后锁就自动解开了，这时删除的锁是b线程的锁。
所以为了保证锁的唯一性，将value设置为唯一，并非必须用UUID，只需保证setnx 的value唯一即可。
redis删除锁产生的问题
最后附上源码：源码可以访问GitHub

ReoShine

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Redis nx分布式锁-缓存击穿解决方案（demo）

一、缓存穿透缓存穿透是指查询一个一定不存在的数据，由于缓存是不命中，将去查询数据库，但是数据库也无此记录，并且处于容错考虑，我们没有将这次查询的null写入缓存，这将导致这个不存在的数据每次请求都要到存储层去查询，失去了缓存的意义。在流量大时，可能DB就挂掉了，要是有人利用不存在的key频繁攻击我们的应用，这就是漏洞。解决方案：空结果进行缓存，但它的过期时间会很短，最长不超过五分钟。二、缓...
复制链接

扫一扫