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();
            }
        }
    }
}