Redis（72）Redis分布式锁的常见使用场景有哪些？

Redis分布式锁在很多需要协调多个分布式系统或组件的场景中都能发挥重要作用。以下是一些常见的使用场景以及相应的代码示例：

常见使用场景

防止资源竞争：
- 多个进程或线程需要访问同一共享资源时，使用分布式锁可以防止资源竞争，确保同一时间只有一个进程或线程在操作该资源。
定时任务调度：
- 在分布式系统中，确保某个定时任务在同一时刻只被一个调度器执行，避免重复执行任务。
库存扣减：
- 电商系统中，多个用户同时下单时，需要确保库存扣减操作的原子性和一致性。
分布式事务：
- 在跨多个服务的分布式事务中，使用分布式锁可以协调各服务的操作，确保事务的一致性。
ID生成器：
- 分布式系统中生成全局唯一ID时，使用分布式锁可以确保ID的唯一性和有序性。

场景示例和相应代码

1. 防止资源竞争

假设有多个进程同时写入一个文件，我们需要确保同一时间只有一个进程在写入。

1import redis.clients.jedis.Jedis;
2import redis.clients.jedis.params.SetParams;
3
4public class FileWriteWithDistributedLock {
5    private Jedis jedis;
6    private String lockKey;
7    private String lockValue;
8    private int expireTime;
9
10    public FileWriteWithDistributedLock(Jedis jedis, String lockKey, int expireTime) {
11        this.jedis = jedis;
12        this.lockKey = lockKey;
13        this.expireTime = expireTime;
14        this.lockValue = String.valueOf(Thread.currentThread().getId());
15    }
16
17    public boolean acquireLock() {
18        SetParams params = new SetParams().nx().px(expireTime);
19        String result = jedis.set(lockKey, lockValue, params);
20        return "OK".equals(result);
21    }
22
23    public boolean releaseLock() {
24        String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
25                           "return redis.call('del', KEYS[1]) else return 0 end";
26        Object result = jedis.eval(luaScript, 1, lockKey, lockValue);
27        return result.equals(1L);
28    }
29
30    public void writeToFile(String content) {
31        if (acquireLock()) {
32            try {
33                // 模拟文件写操作
34                System.out.println("Writing to file: " + content);
35            } finally {
36                boolean released = releaseLock();
37                if (released) {
38                    System.out.println("Lock released after writing.");
39                } else {
40                    System.out.println("Failed to release lock.");
41                }
42            }
43        } else {
44            System.out.println("Failed to acquire lock, try again later.");
45        }
46    }
47
48    public static void main(String[] args) {
49        Jedis jedis = new Jedis("localhost", 6379);
50        FileWriteWithDistributedLock fileLock = new FileWriteWithDistributedLock(jedis, "file_write_lock", 10000);
51        fileLock.writeToFile("Hello, World!");
52        jedis.close();
53    }
54}
55

2. 定时任务调度

确保定时任务在分布式系统中同一时刻只被一个节点执行。

1import redis.clients.jedis.Jedis;
2import redis.clients.jedis.params.SetParams;
3
4public class ScheduledTaskWithDistributedLock {
5    private Jedis jedis;
6    private String lockKey;
7    private String lockValue;
8    private int expireTime;
9
10    public ScheduledTaskWithDistributedLock(Jedis jedis, String lockKey, int expireTime) {
11        this.jedis = jedis;
12        this.lockKey = lockKey;
13        this.expireTime = expireTime;
14        this.lockValue = String.valueOf(Thread.currentThread().getId());
15    }
16
17    public boolean acquireLock() {
18        SetParams params = new SetParams().nx().px(expireTime);
19        String result = jedis.set(lockKey, lockValue, params);
20        return "OK".equals(result);
21    }
22
23    public boolean releaseLock() {
24        String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
25                           "return redis.call('del', KEYS[1]) else return 0 end";
26        Object result = jedis.eval(luaScript, 1, lockKey, lockValue);
27        return result.equals(1L);
28    }
29
30    public void executeScheduledTask() {
31        if (acquireLock()) {
32            try {
33                // 执行定时任务
34                System.out.println("Executing scheduled task.");
35            } finally {
36                boolean released = releaseLock();
37                if (released) {
38                    System.out.println("Lock released after executing task.");
39                } else {
40                    System.out.println("Failed to release lock.");
41                }
42            }
43        } else {
44            System.out.println("Failed to acquire lock, another instance might be executing the task.");
45        }
46    }
47
48    public static void main(String[] args) {
49        Jedis jedis = new Jedis("localhost", 6379);
50        ScheduledTaskWithDistributedLock taskLock = new ScheduledTaskWithDistributedLock(jedis, "scheduled_task_lock", 10000);
51        taskLock.executeScheduledTask();
52        jedis.close();
53    }
54}
55

3. 库存扣减

在电商系统中，同时对同一个商品下单时需要确保库存扣减操作的原子性。

1import redis.clients.jedis.Jedis;
2import redis.clients.jedis.params.SetParams;
3
4public class InventoryReductionWithDistributedLock {
5    private Jedis jedis;
6    private String lockKey;
7    private String lockValue;
8    private int expireTime;
9
10    public InventoryReductionWithDistributedLock(Jedis jedis, String lockKey, int expireTime) {
11        this.jedis = jedis;
12        this.lockKey = lockKey;
13        this.expireTime = expireTime;
14        this.lockValue = String.valueOf(Thread.currentThread().getId());
15    }
16
17    public boolean acquireLock() {
18        SetParams params = new SetParams().nx().px(expireTime);
19        String result = jedis.set(lockKey, lockValue, params);
20        return "OK".equals(result);
21    }
22
23    public boolean releaseLock() {
24        String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
25                           "return redis.call('del', KEYS[1]) else return 0 end";
26        Object result = jedis.eval(luaScript, 1, lockKey, lockValue);
27        return result.equals(1L);
28    }
29
30    public void reduceInventory(String itemId, int quantity) {
31        if (acquireLock()) {
32            try {
33                // 模拟库存扣减操作
34                System.out.println("Reducing inventory for item: " + itemId + " by " + quantity);
35            } finally {
36                boolean released = releaseLock();
37                if (released) {
38                    System.out.println("Lock released after reducing inventory.");
39                } else {
40                    System.out.println("Failed to release lock.");
41                }
42            }
43        } else {
44            System.out.println("Failed to acquire lock, try again later.");
45        }
46    }
47
48    public static void main(String[] args) {
49        Jedis jedis = new Jedis("localhost", 6379);
50        InventoryReductionWithDistributedLock inventoryLock = new InventoryReductionWithDistributedLock(jedis, "inventory_lock", 10000);
51        inventoryLock.reduceInventory("item123", 1);
52        jedis.close();
53    }
54}
55

4. 分布式事务

在跨多个服务的分布式事务中，通过分布式锁来协调操作，确保事务的一致性。

1import redis.clients.jedis.Jedis;
2import redis.clients.jedis.params.SetParams;
3
4public class DistributedTransactionWithLock {
5    private Jedis jedis;
6    private String lockKey;
7    private String lockValue;
8    private int expireTime;
9
10    public DistributedTransactionWithLock(Jedis jedis, String lockKey, int expireTime) {
11        this.jedis = jedis;
12        this.lockKey = lockKey;
13        this.expireTime = expireTime;
14        this.lockValue = String.valueOf(Thread.currentThread().getId());
15    }
16
17    public boolean acquireLock() {
18        SetParams params = new SetParams().nx().px(expireTime);
19        String result = jedis.set(lockKey, lockValue, params);
20        return "OK".equals(result);
21    }
22
23    public boolean releaseLock() {
24        String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
25                           "return redis.call('del', KEYS[1]) else return 0 end";
26        Object result = jedis.eval(luaScript, 1, lockKey, lockValue);
27        return result.equals(1L);
28    }
29
30    public void executeDistributedTransaction() {
31        if (acquireLock()) {
32            try {
33                // 执行分布式事务的协调操作
34                System.out.println("Executing distributed transaction.");
35            } finally {
36                boolean released = releaseLock();
37                if (released) {
38                    System.out.println("Lock released after executing transaction.");
39                } else {
40                    System.out.println("Failed to release lock.");
41                }
42            }
43        } else {
44            System.out.println("Failed to acquire lock, try again later.");
45        }
46    }
47
48

《Redis（72）Redis分布式锁的常见使用场景有哪些？》是转载文章，点击查看原文。