Docker实现容器化的分布式锁服务RedisLock的快速搭建

# 拉取官方镜像
docker pull redis:7.2
# 运行容器（带密码认证，持久化目录挂载）
docker run -d \
  --name redis-lock \
  -p 6379:6379 \
  -v /data/redis:/data \
  redis:7.2 \
  redis-server --requirepass yourpassword --appendonly yes

services:
  redis:
    container_name: redis-lock-server
    image: redis:7.2
    restart: always
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    sysctls:
      - net.core.somaxconn=511
    environment:
      - TZ=Asia/Shanghai
    networks:
      - lock-net
    ports:
      - "6379:6379"
    volumes:
      - ./data:/data
      - ./config/redis.conf:/usr/local/etc/redis/redis.conf:ro
    command: redis-server /usr/local/etc/redis/redis.conf
networks:
  lock-net:
    driver: bridge

# 基础配置
port 6379
bind 0.0.0.0
daemonize no
dir /data
# 安全认证（分布式锁必须设置，防止未授权释放）
requirepass yourpassword
# 持久化（AOF + RDB 双保险）
appendonly yes
appendfsync everysec
save 900 1
save 300 10
save 60 10000
# 内存与性能
maxmemory 256mb
maxmemory-policy noeviction

mkdir -p data config
docker compose up -d

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.27.0</version>
</dependency>

@Configuration
public class RedissonConfig {
    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer()
              .setAddress("redis://localhost:6379")
              .setPassword("yourpassword")
              .setConnectionMinimumIdleSize(10);
        return Redisson.create(config);
    }
}

@Service
public class OrderService {
    @Autowired
    private RedissonClient redissonClient;
    public void deductStock(Long productId) {
        // 锁命名规范：业务:资源:ID
        RLock lock = redissonClient.getLock("lock:stock:" + productId);
        try {
            // 尝试加锁，最多等待3秒，锁10秒后自动释放
            // 不指定leaseTime时，Redisson 看门狗会自动续期（默认30秒检查一次）
            boolean locked = lock.tryLock(3, 10, TimeUnit.SECONDS);
            if (!locked) {
                throw new RuntimeException("获取锁失败，请重试");
            }
            // 执行业务逻辑...
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            // 必须判断当前线程是否持有锁，避免误释放
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

package main
import (
    "context"
    "fmt"
    "time"
    "github.com/bsm/redislock"
    "github.com/redis/go-redis/v9"
)
func main() {
    // 连接 Redis
    client := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "yourpassword",
        DB:       0,
    })
    // 创建锁管理器
    locker := redislock.New(client)
    ctx := context.Background()
    // 获取锁（TTL 10秒，重试策略）
    lock, err := locker.Obtain(ctx, "my-lock", 10*time.Second, &redislock.Options{
        RetryStrategy: redislock.LinearBackoff(100 * time.Millisecond),
    })
    if err == redislock.ErrNotObtained {
        fmt.Println("锁已被占用")
        return
    } else if err != nil {
        panic(err)
    }
    // 必须释放锁
    defer lock.Release(ctx)
    fmt.Println("获取锁成功，执行业务...")
    time.Sleep(5 * time.Second)
}

services:
  redis-master-1:
    image: redis:7.2
    container_name: redlock-1
    ports: ["6381:6379"]
    command: redis-server --port 6379 --appendonly yes
  redis-master-2:
    image: redis:7.2
    container_name: redlock-2
    ports: ["6382:6379"]
    command: redis-server --port 6379 --appendonly yes
  redis-master-3:
    image: redis:7.2
    container_name: redlock-3
    ports: ["6383:6379"]
    command: redis-server --port 6379 --appendonly yes

Config config = new Config();
config.useRedLock()
    .addSlaveAddress("redis://localhost:6381", "redis://localhost:6382", "redis://localhost:6383");
RedissonClient redisson = Redisson.create(config);
RLock lock = redisson.getRedLock("myLock"); // 红锁

# 进入容器
docker exec -it redis-lock-server redis-cli -a yourpassword
# 测试原子加锁
SET mylock myrandomvalue NX PX 30000
# 返回 OK 表示加锁成功
# 模拟释放锁（Lua 脚本保证原子性）
EVAL "if redis.call('get',KEYS[1]) == ARGV[1] then return redis.call('del',KEYS[1]) else return 0 end" 1 mylock myrandomvalue