Redis 分布式锁源码深度解析：从原理到实现细节

# 加锁命令SET lock:resource uuid NX PX 30000

-- 解锁脚本if redis.call('get', KEYS[1]) == ARGV[1] then    return redis.call('del', KEYS[1])else    return 0end

public class RedisDistributedLock implements AutoCloseable {    private final RedisTemplate<String, Object> redisTemplate;    private final String lockKey;         // 锁的键名    private final String lockValue;       // 锁的唯一标识    private final long expireTime;        // 过期时间    private final TimeUnit timeUnit;      // 时间单位    private boolean isLocked = false;     // 是否持有锁    private ScheduledExecutorService scheduler;  // 续期定时器    // 构造函数    public RedisDistributedLock(RedisTemplate<String, Object> redisTemplate,                                String lockKey,                                long expireTime,                                TimeUnit timeUnit) {        this.redisTemplate = redisTemplate;        this.lockKey = lockKey;        this.expireTime = expireTime;        this.timeUnit = timeUnit;        // 生成唯一标识（UUID+线程ID，增强唯一性）        this.lockValue = UUID.randomUUID().toString() + ":" + Thread.currentThread().getId();    }

/** * 尝试获取锁 * @param waitTime 最大等待时间 * @return 是否获取成功 */public boolean tryLock(long waitTime) throws InterruptedException {    long start = System.currentTimeMillis();    long waitMillis = timeUnit.toMillis(waitTime);        // 循环尝试获取锁，直到超时    while (true) {        // 执行加锁命令        Boolean success = redisTemplate.opsForValue().setIfAbsent(            lockKey, lockValue, expireTime, timeUnit        );                if (Boolean.TRUE.equals(success)) {            isLocked = true;            // 启动续期任务            startRenewal();            return true;        }                // 检查是否超时        if (System.currentTimeMillis() - start > waitMillis) {            return false;        }                // 短暂休眠后重试，减轻Redis压力        Thread.sleep(100);    }}/** * 立即获取锁，不等待 */public boolean tryLock() {    try {        return tryLock(0);    } catch (InterruptedException e) {        Thread.currentThread().interrupt();        return false;    }}

/** * 启动锁续期任务 */private void startRenewal() {    scheduler = Executors.newSingleThreadScheduledExecutor(        r -> {            Thread thread = new Thread(r, "lock-renewer-" + lockKey);            thread.setDaemon(true);  // 守护线程，避免阻塞JVM退出            return thread;        }    );        // 每过期时间的1/3执行一次续期    long period = timeUnit.toMillis(expireTime) / 3;        scheduler.scheduleAtFixedRate(() -> {        if (isLocked) {            // 续期命令：延长锁的过期时间            Boolean success = redisTemplate.expire(lockKey, expireTime, timeUnit);            if (Boolean.FALSE.equals(success)) {                // 续期失败，可能锁已过期，停止续期                isLocked = false;                scheduler.shutdown();            }        } else {            scheduler.shutdown();        }    }, period, period, TimeUnit.MILLISECONDS);}

/** * 释放锁 */public void unlock() {    if (!isLocked) {        return;    }        // 执行解锁Lua脚本    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +                   "return redis.call('del', KEYS[1]) " +                   "else return 0 end";        Long result = (Long) redisTemplate.execute(        new DefaultRedisScript<>(script, Long.class),        Collections.singletonList(lockKey),        lockValue    );        // 停止续期任务    if (scheduler != null) {        scheduler.shutdown();    }        isLocked = false;}/** * 实现AutoCloseable接口，支持try-with-resources语法 */@Overridepublic void close() {    unlock();}

// 服务层使用分布式锁示例@Servicepublic class InventoryService {    @Autowired    private RedisTemplate<String, Object> redisTemplate;        @Autowired    private InventoryMapper inventoryMapper;        /**     * 扣减库存     */    public boolean deductInventory(Long productId, int quantity) {        // 创建分布式锁，锁的键名为"lock:inventory:商品ID"，过期时间30秒        String lockKey = "lock:inventory:" + productId;        try (RedisDistributedLock lock = new RedisDistributedLock(                redisTemplate, lockKey, 30, TimeUnit.SECONDS)) {                        // 尝试获取锁，最多等待5秒            if (!lock.tryLock(5000)) {                throw new RuntimeException("系统繁忙，请稍后重试");            }                        // 执行业务逻辑            Inventory inventory = inventoryMapper.selectByProductId(productId);            if (inventory == null || inventory.getStock() < quantity) {                return false;            }                        inventory.setStock(inventory.getStock() - quantity);            inventoryMapper.updateById(inventory);            return true;        } catch (InterruptedException e) {            Thread.currentThread().interrupt();            return false;        }    }}

// Redisson分布式锁使用示例@Servicepublic class OrderService {    @Autowired    private RedissonClient redissonClient;        public void createOrder(Long userId) {        RLock lock = redissonClient.getLock("lock:order:" + userId);        try {            // 尝试获取锁，等待100秒，10秒后自动释放            boolean locked = lock.tryLock(100, 10, TimeUnit.SECONDS);            if (locked) {                // 执行订单创建逻辑            }        } catch (InterruptedException e) {            Thread.currentThread().interrupt();        } finally {            // 确保释放锁            if (lock.isHeldByCurrentThread()) {                lock.unlock();            }        }    }}