详解解Spring Boot高并发锁的使用方法

@Service
public class StockService {
    // 模拟数据库中的库存（实际开发中用数据库或缓存）
    private int stock = 10;

    // 下单扣减库存（synchronized保证同一时刻只有1个线程执行）
    public synchronized boolean deductStock(int productId, int count) {
        // 检查库存是否足够
        if (stock < count) {
            return false; // 库存不足
        }
        // 模拟业务耗时（如查询数据库、记录日志）
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        // 扣减库存
        stock -= count;
        System.out.println("扣减成功，剩余库存：" + stock);
        return true;
    }
}

@Service
public class StockService {
    private int stock = 10;
    // 显式锁（可重入锁，支持公平/非公平）
    private final ReentrantLock lock = new ReentrantLock();

    public boolean deductStock(int productId, int count) {
        // 尝试加锁（最多等待2秒，避免死锁）
        try {
            if (lock.tryLock(2, TimeUnit.SECONDS)) {
                if (stock >= count) {
                    Thread.sleep(100); // 模拟业务耗时
                    stock -= count;
                    System.out.println("扣减成功，剩余库存：" + stock);
                    return true;
                } else {
                    System.out.println("库存不足");
                    return false;
                }
            } else {
                System.out.println("获取锁超时");
                return false;
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        } finally {
            // 必须在finally中释放锁（避免异常导致锁未释放）
            lock.unlock();
        }
    }
}

@Service
public class StockService {
    @Autowired
    private RedissonClient redissonClient;

    // 模拟数据库库存（实际用数据库或缓存，如Redis存储库存）
    private int stock = 10;

    public boolean deductStock(int productId, int count) {
        // 定义锁的名称（按商品ID隔离，不同商品用不同锁）
        String lockKey = "lock:product:" + productId;
        RLock lock = redissonClient.getLock(lockKey);

        try {
            // 加锁（自动续期，防止业务耗时过长锁过期）
            // waitTime: 等待锁的最大时间（5秒）
            // leaseTime: 锁自动释放时间（30秒，防止死锁）
            boolean locked = lock.tryLock(5, 30, TimeUnit.SECONDS);
            if (!locked) {
                System.out.println("获取锁失败，稍后再试");
                return false;
            }

            // 检查并扣减库存
            if (stock >= count) {
                Thread.sleep(100); // 模拟业务耗时
                stock -= count;
                System.out.println("扣减成功，剩余库存：" + stock);
                return true;
            } else {
                System.out.println("库存不足");
                return false;
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return false;
        } finally {
            // 释放锁（只有自己加的锁才能释放）
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}