public class SimpleRedisLock implements ILock {

    private String name; // 业务名
    private StringRedisTemplate stringRedisTemplate;

    public SimpleRedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    private static final String KEY_PREFIX = "lock:";
    private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";

    /**
     * 获取锁
     * @param timeoutSec
     * @return
     */
    @Override
    public boolean tryLock(long timeoutSec) {
        // 获取线程标识
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        // 获取锁，redis 中以线程标识作为 value
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
        // 封装类的自动拆箱可能造成空指针异常，这里用 equals 方法进行判断
        return Boolean.TRUE.equals(success);
    }

    /**
     * 释放锁
     */
    @Override
    public void unlock() {
        // 获取当前线程标识和分布式锁里存放的线程标识
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        String id = stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
        // 两个 id 相同才能释放锁
        if (threadId.equals(id)) {
            stringRedisTemplate.delete(KEY_PREFIX + name);
        }
    }
}

@Configuration
public class RedissonConfig {

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://localhost:6379").setPassword("123456");
        return Redisson.create(config);
    }
}

/**
 * 优惠券秒杀下单
 * @param voucherId
 * @return
 */
@Override
public Result seckillVoucher(Long voucherId) {
    SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
    if (voucher.getBeginTime().isAfter(LocalDateTime.now()) || voucher.getEndTime().isBefore(LocalDateTime.now())) {
        return Result.fail("不在秒杀的时间范围内！");
    }
    if (voucher.getStock() < 1) {
        return Result.fail("库存不足！");
    }

    Long userId = UserHolder.getUser().getId();
    // 悲观锁 synchronized 只能在单机系统里解决线程安全问题，不能解决分布式系统的线程安全问题
//        synchronized (userId.toString().intern()) {
//            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
//            return proxy.createVoucherOrder(voucherId);
//        }

    // 分布式锁实现
    // SimpleRedisLock 是自己实现的简单分布式锁
//        SimpleRedisLock lock = new SimpleRedisLock("order" + userId, stringRedisTemplate);

    // Rlock 是 redisson 框架提供的分布式锁
    RLock lock = redissonClient.getLock("lock:order:" + userId);

    boolean isLock = lock.tryLock();
    if (!isLock) {
        return Result.fail("不允许重复下单！");
    }

    try {
        // 获取 spring 事务的代理对象，如果直接调用 createVoucherOrder 方法可能会造成 spring 事务失效
        IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
        // spring 的事务实现是通过动态代理技术实现的，拿到代理对象来调用方法能保证事务的有效性
        return proxy.createVoucherOrder(voucherId);
    } finally {
        lock.unlock();
    }
}

@Transactional
public Result createVoucherOrder(Long voucherId) {
    // 通过拦截器获取登录用户名
    Long userId = UserHolder.getUser().getId();
    // 优惠券一个用户最多购买一次
    int count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
    if (count > 0) {
        return Result.fail("用户已经购买过一次！");
    }

    // 扣减库存
    boolean success = seckillVoucherService.update()
            .setSql("stock = stock - 1")
            // 第二个 gt 是加了一个乐观锁，判断现在查询到的库存和之前的库存是否一样，从而来判断数据库是否被修改过
            // 能解决高并发下的线程安全问题
            .eq("voucher_id", voucherId).gt("stock", 0)
            .update();
    if (!success) {
        // 扣减库存失败
        return Result.fail("库存不足！");
    }

    // 接下来创建订单
    VoucherOrder voucherOrder = new VoucherOrder();
    // 生成全局唯一订单 id
    long orderId = redisIdWorker.nextId("order");
    voucherOrder.setId(orderId);
    voucherOrder.setUserId(userId);
    // 设置优惠券 id
    voucherOrder.setVoucherId(voucherId);
    save(voucherOrder);

    // 返回订单 id
    return Result.ok(orderId);
}

@SpringBootTest
@Slf4j
public class RedissonTest {
 
        @Resource
        private RedissonClient redissonClient;
 
        private RLock lock;
        /**
         * 方法1获取一次锁
         */
        @Test
        void method1() {
            boolean isLock = false;
            // 创建锁对象
            lock = redissonClient.getLock("lock");
            try {
                isLock = lock.tryLock();
                if (!isLock) {
                    log.error("获取锁失败，1");
                    return;
                }
                log.info("获取锁成功，1");
                method2();
            } finally {
                if (isLock) {
                    log.info("释放锁，1");
                    lock.unlock();
                }
            }
        }
 
        /**
         * 方法二再获取一次锁
         */
        void method2() {
            boolean isLock = false;
            try {
                isLock = lock.tryLock();
                if (!isLock) {
                    log.error("获取锁失败, 2");
                    return;
                }
                log.info("获取锁成功，2");
            } finally {
                if (isLock) {
                    log.info("释放锁，2");
                    lock.unlock();
                }
            }
        }
 
}

RLock lock = redissonClient.getLock("myLock");

try {
    // 尝试获取锁，最多等待10秒，上锁以后30秒自动解锁
    boolean isLocked = lock.tryLock(10, 30, TimeUnit.SECONDS);
    if (isLocked) {
        System.out.println("Lock acquired!");
        // 执行业务逻辑
        Thread.sleep(5000); // 模拟耗时操作
    } else {
        System.out.println("Failed to acquire lock.");
    }
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    // 释放锁
    lock.unlock();
    System.out.println("Lock released.");
}