SpringBoot框架结合Redis实现分布式锁

一、SpringBoot结合 Redis实现分布式锁

1.1、什么是分布式锁

分布式锁,是在分布式的环境下,才会使用到的一种同步访问机制,在传统的单体环境里面,不存在分布式锁的概念,只有在分布式环境里面,才有分布式锁的概念,那到底什么是分布式锁呢?

现在我们通过一个案例来看下,分布式锁的作用。

  • 假设,有一个应用程序,它是分布式部署的,总共有两个应用实例部署在两台机器上面。
  • 注意:这两个应用程序是一模一样的,只不过部署的机器不同。
  • 现在,假设应用程序中有一个定时任务,是专门用于操作数据库的数据,那么,当定时任务执行的时候,两台机器上面的程序都会同时执行,也就是说,此时,存在两个任务同时操作同一个数据库的数据,如果不加锁,那么数据库的数据就会被操作两次。
  • 这显然,可能会出现问题啦,例如:如果是新增数据,那就会插入两条数据,但是实际情况下,我们希望是只有一条数据。
  • 要实现这个功能,就需要添加分布式锁,只有获取到锁的那台机器,才能够操作数据库,其他的机器就不能操作。

分布式锁如下图所示:

SpringBoot框架结合Redis实现分布式锁_第1张图片

1.2、如何实现分布式锁

使用Redis数据库实现分布式锁,核心思想就是:

  • 第一步:每一个线程访问共享资源之前,都需要向redis里面设置一个分布式锁的key。
  • 第二步:如果分布式锁的key已经存在,则说明其他线程已经拿到锁了,那么当前线程就获取锁失败,不用执行。
  • 第三步:如果当前线程获取锁成功,则执行具体的业务逻辑代码。
  • 第四步:当业务逻辑代码执行完成之后,此时,需要主动将分布式锁key给删除掉,这样,下次访问的时候,其他线程可以有机会获取到锁。
  • 注意:删除锁的时候,一定只能够删除当前线程设置的锁,其他线程不能够删除非自身线程的锁。

1.3、分布式锁实现代码

这里是采用SpringBoot结合Redis实现分布式锁,所以,我们需要搭建SpringBoot环境,以及集成Redis数据库。

(1)创建RedisLock工具类

这里我们创建一个RedisLock类,这个类是专门用于加锁、解锁操作的。

  • 为了保证加锁、解锁操作的原子性,一般实际开发中,都会采用LUA脚本执行redis命令。
  • 注意:这里删除锁的时候,必须只能删除当前线程持有的锁。
  • 为什么呢???
  • 假设:A线程获取到了锁,开始执行业务代码,由于执行业务代码时间很长,此时,锁已经过期了,redis已经删除了过期的key;
  • 如果这个时候,B线程来获取锁,那是可以获取成功的,即:B获取锁成功,此时redis中的锁是B持有的。
  • 但是当A线程的业务代码执行完成之后,最后要删除锁,假设,删除锁之前,没有判断这个锁是不是A线程的,就直接删除了,那么此时A线程删除的锁是B线程持有的,从而导致错误。
  • 所以,每次删除锁的时候,都需要判断一下,当前的锁是不是自己持有的。
package com.spring.boot.demo.utils;
 
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.commands.JedisCommands;
import redis.clients.jedis.params.SetParams;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
 
/**
 * @author ZhuYouBin
 * @version 1.0.0
 * @Date: 2022/11/8 20:41
 * @Description Redis分布式锁工具类
 */
@Component
public class RedisLock {
 
    // 定义 RedisTemplate 对象
    private static RedisTemplate<String, Object> redisTemplate;
    // 通过构造方法的方式,注入 RedisTemplate 对象
    public RedisLock(RedisTemplate<String, Object> redisTemplate) {
        RedisLock.redisTemplate = redisTemplate;
    }
 
    // 创建 LUA 脚本【用于解锁的脚本语句】
    private static final StringBuilder unlock_lua = new StringBuilder();
    static {
        // TODO 这里的 KEYS[1] 表示分布式锁对应的 key 值
        // TODO 这里的 ARGV[1] 表示当前线程的唯一标识,要和分布式锁对应的 value 值比较是否相等
        // 查询当前 key 对应的 value 值,是否为当前线程拥有的
        unlock_lua.append("if redis.call(\"get\", KEYS[1]) == ARGV[1] ");
        unlock_lua.append("then "); // 当前锁是当前线程拥有的,可以删除分布式锁
        unlock_lua.append("   return redis.call(\"del\", KEYS[1]) ");
        unlock_lua.append("else "); // 不是当前线程拥有的锁,删除失败
        unlock_lua.append("   return 0 ");
        unlock_lua.append("end ");
    }
 
    /**
     * 获取分布式锁的操作
     * @param key 锁对应的 key 值
     * @param requestId 当前请求线程唯一标识, 作为 value 值【例如:UUID】
     * @param expire 锁过期时间,单位ms
     * @return 加锁成功,则返回 true
     */
    public static boolean acquireLock(final String key, final String requestId, final long expire) {
        try {
            RedisCallback<String> callback = new RedisCallback<String>() {
                @Override
                public String doInRedis(RedisConnection redisConnection) throws DataAccessException {
                    // 获取 redis 命令对象
                    JedisCommands commands = (JedisCommands) redisConnection.getNativeConnection();
                    SetParams params = new SetParams();
                    params.nx(); // 只有键不存在,才能够设置
                    params.px(expire); // 设置过期时间,单位ms
                    // 执行命令【】
                    return commands.set(key, requestId, params);
                }
            };
            // 执行加锁命令
            Object result = redisTemplate.execute(callback);
            if (!Objects.isNull(result)) {
                // 执行结果不等于null,则说明执行成功
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
 
 
    /**
     * 释放当前线程持有的分布式锁
     * @param key 锁对应的 key 值
     * @param requestId 当前请求线程唯一标识, 作为 value 值
     * @return 释放成功,则返回true
     */
    public static boolean releaseLock(final String key, final String requestId) {
        try {
            final List<String> keys = new ArrayList<>();
            keys.add(key);
            final List<String> args = new ArrayList<>();
            args.add(requestId);
 
            RedisCallback<Long> callback = new RedisCallback<Long>() {
                @Override
                public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                    Object nativeConnection = redisConnection.getNativeConnection();
                    Jedis jedis = (Jedis) nativeConnection;
                    // 执行解锁脚本语句
                    Object eval = jedis.eval(unlock_lua.toString(), keys, args);
                    return (Long) eval;
                }
            };
            Long ret = (Long) redisTemplate.execute(callback);
            if (ret != null && ret > 0L) {
                // 删除成功,解锁成功
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
 
}

1.4、编写测试案例

为了演示分布式锁的功能,这里可以编写两个应用程序,写两个定时任务,分别用于模拟同时访问数据库的情况,案例代码如下所示:

(1)案例代码

package com.spring.boot.demo.controller;
 
import com.spring.boot.demo.utils.RedisLock;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
 
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
 
/**
 * @author ZhuYouBin
 * @version 1.0.0
 * @Date: 2022/11/9 22:18
 * @Description
 */
@Component
public class TaskDemo01 {
 
    @Scheduled(cron = "0/10 * * * * ?")
    public void demo01() throws InterruptedException {
        final String key = "distribute_lock_key";
        final String requestId = UUID.randomUUID().toString();
        final long expire = 10000; // 10s过期
 
        boolean acquireLock = RedisLock.acquireLock(key, requestId, expire);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = sdf.format(new Date());
        if (acquireLock) {
            System.out.println(format + ": [TaskDemo01]模拟操作数据库......");
            // TODO 暂停2秒,释放锁
            Thread.sleep(2000);
            RedisLock.releaseLock(key, requestId);
        } else {
            System.out.println(format + ": [TaskDemo01]获取锁失败,不执行......");
        }
    }
 
}

(2)运行测试

将上面的工程分别启动两个实例,然后查看控制台的输出日志。

SpringBoot框架结合Redis实现分布式锁_第2张图片

到此,Redis实现分布式锁就成功啦。

1.5、Redis分布式锁存在的问题

虽然这种Redis实现分布式锁可以解决大部分的问题,但是仍然可能存在问题:

  • 分布式锁过期问题。
    • 当某个线程执行业务逻辑代码的时间,超过分布式锁的有效时间,此时其他线程会获取到锁。
    • 解决办法:使用redission提供的看门狗进行key续期操作。
  • 多个Redis实例情况。
    • 当项目中存在多个Redis实例时候,此时这种分布式锁就失效了。
    • 解决办法:使用redission实现分布式锁。

这种分布式锁可以说,在大部分情况下足够使用了,但是,当项目中部署了多个redis实例时候,这种分布式锁就失效了,多个redis实例时候,可以使用redis官方推出的RedLock。

你可能感兴趣的:(SpringBoot,spring,boot,redis,分布式)