分布式锁详解：Redis与ZooKeeper实现原理与对比

1
public class RedisDistributedLock {
2

3
    private final StringRedisTemplate redis;
4

5
    public RedisDistributedLock(StringRedisTemplate redis) {
6
        this.redis = redis;
7
    }
8

9
    /** 加锁成功返回 true，value 用 UUID 保证唯一，用来安全释放 */
10
    public boolean lock(String key, String value, long expireSec) {
11
        return Boolean.TRUE.equals(
12
                redis.opsForValue().setIfAbsent(key, value, expireSec, TimeUnit.SECONDS));
13
    }
14

15
    /** 释放锁：Lua 校验 value 是自己才删除 */
16
    public void unlock(String key, String value) {
17
        String script =
18
            "if redis.call('get', KEYS[1]) == ARGV[1] " +
19
            "then return redis.call('del', KEYS[1]) " +
20
            "else return 0 end";
21
        redis.execute(new DefaultRedisScript<>(script, Long.class),
22
                List.of(key), value);
23
    }
24
}

1
public void createOrder(Long userId, Long orderId) {
2
    String lockKey = "lock:order:" + userId;
3
    String lockValue = UUID.randomUUID().toString(); // 每个请求唯一
4

5
    // 自旋重试获取锁（非阻塞尝试 + 短暂睡眠）
6
    if (!tryLockLoop(lockKey, lockValue, 3, 50)) { // 最多等3秒
7
        throw new BizException("操作太频繁，请稍后重试");
8
    }
9
    try {
10
        // 临界区：防止重复下单
11
        doCreateOrder(userId, orderId);
12
    } finally {
13
        redisDistributedLock.unlock(lockKey, lockValue);
14
    }
15
}

1
// 1. 引入依赖
2
// <dependency>
3
//     <groupId>org.redisson</groupId>
4
//     <artifactId>redisson-spring-boot-starter</artifactId>
5
// </dependency>
6

7
@Configuration
8
public class RedissonConfig {
9

10
    @Bean(destroyMethod = "shutdown")
11
    public RedissonClient redissonClient() {
12
        Config config = new Config();
13
        config.useSingleServer()
14
                .setAddress("redis://127.0.0.1:6379")
15
                .setPassword("你的密码");  // 无密码可去掉
16
        return Redisson.create(config);
17
    }
18
}

1
@Service
2
public class OrderService {
3

4
    @Autowired
5
    private RedissonClient redisson;
6

7
    public void createOrder(Long userId, Long orderId) {
8
        // 锁的 key，按业务维度隔离
9
        RLock lock = redisson.getLock("lock:order:" + userId);
10

11
        try {
12
            // 等待2秒拿不到锁就放弃（不阻塞太长时间）
13
            boolean locked = lock.tryLock(2, 10, TimeUnit.SECONDS);
14
            if (!locked) {
15
                throw new BizException("操作太频繁，请稍后重试");
16
            }
17
            doCreateOrder(userId, orderId);
18
        } catch (InterruptedException e) {
19
            Thread.currentThread().interrupt();
20
        } finally {
21
            // 只有持有锁才释放（Redisson 内部校验）
22
            if (lock.isHeldByCurrentThread()) {
23
                lock.unlock();
24
            }
25
        }
26
    }
27
}

1
// 1. 引入依赖
2
// <dependency>
3
//     <groupId>org.apache.curator</groupId>
4
//     <artifactId>curator-recipes</artifactId>
5
// </dependency>
6

7
@Configuration
8
public class ZkLockConfig {
9

10
    @Bean(destroyMethod = "close")
11
    public CuratorFramework curatorFramework() {
12
        // 连接串，多个节点逗号分隔
13
        CuratorFramework client = CuratorFrameworkFactory.newClient(
14
                "127.0.0.1:2181",
15
                new ExponentialBackoffRetry(1000, 3));
16
        client.start();
17
        return client;
18
    }
19
}

1
@Service
2
public class InventoryService {
3

4
    @Autowired
5
    private CuratorFramework curator;
6

7
    public void reduceStock(Long productId, int num) {
8
        // 公平可重入锁
9
        InterProcessMutex lock = new InterProcessMutex(
10
                curator, "/locks/stock:" + productId);
11

12
        try {
13
            // 阻塞等待获取锁
14
            if (!lock.acquire(5, TimeUnit.SECONDS)) {
15
                throw new BizException("系统繁忙，请稍后重试");
16
            }
17
            doReduceStock(productId, num);
18
        } catch (Exception e) {
19
            throw new BizException("扣减库存失败", e);
20
        } finally {
21
            // 释放锁（若持有）
22
            try {
23
                lock.release();
24
            } catch (Exception ignored) {
25
                // 会话异常时节点已被自动清理
26
            }
27
        }
28
    }
29
}