分布式锁的实现：基于Redis的解决方案

微服务架构中，分布式锁是确保跨多个节点或实例的线程安全的关键技术。当多个服务实例可能同时修改共享资源时，分布式锁可以保证在同一时间只有一个实例可以执行特定的操作。在本文中，我们将探讨如何使用Redis来实现一个简单的分布式锁机制。
分布式锁的挑战
在分布式系统中，锁必须满足以下条件：

互斥性：同时只能有一个进程持有锁。
安全性：锁必须具有原子性，要么成功获取锁，要么不获取。
性能：锁的获取和释放必须快速。
可重入性：同一个进程可以多次获取同一把锁。
死锁预防：避免因进程异常退出导致的死锁。
使用Redis实现分布式锁
环境准备
在开始之前，确保你的开发环境已经安装了Redis。你可以使用任何版本的Spring Boot，因为我们将使用RedisTemplate来操作Redis。

代码实现
以下是使用Java和Spring框架实现Redis分布式锁的基础代码。

package com.csot.kms.common.redislock;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.connection.RedisStringCommands;
import org.springframework.data.redis.connection.ReturnType;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.types.Expiration;

import java.nio.charset.StandardCharsets;
import java.util.UUID;

/**
 * @author dj
 */
@Slf4j
public class RedisLockUtils {

    /**
     * 默认轮休获取锁间隔时间， 单位：毫秒
     */
    private static final int DEFAULT_ACQUIRE_RESOLUTION_MILLIS = 100;

    private static final String UNLOCK_LUA;

    static {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        UNLOCK_LUA = sb.toString();
    }

    /**
     * 获取锁，没有获取到则一直等待，异常情况则返回null
     *
     * @param redisTemplate     redis连接
     * @param key               redis key
     * @param expire            锁过期时间, 单位 秒
     * @return                  当前锁唯一id，如果没有获取到，返回 null
     */
    public static String lock(RedisTemplate redisTemplate, final String key, long expire){
        return lock(redisTemplate, key, expire, -1);
    }

    /**
     * 获取锁，acquireTimeout时间内没有获取到，则返回null，异常情况返回null
     *
     * @param redisTemplate     redis连接
     * @param key               redis key
     * @param expire            锁过期时间, 单位 秒
     * @param acquireTimeout    获取锁超时时间, -1代表永不超时, 单位 秒
     * @return                  当前锁唯一id，如果没有获取到，返回 null
     */
    public static String lock(RedisTemplate redisTemplate, final String key, long expire, long acquireTimeout){
        try {
            return acquireLock(redisTemplate, key, expire, acquireTimeout);
        } catch (Exception e) {
            log.error("acquire lock exception", e);
        }
        return null;
    }

    /**
     * 获取锁，没有获取到则一直等待，没有获取到则抛出异常
     *
     * @param redisTemplate     redis连接
     * @param key               redis key
     * @param expire            锁过期时间, 单位 秒
     * @return                  当前锁唯一id，如果没有获取到，返回 null
     */
    public static String lockFailThrowException(RedisTemplate redisTemplate, final String key, long expire){
        return lockFailThrowException(redisTemplate, key, expire, -1);
    }

    /**
     * 获取锁，到达超时时间时没有获取到，则抛出异常
     *
     * @param redisTemplate     redis连接
     * @param key               redis key
     * @param expire            锁过期时间, 单位 秒
     * @param acquireTimeout    获取锁超时时间, -1代表永不超时, 单位 秒
     * @return                  当前锁唯一id，如果没有获取到，返回 null
     */
    public static String lockFailThrowException(RedisTemplate redisTemplate, final String key, long expire, long acquireTimeout){
        try {
            log.info("redis开始获取锁,key：{}",key);
            String lockId = acquireLock(redisTemplate, key, expire, acquireTimeout);
            if (lockId != null) {
                log.info("redis获取锁完成,key：{}",key);
                return lockId;
            }
            throw new RuntimeException("acquire lock fail");
        } catch (Exception e) {
            throw new RuntimeException("acquire lock exception", e);
        }
    }

    private static String acquireLock(RedisTemplate redisTemplate, String key, long expire, long acquireTimeout) throws InterruptedException {
        long acquireTime = -1;
        if (acquireTimeout != -1) {
            acquireTime = acquireTimeout * 1000 + System.currentTimeMillis();
        }
        synchronized (key) {
            String lockId = UUID.randomUUID().toString();
            while (true) {

                if (acquireTime != -1 && acquireTime < System.currentTimeMillis()) {
                    break;
                }
                //调用tryLock
                boolean hasLock = tryLock(redisTemplate, key, expire, lockId);

                //获取锁成功
                if (hasLock) {
                    return lockId;
                }
                Thread.sleep(DEFAULT_ACQUIRE_RESOLUTION_MILLIS);
            }
        }
        return null;
    }


    /**
     *  释放锁
     *
     * @param redisTemplate     redis连接
     * @param key               redis key
     * @param lockId            当前锁唯一id
     */
    public static void unlock(RedisTemplate redisTemplate, String key, String lockId) {
        try {
            RedisCallback<Boolean> callback = (connection) ->
                    connection.eval(UNLOCK_LUA.getBytes(StandardCharsets.UTF_8), ReturnType.BOOLEAN, 1,
                            (RedisKeys.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8), lockId.getBytes(StandardCharsets.UTF_8));
            redisTemplate.execute(callback);
            log.info("redis释放锁,key：{}",key);
        } catch (Exception e) {
            log.error("release lock exception", e);
        }
    }

    /**
     * 获取当前锁的id
     *
     * @param key       redis key
     * @return          当前锁唯一id
     */
    public static String get(RedisTemplate redisTemplate, String key) {
        try {
            RedisCallback<String> callback = (connection) -> {
                byte[] bytes = connection.get((RedisKeys.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8));
                if (bytes != null){
                    return new String(bytes, StandardCharsets.UTF_8);
                }
                return null;
            };
            return (String)redisTemplate.execute(callback);
        } catch (Exception e) {
            log.error("get lock id exception", e);
        }
        return null;
    }

    private static boolean tryLock(RedisTemplate redisTemplate, String key, long expire, String lockId) {
        RedisCallback<Boolean> callback = (connection) ->
                connection.set((RedisKeys.LOCK_REDIS_PREFIX + key).getBytes(StandardCharsets.UTF_8),
                        lockId.getBytes(StandardCharsets.UTF_8), Expiration.seconds(expire), RedisStringCommands.SetOption.SET_IF_ABSENT);
        return (Boolean)redisTemplate.execute(callback);
    }

}

package com.csot.kms.sys.quartz.task;

import com.csot.kms.common.redislock.RedisLockUtils;
import com.csot.kms.common.utill.SpringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * 定时任务类
 *
 * @author dj
 * @date 2023/7/5
 */
@Slf4j
@Component("jobTaskTest")
public class JobTask {

    public static String syncUserRedisLockKey = "lock:syncPush:lockKey";
    private static StringRedisTemplate redisTemplate = SpringUtils.getBean("stringRedisTemplate");
    /**
     * 此处为需要执行定时任务的方法, 可以根据需求自行添加对应的定时任务方法
     */
    public void upsertTask(String jobId) {
        log.info("01.锁等待,time:{}",new Date());
        String lockId = RedisLockUtils.lockFailThrowException(redisTemplate, syncUserRedisLockKey, 40);
        log.info("02.拿到锁,time:{}",new Date());
        try {
            Thread.sleep(15*1000);
            log.info("定时任务执行啦...jobId:{}",jobId);
           
        }
        catch (Exception e){
            log.error("执行异常：{}",e.getMessage());
        }finally {
            RedisLockUtils.unlock(redisTemplate,syncUserRedisLockKey,lockId);
            log.info("03.释放锁,time:{}",new Date());
        }
    }
}