引言

在多实例的分布式系统中，对共享资源进行操作时可能会发生并发访问的情况，可能导致数据一致性问题或竞争条件。为了解决这个问题，我们可以使用分布式锁。本文将介绍如何利用Spring Boot集成Redis实现分布式锁，保证共享资源的同步访问，避免数据错误和系统异常。

Redis分布式锁原理

Redis分布式锁的原理基于Redis的单线程特性和SETNX（SET if Not eXists）命令的原子性。通过SETNX命令可以在Redis中创建一个Key-Value对，只有在该Key不存在的情况下才能成功创建，实现了锁的获取。通过设置锁的超时时间，实现了锁的自动释放。

示例代码

1. Redis配置

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

2. Redis分布式锁工具类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;

@Component
public class RedisDistributedLock {

    @Autowired
    private StringRedisTemplate redisTemplate;

    /**
     * 加锁
     *
     * @param lockKey   锁的key
     * @param requestId 请求标识，用于解锁
     * @param expire    锁的超时时间，单位：秒
     * @return 是否成功获取锁
     */
    public boolean lock(String lockKey, String requestId, int expire) {
        Boolean success = redisTemplate.opsForValue().setIfAbsent(lockKey, requestId, expire, TimeUnit.SECONDS);
        return success != null && success;
    }

    /**
     * 解锁
     *
     * @param lockKey   锁的key
     * @param requestId 请求标识
     */
    public void unlock(String lockKey, String requestId) {
        String currentValue = redisTemplate.opsForValue().get(lockKey);
        if (currentValue != null && currentValue.equals(requestId)) {
            redisTemplate.opsForValue().getOperations().delete(lockKey);
        }
    }
}

3. 使用分布式锁示例

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController

public class DemoController {

    @Autowired
    private RedisDistributedLock redisDistributedLock;

    @GetMapping("/process")
    public String process() {
        String lockKey = "lock:resource";
        String requestId = "unique_id";
        int expireTime = 10; // 锁的超时时间
        try {
            // 尝试获取锁
            boolean acquired = redisDistributedLock.lock(lockKey, requestId, expireTime);
            if (acquired) {
                // 成功获取锁，执行业务逻辑
                // ...
                return "Success";
            } else {
                return "Failed to acquire lock";
            }
        } finally {
            // 释放锁
            redisDistributedLock.unlock(lockKey, requestId);
        }
    }
}

适用场景

多实例高并发共享资源场景：适用于多个实例并发访问共享资源时，确保数据一致性和避免竞争条件。常见于订单库存减扣、秒杀等业务场景。

库存系统：在库存系统中，多个用户同时购买商品，需要通过分布式锁来保护库存的减扣操作，确保库存不会出现负数或超卖现象。

限流控制：在高并发访问的情况下，可以利用分布式锁对请求进行限流控制，确保系统不会被过多请求压垮。

数据同步：在数据同步场景下，不同实例需要同步某个数据时，可以通过分布式锁确保只有一个实例进行同步操作，避免重复同步和数据不一致问题。

分布式任务调度：在分布式环境下，如果多个实例共同执行某个任务，可以通过分布式锁保证只有一个实例执行任务，避免重复执行。

适用于需要保证共享资源访问同步、避免并发冲突和确保数据一致性的多实例分布式场景。

优点

实现简单高效：基于Redis的单线程特性，原子性的SETNX操作，实现了简单高效的分布式锁。

避免竞争条件：确保共享资源的同步访问，避免竞争条件导致的数据错误和系统异常。

灵活性强：通过设置合适的锁超时时间，可以适应不同业务场景的需求，避免长时间占用锁资源。

总结

Spring Boot集成Redis分布式锁是解决多实例高并发共享资源问题的一种有效方案。利用Redis原子性的特性，我们可以简单高效地实现分布式锁，确保共享资源的同步访问，避免竞争条件导致的数据错误和系统异常。在多实例分布式系统中，合理使用分布式锁能够确保数据一致性，保障系统的稳定运行。