【Java】@Transactional事务套着ReentrantLock锁,锁竟然失效超卖了

简介: 本文通过一个生动的例子,探讨了Java中加锁仍可能出现超卖问题的原因及解决方案。作者“JavaDog程序狗”通过模拟空调租赁场景,详细解析了超卖现象及其背后的多线程并发问题。文章介绍了四种解决超卖的方法:乐观锁、悲观锁、分布式锁以及代码级锁,并重点讨论了ReentrantLock的使用。此外,还分析了事务套锁失效的原因及解决办法,强调了事务边界的重要性。

前言

🍊缘由

Java事务套着锁,就像女色缠着我

🏀事情起因:

大家好,我是JavaDog程序狗

在一个阳光明媚的中午,我的师傅突然找到我,问了我如下一个问题:

Java中已经加了锁,为什么结果却还是超卖了!

先解释下上述的几个关键词

  • 我的师傅:前阿里大牛,目前屈居青岛大厂管理岗......此处省略一万字夸赞

  • 加锁:模拟使用ReentrantLock加锁,多线程下建议使用Redisson分布式锁实现

  • 超卖:是指系统允许多个用户购买或预订超过实际可用数量的资源

各位小伙伴先有个印象,后续本狗会详细讲解关键词


🎯主要目标

实现4大重点

1. 什么是超卖
2. 超卖如何解决
3. 事务套锁失效问题
4. 解决锁失效问题

🎁如何获取源码

本狗将测试的所有代码均已上传,包含多个示例,小伙伴们可亲测

公众号:【JavaDog程序狗】

关注公众号,发送 “lock”,无任何套路即可获得!

正文

🍅情景前置

空调租赁充值时长超卖问题

因我师傅遇到的问题代码涉及隐私,我们就模拟一个场景来分析我们的问题

举例🌰

炎炎夏日,狗哥宿舍因忍受不了酷热,租赁了一台空调,大家在清爽空调的吹拂下渐渐迷失自我

随着租赁时长到期,空调暂停工作,需要我们充值空调使用时长

我们宿舍100个赤膊大汉,分分掏出自己手机同时进行空调使用时长充值......并发超卖问题由此而来

为此设计了一个设备表,用于下方演示调试

CREATE TABLE `device` (
  `id` bigint(20) NOT NULL COMMENT '主键',
  `use_times` int(10) DEFAULT '0' COMMENT '使用时长',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

🥦目标分析

一. 什么是超卖?

系统允许多个用户购买或预订超过实际可用数量的资源

👽人话解释

某件商品库存数量1件,结果卖给2个人;更形象的就是双胞胎,一个爱情结晶却喜提两个宝贝

结合上述情景前置,就是宿舍这100个人同时并发操作,按照正常逻辑每个人充值都会在基数+1小时,则总使用时长应为100。

但因为多线程并发问题,可能会导致A和B同时处理逻辑时,获取基数都是同一个,+1后同时更新入库,这样最终的总使用时长就会小于100,出现超卖问题。

出现超卖的代码
@GetMapping("/A")
@Operation(summary = "方式A-更新设备-普通方法(会出现超卖)")
public void payA(@RequestParam Long deviceId) throws InterruptedException {
   
   
    for(int i=0; i<100; i++){
   
   
        // 暂停20毫秒,模拟不同时间,不同人请求并发
        Thread.sleep(20);
        // 模拟是个100线程
        new Thread(() -> {
   
   
            // 更新设备-普通方法
            deviceService.updateDeviceNormal(deviceId);
        }).start();
    }
}
@Override
public void updateDeviceNormal(Long deviceId) {
   
   
    Device device = this.getById(deviceId);
    LambdaUpdateWrapper<Device> updateWrapper = new LambdaUpdateWrapper<>();
    updateWrapper.eq(Device::getId, deviceId);
    updateWrapper.set(Device::getUseTimes, device.getUseTimes()+1);
    this.update(updateWrapper);
}
出现超卖的代码截图

出现超卖的代码调试

可以启动本狗代码,访问http://localhost:1026/lock ,查看swagger文档,或者使用postman都是一样的

出现超卖测试结果


二. 超卖如何解决

  • 乐观锁
    通常通过在数据库表中增加一个版本号(version)字段来实现。在更新时,系统会检查当前版本号是否与请求时的版本号相匹配,如果匹配则更新,否则认为数据已被其他事务修改,当前事务失败。

  • 悲观锁
    数据被读取时就锁定数据,直到事务结束。在数据库中,可以通过SELECT ... FOR UPDATE语句来实现,这会阻止其他事务对锁定的数据进行修改,直到当前事务完成。

  • 分布式锁
    在分布式系统中,单个节点的锁机制不足以保证数据的一致性,因此需要使用分布式锁,如Redisson

  • 代码锁
    使用 synchronized 关键字或者使用 ReentrantLock等

解决方式有很多种,我们举例以ReentrantLock为例,但首先我们要了解什么是ReentrantLock?

ReentrantLock 是 Java 平台上的一个可重入的互斥锁,它属于 java.util.concurrent.locks 包的一部分。与传统的 synchronized 关键字相比,ReentrantLock 提供了更多高级功能和更大的灵活性。

再啰嗦解释一下,什么是可重入的互斥锁?

可重入的互斥锁是一种特殊的锁机制,它允许在同一个线程内多次获取而不造成死锁。通常,互斥锁(mutex)在一个线程获取后,会阻止其他线程获取该锁,直到锁被释放。然而,可重入的互斥锁允许一个线程在已经获取了锁的情况下再次获取锁,而不会引起死锁,而是增加锁的持有计数。当这个线程最终释放锁时,它必须释放相同的次数才能完全释放锁,让其他线程有机会获取。

加入ReentrantLock代码
@GetMapping("/B")
@Operation(summary = "方式B-更新设备-使用ReentrantLock(不会出现超卖)")
public void payB(@RequestParam Long deviceId) throws InterruptedException {
   
   
    // 模拟是个10线程
    for(int i=0; i<100; i++){
   
   
        // 暂停20毫秒,模拟不同时间,不同人请求并发
        Thread.sleep(20);
        // 创建线程
        new Thread(() -> {
   
   
            // 更新设备-使用ReentrantLock。
            deviceService.updateDeviceByLock(deviceId);
        }).start();
    }
}
Lock lock = new ReentrantLock();
@Override
public void updateDeviceByLock(Long deviceId) {
   
   
    lock.lock();
    Device device = this.getById(deviceId);
    LambdaUpdateWrapper<Device> updateWrapper = new LambdaUpdateWrapper<>();
    updateWrapper.eq(Device::getId, deviceId);
    updateWrapper.set(Device::getUseTimes, device.getUseTimes()+1);
    try {
   
   
        this.update(updateWrapper);
    } catch (Exception e) {
   
   
        throw new RuntimeException(e);
    } finally {
   
   
        lock.unlock();
    }
}
加入ReentrantLock代码截图

ReentrantLock代码调试

ReentrantLock测试结果


三. 事务套锁失效问题

上面第二步已经通过加入ReentrantLock成功解决超卖问题

BUT,我师傅的代码中却还存在超卖问题,排查一下,原来在锁外面加入了事务@Transactional

事务套锁失效代码
@GetMapping("/C")
@Operation(summary = "方式C-更新设备-使用事务套锁(锁失效)")
public void payC(@RequestParam Long deviceId) throws InterruptedException {
   
   
    for(int i=0; i<100; i++){
   
   
        // 暂停20毫秒,模拟不同时间,不同人请求并发
        Thread.sleep(20);
        // 模拟是个100线程
        new Thread(() -> {
   
   
            // 更新-使用事务套锁
            deviceService.updateDeviceByTansaction(deviceId);
        }).start();
    }
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updateDeviceByTansaction(Long deviceId) {
   
   
    // 加锁
    lock.lock();
    Device device = this.getById(deviceId);
    LambdaUpdateWrapper<Device> updateWrapper = new LambdaUpdateWrapper<>();
    updateWrapper.eq(Device::getId, deviceId);
    updateWrapper.set(Device::getUseTimes, device.getUseTimes()+1);
    try {
   
   
        this.update(updateWrapper);
    } catch (Exception e) {
   
   
        throw new RuntimeException(e);
    } finally {
   
   
        // 解锁
        lock.unlock();
    }
}
事务套锁失效代码截图

事务套锁失效代码调试

事务套锁失效测试结果

❓为什么加入事务就导致锁失效了呢?

✅答案是因为事务边界问题

使用@Transactional 注解来管理事务,但锁的获取和释放并没有放在事务边界之内。这意味着如果在事务提交之前锁就被释放了,其他线程可能在当前事务结束之前修改相同的数据,这会导致数据不一致

四. 解决锁失效问题

通过上面分析事务套锁失效问题,我们可以采取事务边界缩小,尽量不要让事务边界过大,从而导致包裹着锁导致并发数据问题

事务边界缩小代码
@GetMapping("/D")
@Operation(summary = "方式D-更新设备-缩小事务便捷方法(锁正常-不会出现超卖)")
public void payD(@RequestParam Long deviceId) throws InterruptedException {
   
   
    for(int i=0; i<100; i++){
   
   
        // 暂停20毫秒,模拟不同时间,不同人请求并发
        Thread.sleep(20);
        // 模拟是个100线程
        new Thread(() -> {
   
   
            // 更新-使用原子性更新
            deviceService.updateDeviceByReduce(deviceId);
        }).start();
    }
}
@Override
public void updateDeviceByReduce(Long deviceId) {
   
   
     try {
   
   
         // 加锁
         lock.lock();
         this.updateDevice(deviceId);
     } finally {
   
   
         // 解锁
         lock.unlock();
     }
 }

 @Transactional(rollbackFor = Exception.class)
 public void updateDevice(Long deviceId){
   
   
     Device device = this.getById(deviceId);
     LambdaUpdateWrapper<Device> updateWrapper = new LambdaUpdateWrapper<>();
     updateWrapper.eq(Device::getId, deviceId);
     updateWrapper.set(Device::getUseTimes, device.getUseTimes()+1);
     this.update(updateWrapper);
 }
事务边界缩小代码截图

事务边界缩小代码调试

事务边界缩小测试结果

总结

处理并发和超卖问题时,理解并合理运用锁机制和事务管理至关重要。

通过将锁操作置于事务边界内,可以有效防止数据不一致,确保系统的稳定性和可靠性

在实际应用中,根据业务特性和性能要求选择最合适的解决方案是关键

解决方案概述

  • 乐观锁:通过版本号或时间戳检查数据是否已被其他事务修改,适用于读多写少的场景。

  • 悲观锁:预先锁定数据直至事务完成,适合写操作频繁或数据竞争激烈的场景。

  • 分布式锁:如Redisson,确保分布式系统中数据的一致性,适用于跨节点的数据同步。

  • 代码级锁:利用synchronized或ReentrantLock等机制,控制线程间的访问顺序,防止并发冲突。

事务边界的重要性

  • 关键点:确保锁的获取和释放严格位于事务边界内,避免数据在事务未完成前被其他线程修改。

  • 实践:使用try-finally结构包裹锁的获取和释放,确保即使发生异常,锁也能正确释放,维护数据完整性。


🍯猜你喜欢

文章推荐

【规范】Git分支管理,看看我司是咋整的

【工具】珍藏免费宝藏工具,不好用你来捶我

【插件】IDEA这款插件,爱到无法自拔

【规范】看看人家Git提交描述,那叫一个规矩

【工具】用nvm管理nodejs版本切换,真香!

【项目实战】SpringBoot+uniapp+uview2打造H5+小程序+APP入门学习的聊天小项目

【项目实战】SpringBoot+uniapp+uview2打造一个企业黑红名单吐槽小程序

【模块分层】还不会SpringBoot项目模块分层?来这手把手教你!

目录
相关文章
|
10天前
|
安全 Java 调度
Java编程时多线程操作单核服务器可以不加锁吗?
Java编程时多线程操作单核服务器可以不加锁吗?
26 2
|
24天前
|
存储 缓存 安全
【Java面试题汇总】多线程、JUC、锁篇(2023版)
线程和进程的区别、CAS的ABA问题、AQS、哪些地方使用了CAS、怎么保证线程安全、线程同步方式、synchronized的用法及原理、Lock、volatile、线程的六个状态、ThreadLocal、线程通信方式、创建方式、两种创建线程池的方法、线程池设置合适的线程数、线程安全的集合?ConcurrentHashMap、JUC
【Java面试题汇总】多线程、JUC、锁篇(2023版)
|
12天前
|
算法 Java 关系型数据库
Java中到底有哪些锁
【9月更文挑战第24天】在Java中,锁主要分为乐观锁与悲观锁、自旋锁与自适应自旋锁、公平锁与非公平锁、可重入锁以及独享锁与共享锁。乐观锁适用于读多写少场景,通过版本号或CAS算法实现;悲观锁适用于写多读少场景,通过加锁保证数据一致性。自旋锁与自适应自旋锁通过循环等待减少线程挂起和恢复的开销,适用于锁持有时间短的场景。公平锁按请求顺序获取锁,适合等待敏感场景;非公平锁性能更高,适合频繁加解锁场景。可重入锁支持同一线程多次获取,避免死锁;独享锁与共享锁分别用于独占和并发读场景。
|
20天前
|
Java 数据库
JAVA并发编程-一文看懂全部锁机制
曾几何时,面试官问:java都有哪些锁?小白,一脸无辜:用过的有synchronized,其他不清楚。面试官:回去等通知! 今天我们庖丁解牛说说,各种锁有什么区别、什么场景可以用,通俗直白的分析,让小白再也不怕面试官八股文拷打。
|
20天前
|
安全 Java 开发者
Java并发编程中的锁机制解析
本文深入探讨了Java中用于管理多线程同步的关键工具——锁机制。通过分析synchronized关键字和ReentrantLock类等核心概念,揭示了它们在构建线程安全应用中的重要性。同时,文章还讨论了锁机制的高级特性,如公平性、类锁和对象锁的区别,以及锁的优化技术如锁粗化和锁消除。此外,指出了在高并发环境下锁竞争可能导致的问题,并提出了减少锁持有时间和使用无锁编程等策略来优化性能的建议。最后,强调了理解和正确使用Java锁机制对于开发高效、可靠并发应用程序的重要性。
19 3
|
1月前
|
Oracle Java 关系型数据库
【颠覆性升级】JDK 22:超级构造器与区域锁,重塑Java编程的两大基石!
【9月更文挑战第6天】JDK 22的发布标志着Java编程语言在性能和灵活性方面迈出了重要的一步。超级构造器和区域锁这两大基石的引入,不仅简化了代码设计,提高了开发效率,还优化了垃圾收集器的性能,降低了应用延迟。这些改进不仅展示了Oracle在Java生态系统中的持续改进和创新精神,也为广大Java开发者提供了更多的可能性和便利。我们有理由相信,在未来的Java编程中,这些新特性将发挥越来越重要的作用,推动Java技术不断向前发展。
|
19天前
|
Java
JAVA并发编程ReentrantLock核心原理剖析
本文介绍了Java并发编程中ReentrantLock的重要性和优势,详细解析了其原理及源码实现。ReentrantLock作为一种可重入锁,弥补了synchronized的不足,如支持公平锁与非公平锁、响应中断等。文章通过源码分析,展示了ReentrantLock如何基于AQS实现公平锁和非公平锁,并解释了两者的具体实现过程。
|
1月前
|
安全 Java API
Java线程池原理与锁机制分析
综上所述,Java线程池和锁机制是并发编程中极其重要的两个部分。线程池主要用于管理线程的生命周期和执行并发任务,而锁机制则用于保障线程安全和防止数据的并发错误。它们深入地结合在一起,成为Java高效并发编程实践中的关键要素。
19 0
|
2月前
|
传感器 C# 监控
硬件交互新体验:WPF与传感器的完美结合——从初始化串行端口到读取温度数据,一步步教你打造实时监控的智能应用
【8月更文挑战第31天】本文通过详细教程,指导Windows Presentation Foundation (WPF) 开发者如何读取并处理温度传感器数据,增强应用程序的功能性和用户体验。首先,通过`.NET Framework`的`Serial Port`类实现与传感器的串行通信;接着,创建WPF界面显示实时数据;最后,提供示例代码说明如何初始化串行端口及读取数据。无论哪种传感器,只要支持串行通信,均可采用类似方法集成到WPF应用中。适合希望掌握硬件交互技术的WPF开发者参考。
43 0
|
2月前
|
开发者 C# Windows
WPF与游戏开发:当桌面应用遇见游戏梦想——利用Windows Presentation Foundation打造属于你的2D游戏世界,从环境搭建到代码实践全面解析新兴开发路径
【8月更文挑战第31天】随着游戏开发技术的进步,WPF作为.NET Framework的一部分,凭借其图形渲染能力和灵活的UI设计,成为桌面游戏开发的新选择。本文通过技术综述和示例代码,介绍如何利用WPF进行游戏开发。首先确保安装最新版Visual Studio并创建WPF项目。接着,通过XAML设计游戏界面,并在C#中实现游戏逻辑,如玩家控制和障碍物碰撞检测。示例展示了创建基本2D游戏的过程,包括角色移动和碰撞处理。通过本文,WPF开发者可更好地理解并应用游戏开发技术,创造吸引人的桌面游戏。
100 0