每天一道面试题之架构篇：Redis 分布式锁深度解析与实战指南

面试官："请详细说明Redis分布式锁的实现原理，包括基于SETNX的方案和RedLock算法，并分析各自的优缺点和适用场景。"

分布式锁是分布式系统中的核心基础组件，用于解决跨进程、跨服务的资源互斥访问问题。Redis凭借其高性能和丰富的数据结构，成为实现分布式锁的首选方案之一。

一、核心难点：分布式锁的四大挑战

1. 原子性保障难题

• SETNX和EXPIRE操作的原子性保证
• 锁释放时的身份验证机制
• 复杂业务场景下的锁操作序列化

2. 死锁预防与处理

• 客户端崩溃后的锁自动释放机制
• 网络分区下的锁状态一致性
• 锁过期时间设置的权衡策略

3. 高可用性要求

• Redis单点故障下的锁服务可用性
• 主从切换过程中的锁状态丢失风险
• 多数据中心场景下的锁同步

4. 性能与一致性平衡

• 锁获取和释放的性能开销优化
• 强一致性 vs 最终一致性的选择
• 锁等待队列的公平性保障

二、基于SETNX+EXPIRE的基础方案

2.1 基础实现原理

/**
 * 基于SETNX+EXPIRE的分布式锁基础实现
 * 优点：实现简单，性能高效
 * 缺点：存在原子性问题，需要额外处理
 */
public class RedisDistributedLock {
    private final JedisPool jedisPool;
    private static final String LOCK_PREFIX = "lock:";
    private static final int DEFAULT_EXPIRE_TIME = 30; // 默认30秒过期
    
    /**
     * 尝试获取分布式锁
     * @param lockKey 锁的key
     * @param requestId 请求标识（用于锁释放验证）
     * @param expireTime 锁过期时间（秒）
     * @return 是否获取成功
     */
    public boolean tryLock(String lockKey, String requestId, int expireTime) {
        try (Jedis jedis = jedisPool.getResource()) {
            // 使用SET命令替代SETNX+EXPIRE，保证原子性
            String result = jedis.set(
                LOCK_PREFIX + lockKey,
                requestId,
                SetParams.setParams().nx().ex(expireTime)
            );
            return "OK".equals(result);
        }
    }
    
    /**
     * 释放分布式锁
     * @param lockKey 锁的key
     * @param requestId 请求标识
     * @return 是否释放成功
     */
    public boolean unlock(String lockKey, String requestId) {
        try (Jedis jedis = jedisPool.getResource()) {
            // 使用Lua脚本保证原子性
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                           "return redis.call('del', KEYS[1]) " +
                           "else " +
                           "return 0 " +
                           "end";
            
            Object result = jedis.eval(
                script,
                Collections.singletonList(LOCK_PREFIX + lockKey),
                Collections.singletonList(requestId)
            );
            return Long.valueOf(1L).equals(result);
        }
    }
}

2.2 完整线程安全实现

/**
 * 线程安全的分布式锁管理器
 * 支持可重入、自动续期等高级特性
 */
@Component
public class DistributedLockManager {
    private final RedisTemplate<String, String> redisTemplate;
    private final ThreadLocal<Map<String, LockInfo>> lockHolder = ThreadLocal.withInitial(HashMap::new);
    
    @Data
    @AllArgsConstructor
    private static class LockInfo {
        private String requestId;
        private int lockCount;
        private long expireTime;
    }
    
    /**
     * 尝试获取锁（支持可重入）
     */
    public boolean tryLock(String lockKey, long waitTime, long leaseTime, TimeUnit unit) 
        throws InterruptedException {
        
        String requestId = UUID.randomUUID().toString();
        long startTime = System.currentTimeMillis();
        long maxWaitTime = unit.toMillis(waitTime);
        
        while (System.currentTimeMillis() - startTime < maxWaitTime) {
            if (acquireLock(lockKey, requestId, leaseTime, unit)) {
                return true;
            }
            Thread.sleep(100); // 避免频繁重试
        }
        return false;
    }
    
    private boolean acquireLock(String lockKey, String requestId, long leaseTime, TimeUnit unit) {
        LockInfo currentLock = lockHolder.get().get(lockKey);
        
        // 可重入锁检查
        if (currentLock != null && requestId.equals(currentLock.getRequestId())) {
            currentLock.setLockCount(currentLock.getLockCount() + 1);
            return true;
        }
        
        // 尝试获取新锁
        Boolean success = redisTemplate.execute((RedisCallback<Boolean>) connection -> {
            return connection.set(
                lockKey.getBytes(),
                requestId.getBytes(),
                Expiration.milliseconds(unit.toMillis(leaseTime)),
                RedisStringCommands.SetOption.SET_IF_ABSENT
            );
        });
        
        if (Boolean.TRUE.equals(success)) {
            lockHolder.get().put(lockKey, new LockInfo(requestId, 1, 
                System.currentTimeMillis() + unit.toMillis(leaseTime)));
            return true;
        }
        return false;
    }
    
    /**
     * 释放锁
     */
    public void unlock(String lockKey) {
        LockInfo lockInfo = lockHolder.get().get(lockKey);
        if (lockInfo == null) {
            throw new IllegalStateException("Lock not held by current thread");
        }
        
        if (lockInfo.getLockCount() > 1) {
            lockInfo.setLockCount(lockInfo.getLockCount() - 1);
            return;
        }
        
        // 使用Lua脚本保证原子性释放
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                       "return redis.call('del', KEYS[1]) " +
                       "else " +
                       "return 0 " +
                       "end";
        
        redisTemplate.execute(new DefaultRedisScript<>(script, Long.class), 
            Collections.singletonList(lockKey), lockInfo.getRequestId());
        
        lockHolder.get().remove(lockKey);
    }
}

三、RedLock算法深度解析

3.1 RedLock算法原理

/**
 * RedLock算法实现
 * 通过多个独立的Redis实例提高分布式锁的可靠性
 */
public class RedLock {
    private final List<RedisPool> redisPools;
    private static final int DEFAULT_RETRY_COUNT = 3;
    private static final long DEFAULT_RETRY_DELAY = 200;
    private static final float CLOCK_DRIFT_FACTOR = 0.01f;
    
    public boolean lock(String resource, String value, int ttl) {
        int retryCount = DEFAULT_RETRY_COUNT;
        Random random = new Random();
        
        while (retryCount-- > 0) {
            long startTime = System.currentTimeMillis();
            
            // 尝试从所有Redis实例获取锁
            int successCount = 0;
            for (RedisPool pool : redisPools) {
                if (acquireLockFromInstance(pool, resource, value, ttl)) {
                    successCount++;
                }
            }
            
            // 计算获取锁耗时
            long elapsedTime = System.currentTimeMillis() - startTime;
            int quorum = redisPools.size() / 2 + 1;
            
            // 检查是否获得多数派锁且未超时
            if (successCount >= quorum && 
                elapsedTime < (ttl - Math.max(ttl * CLOCK_DRIFT_FACTOR, 2))) {
                return true;
            }
            
            // 获取失败，释放所有已获得的锁
            for (RedisPool pool : redisPools) {
                releaseLockFromInstance(pool, resource, value);
            }
            
            // 随机延迟后重试
            try {
                Thread.sleep(random.nextInt((int) DEFAULT_RETRY_DELAY));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
        return false;
    }
    
    private boolean acquireLockFromInstance(RedisPool pool, String resource, 
                                          String value, int ttl) {
        try (Jedis jedis = pool.getResource()) {
            String result = jedis.set(resource, value, 
                SetParams.setParams().nx().ex(ttl));
            return "OK".equals(result);
        } catch (Exception e) {
            return false;
        }
    }
    
    private void releaseLockFromInstance(RedisPool pool, String resource, String value) {
        try (Jedis jedis = pool.getResource()) {
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                           "return redis.call('del', KEYS[1]) " +
                           "else " +
                           "return 0 " +
                           "end";
            jedis.eval(script, Collections.singletonList(resource), 
                Collections.singletonList(value));
        } catch (Exception e) {
            // 忽略释放异常
        }
    }
}

3.2 RedLock生产环境配置

# Redis集群配置
redis:
  clusters:
    - name: redlock-cluster1
      host: 192.168.1.10
      port: 6379
      password: ${REDIS_PASSWORD}
      database: 0
      timeout: 2000
      
    - name: redlock-cluster2  
      host: 192.168.1.11
      port: 6379
      password: ${REDIS_PASSWORD}
      database: 0
      timeout: 2000
      
    - name: redlock-cluster3
      host: 192.168.1.12
      port: 6379
      password: ${REDIS_PASSWORD}
      database: 0
      timeout: 2000
      
    - name: redlock-cluster4
      host: 192.168.1.13
      port: 6379
      password: ${REDIS_PASSWORD}
      database: 0
      timeout: 2000
      
    - name: redlock-cluster5
      host: 192.168.1.14
      port: 6379
      password: ${REDIS_PASSWORD}
      database: 0
      timeout: 2000

# RedLock配置
redlock:
  retry-count: 3
  retry-delay: 200
  clock-drift-factor: 0.01
  quorum-size: 3

四、生产环境最佳实践

4.1 锁自动续期机制

/**
 * 分布式锁自动续期守护线程
 * 解决长任务执行时的锁过期问题
 */
@Component
public class LockRenewalDaemon {
    private final ScheduledExecutorService scheduler;
    private final ConcurrentMap<String, RenewalTask> renewalTasks;
    
    @Data
    private static class RenewalTask {
        private String lockKey;
        private String requestId;
        private long expireTime;
        private ScheduledFuture<?> future;
    }
    
    public void startRenewal(String lockKey, String requestId, long initialExpireTime) {
        RenewalTask task = new RenewalTask();
        task.setLockKey(lockKey);
        task.setRequestId(requestId);
        task.setExpireTime(initialExpireTime);
        
        // 每隔1/3过期时间续期一次
        long renewalInterval = initialExpireTime * 1000 / 3;
        
        ScheduledFuture<?> future = scheduler.scheduleAtFixedRate(() -> {
            renewLock(lockKey, requestId, initialExpireTime);
        }, renewalInterval, renewalInterval, TimeUnit.MILLISECONDS);
        
        task.setFuture(future);
        renewalTasks.put(lockKey, task);
    }
    
    private void renewLock(String lockKey, String requestId, long expireTime) {
        String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                       "return redis.call('expire', KEYS[1], ARGV[2]) " +
                       "else " +
                       "return 0 " +
                       "end";
        
        Long result = redisTemplate.execute(
            new DefaultRedisScript<>(script, Long.class),
            Collections.singletonList(lockKey),
            requestId,
            String.valueOf(expireTime)
        );
        
        if (Long.valueOf(1L).equals(result)) {
            log.info("Lock {} renewed successfully", lockKey);
        } else {
            log.warn("Failed to renew lock {}", lockKey);
            stopRenewal(lockKey);
        }
    }
}

4.2 监控与告警集成

/**
 * 分布式锁监控服务
 * 实时监控锁状态，及时发现问题
 */
@Service
public class LockMonitorService {
    private final MeterRegistry meterRegistry;
    private final Map<String, Timer> lockTimers;
    
    @Scheduled(fixedRate = 60000)
    public void monitorLockStatistics() {
        // 监控锁获取成功率
        monitorLockAcquisitionRate();
        
        // 监控锁持有时间分布
        monitorLockHoldTime();
        
        // 检测死锁风险
        detectDeadlockRisk();
    }
    
    private void monitorLockAcquisitionRate() {
        Map<String, Double> successRates = calculateLockSuccessRates();
        successRates.forEach((lockKey, rate) -> {
            Gauge.builder("distributed_lock.success_rate", () -> rate)
                .tag("lock_key", lockKey)
                .register(meterRegistry);
            
            if (rate < 0.8) {
                alertService.sendAlert("Lock acquisition rate too low for: " + lockKey);
            }
        });
    }
    
    private void detectDeadlockRisk() {
        // 检测长时间持有的锁
        List<LockInfo> longHeldLocks = findLongHeldLocks(300000); // 5分钟
        longHeldLocks.forEach(lock -> {
            alertService.sendAlert("Potential deadlock detected for lock: " + lock.getLockKey());
        });
    }
}

五、方案对比与选型指南

Redis分布式锁方案对比矩阵：

方案特性	SETNX+EXPIRE	RedLock	Redis集群模式
实现复杂度	简单	复杂	中等
可靠性	中等（单点风险）	高（多数派）	高（集群）
性能	高	中（多实例操作）	高
一致性	最终一致性	强一致性	最终一致性
适用场景	非关键业务，允许偶尔失败	金融交易，强一致性要求	高并发业务，可用性要求高
运维成本	低	高（多实例管理）	中
网络要求	普通	高（低延迟网络）	普通

六、面试要点与回答技巧

面试回答框架：

1. 先明确需求：分析业务场景对一致性的要求程度
2. 分层阐述：从基础方案到高级方案，说明演进过程
3. 原理深入：详细解释每种方案的实现机制和保障措施
4. 实践经验：分享实际项目中遇到的问题和解决方案
5. 趋势展望：提及新一代分布式锁技术（如etcd、ZooKeeper）

加分回答点：

• 提到时钟漂移对RedLock算法的影响及解决方案
• 讨论网络分区（脑裂）场景下的锁安全性问题
• 分析不同业务场景下的锁超时时间设置策略
• 提及监控体系和故障应急处理方案

常见问题准备：

1. SETNX和EXPIRE为什么要保证原子性？如何保证？
2. RedLock算法为什么需要多数派实例同意？
3. 如何处理锁过期但业务还在执行的情况？
4. Redis主从切换会导致什么问题？如何解决？
5. 除了Redis，还有哪些分布式锁实现方案？

实用面试话术： "在我们之前的支付系统中，根据不同的业务重要性采用了不同的锁方案。对于余额查询使用SETNX方案，对于资金扣减使用RedLock方案，并且建立了完善的监控告警体系来确保锁服务的可靠性..."

本文由微信公众号"程序员小胖"整理发布，转载请注明出处。