Redis分布式锁

设计思路
基于 Redis 的 Setnx 命令:在指定的 key 不存在时,为 key 设置指定的值。

具体思路和实现步骤,详见代码。

import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;

/**
 * Redis分布式锁
 *
 * @author Alisallon
 * Created on 2021/4/25 9:34.
 */
@Component
public class RedisLock {
    /**
     * 保存锁以及过期时间,用于解决释放锁造成的问题
     */
    private static final Map LOCK_MAP = new HashMap<>();
    private final StringRedisTemplate redisTemplate;

    public RedisLock(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 尝试获取分布式锁(加锁)
     *
     * @param lock   锁名称
     * @param expire 锁过期时间
     * @return 是否获取到
     */
    public boolean lock(String lock, long expire) {
        try {
            AtomicLong expireAt = new AtomicLong();
            Object result = redisTemplate.execute((RedisCallback) connection -> {
                // 尝试给锁设置值(保存的是未来的过期时间)
                expireAt.set(System.currentTimeMillis() + expire + 1);
                Boolean acquire = connection.setNX(lock.getBytes(), String.valueOf(expireAt.get()).getBytes());
                if (Optional.ofNullable(acquire).orElse(false)) {
                    // 设置值成功,即获取锁成功(加锁成功)
                    return true;
                }
                // 设置值失败,即没有获取到锁,获取锁的对应的值(过期时间)
                byte[] value = connection.get(lock.getBytes());
                if (Objects.nonNull(value) && value.length > 0) {
                    // 获取锁的对应的值(过期时间)成功
                    long expireTime = Long.parseLong(new String(value));
                    // 判断锁是否过期
                    if (expireTime < System.currentTimeMillis()) {
                        // 锁已经过期,表示没有其他程序在占用锁(不能排除占用锁的程序,因为逻辑复杂造成执行时间太长或者程序挂掉了,还没来得及释放锁)
                        // 这里为了防止死锁,直接对已过期的锁重新设置过期时间,同时获得设置新值之前的旧过期时间
                        expireAt.set(System.currentTimeMillis() + expire + 1);
                        byte[] oldValue = connection.getSet(lock.getBytes(), String.valueOf(expireAt.get()).getBytes());
                        if (Optional.ofNullable(oldValue).isPresent()) {
                            // 重新判断设置新值之前的旧过期时间是否真的过期,因为可能会同时存在多个程序在竞争该锁
                            // 如果oldValue还未过期,说明该锁被其他程序抢走了
                            // 如果oldValue已过期,说明该锁未被占用,当前程序可以获得该锁
                            return Long.parseLong(new String(oldValue)) < System.currentTimeMillis();
                        }
                    }
                }
                // 锁的对应的值失败,返回获取锁失败
                return false;
            });
            if (Optional.ofNullable(result).map(t -> (Boolean) result).orElse(false)) {
                // 获取锁成功
                // 在当前程序中保存该锁和过期时间,会在释放锁时使用
                LOCK_MAP.put(lock, expireAt.longValue());
                return true;
            }
            // 获取锁失败
            return false;
        } catch (Exception e) {
            // 获取锁异常,返回获取锁失败
            return false;
        }
    }

    /**
     * 释放锁
     * 必须和上面的lock方法成对出现
     * 需要注意,如果lock方法后面的执行逻辑里有try-catch,一定要在finally中释放锁
     *
     * @param lock 锁名称
     */
    public void release(String lock) {
        // 当当前占用锁的程序因为逻辑复杂造成执行时间太长(执行正常无误),超过了锁的超时时间,这时锁可能会被其他程序抢走
        // 如果直接delete,可能会把其他程序抢走的锁释放,并且被另一个程序抢走,这会造成多个程序同一种业务逻辑并发执行,可能会造成数据不一致的问题
        // 为了解决这个问题,引入了LOCK_MAP
        // 如果LOCK_MAP中存在该锁,需要判断该锁的超时时间
        if (LOCK_MAP.containsKey(lock)) {
            // 已存在该锁
            long expireAt = LOCK_MAP.get(lock);
            if (expireAt <= System.currentTimeMillis()) {
                // 该锁已过期,此时无需手动释放锁,因为该锁可能已经被其他程序抢走了
                // 如果释放了锁,可能释放的不是本程序获得的锁,而是别的程序已抢走的锁,就可能会出现上面说的数据不一致的问题
                return;
            }
            // 该锁还未过期,可以释放锁,因为能主动调用release方法的一定是已获得锁的程序
        }
        try {
            // 释放锁
            redisTemplate.delete(lock);
            // 当前程序移除锁
            LOCK_MAP.remove(lock);
        } catch (Exception e) {
            // 释放锁异常,可以无视
        }
    }
}

 

                            
                        
                    
                    
                    

你可能感兴趣的:(Redis分布式锁)