Redis锁与DB锁的使用与区别小结

@Service
public class SeckillService {
    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private SeckillMapper seckillMapper;
    @Autowired
    private RedisTemplate<String, Integer> redisTemplate;
 
    // 秒杀核心方法
    public String seckill(String productId, String userId) {
        // 1. 定义Redis锁key（粒度：商品ID，确保同一商品的秒杀串行）
        String lockKey = "seckill_lock:" + productId;
        RLock lock = redissonClient.getLock(lockKey);
 
        try {
            // 2. 获取锁（等待时间10秒，锁自动过期30秒，防止死锁）
            boolean lockSuccess = lock.tryLock(10, 30, TimeUnit.SECONDS);
            if (!lockSuccess) {
                return "秒杀太火爆了，请稍后重试！";
            }
 
            // 3. 业务逻辑：先查Redis库存（缓存），再扣减，最后同步到DB
            Integer stock = redisTemplate.opsForValue().get("seckill_stock:" + productId);
            if (stock == null || stock <= 0) {
                return "秒杀已结束！";
            }
            // 扣减Redis库存
            redisTemplate.opsForValue().decrement("seckill_stock:" + productId);
            // 生成订单（异步写入DB，提升性能）
            seckillMapper.createOrder(productId, userId);
            return "秒杀成功！";
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return "秒杀失败，请重试！";
        } finally {
            // 4. 释放锁（只有持有锁的线程才能释放）
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }
}

@Service
public class SeckillService {
    @Autowired
    private SeckillMapper seckillMapper;
 
    // 秒杀核心方法（事务内执行）
    @Transactional(rollbackFor = Exception.class)
    public String seckill(String productId, String userId) {
        // 1. 获取DB行锁（根据商品ID锁定库存记录，悲观锁）
        SeckillStock stock = seckillMapper.selectStockByProductIdForUpdate(productId);
        if (stock == null || stock.getStock() <= 0) {
            return "秒杀已结束！";
        }
 
        // 2. 扣减库存
        seckillMapper.decrementStock(productId);
        // 3. 生成订单
        seckillMapper.createOrder(productId, userId);
        return "秒杀成功！";
    }
}
 
// Mapper接口
public interface SeckillMapper {
    @Select("SELECT * FROM seckill_stock WHERE product_id = #{productId} FOR UPDATE")
    SeckillStock selectStockByProductIdForUpdate(String productId);
 
    @Update("UPDATE seckill_stock SET stock = stock - 1 WHERE product_id = #{productId}")
    int decrementStock(String productId);
 
    @Insert("INSERT INTO seckill_order (product_id, user_id) VALUES (#{productId}, #{userId})")
    void createOrder(String productId, String userId);
}

@Service
public class TransferService {
    @Autowired
    private AccountMapper accountMapper;
 
    // 转账核心方法（事务内执行，保证原子性）
    @Transactional(rollbackFor = Exception.class)
    public String transfer(String fromUserId, String toUserId, BigDecimal amount) {
        // 1. 校验金额
        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
            return "转账金额必须大于0！";
        }
 
        // 2. 获取用户A的行锁（扣减余额前加锁，防止并发扣减）
        Account fromAccount = accountMapper.selectByUserIdForUpdate(fromUserId);
        if (fromAccount == null) {
            return "转出账户不存在！";
        }
        // 校验余额
        if (fromAccount.getBalance().compareTo(amount) < 0) {
            return "余额不足！";
        }
 
        // 3. 获取用户B的行锁（防止并发更新）
        Account toAccount = accountMapper.selectByUserIdForUpdate(toUserId);
        if (toAccount == null) {
            return "转入账户不存在！";
        }
 
        // 4. 扣减用户A的余额
        accountMapper.decrementBalance(fromUserId, amount);
        // 5. 增加用户B的余额
        accountMapper.incrementBalance(toUserId, amount);
 
        return "转账成功！";
    }
}
 
// Mapper接口
public interface AccountMapper {
    @Select("SELECT * FROM account WHERE user_id = #{userId} FOR UPDATE")
    Account selectByUserIdForUpdate(String userId);
 
    @Update("UPDATE account SET balance = balance - #{amount} WHERE user_id = #{userId}")
    int decrementBalance(String userId, BigDecimal amount);
 
    @Update("UPDATE account SET balance = balance + #{amount} WHERE user_id = #{userId}")
    int incrementBalance(String userId, BigDecimal amount);
}

@Service
public class TransferService {
    @Autowired
    private RedissonClient redissonClient;
    @Autowired
    private AccountMapper accountMapper;
 
    public String transfer(String fromUserId, String toUserId, BigDecimal amount) {
        // 1. 定义Redis锁key（粒度：用户ID，按字典序加锁）
        String lockKey1 = "transfer_lock:" + (fromUserId.compareTo(toUserId) < 0 ? fromUserId : toUserId);
        String lockKey2 = "transfer_lock:" + (fromUserId.compareTo(toUserId) > 0 ? fromUserId : toUserId);
        RLock lock1 = redissonClient.getLock(lockKey1);
        RLock lock2 = redissonClient.getLock(lockKey2);
 
        try {
            // 2. 批量获取锁（等待时间10秒，锁过期30秒）
            boolean lockSuccess = RedissonMultiLock(lock1, lock2).tryLock(10, 30, TimeUnit.SECONDS);
            if (!lockSuccess) {
                return "转账请求处理中，请稍后重试！";
            }
 
            // 3. 业务逻辑（扣减+增加余额，无事务保障）
            Account fromAccount = accountMapper.selectByUserId(fromUserId);
            if (fromAccount == null || fromAccount.getBalance().compareTo(amount) < 0) {
                return "余额不足或账户不存在！";
            }
            Account toAccount = accountMapper.selectByUserId(toUserId);
            if (toAccount == null) {
                return "转入账户不存在！";
            }
 
            // 4. 扣减余额（无事务，可能出现扣减成功但增加失败）
            accountMapper.decrementBalance(fromUserId, amount);
            // 模拟网络异常：此处若服务宕机，A的余额被扣减，B的余额未增加，资金丢失
            // int a = 1 / 0;
            accountMapper.incrementBalance(toUserId, amount);
 
            return "转账成功！";
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return "转账失败，请重试！";
        } finally {
            // 5. 释放锁
            if (lock1.isHeldByCurrentThread()) {
                lock1.unlock();
            }
            if (lock2.isHeldByCurrentThread()) {
                lock2.unlock();
            }
        }
    }
}