【事务与锁】当Transactional遇上synchronized

柔情只为你懂 2023-10-04 23:52 1阅读 0赞

### 前言 ###

最近工作中遇到某些七七八八的问题，就是与事务和锁、并发都有着紧密联系相关的问题所在。主要情况是：通过调用方法获取编号，而这个编号是递增有序的，并且存在于数据库中，简单理解就是需要用到这种编号(以下称任务编号)，需要从数据库获取出来，在+1最为本次需要的编号，然后在存回数据库中，提供下次使用。直观来看是没得问题的，但是，可能在某次并发的时候出现编号相同，着属实很令人头疼，在经过领导的指导下是完美的解决了，接下来复盘一下。

### 问题回放 ###

因为公司项目使用WQL作为持久层，但是我这次使用Mybatis-Plus，效果大差不差。新建springboot项目，基础创建不在赘述。主要创建一张简单的数据表，就一个id和number字段。之后用mp自动生成代码。

#### 问题一 ####

最外层加上Transactional注解，并且在对编码操作的方法也加了Transactional注解，为了防止并发问题，加了锁。此时模拟的问题是：在嵌套事务中，父事务延时提交导致获得到的数据出错。

1、代码与结果复现

直接在控制层中调用，这里会加上Transactional，并且一开始数据库数据为\{"id":"1", "number":"460"\}

@GetMapping("/t1")
    @Transactional(rollbackFor = Exception.class)
    public void getTest1() {
        String n = countNumService.getCount();
        System.out.println(" t1 : " + n);
        try {
            Thread.sleep(6000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
    
    @GetMapping("/t2")
    @Transactional(rollbackFor = Exception.class)
    public void getTest2() {
        String n = countNumService.getCount();
        System.out.println(" t2 : " + n);
        // 忽略其他的增删操作
    }
    复制代码

对数据库获取操作的方法，加上Transactional与synchronized。

@Override
    @Transactional(rollbackFor = Exception.class)
    public synchronized String getCount() {
        // 获取
        CountNum countNum = countNumMapper.selectById(1);
    
        countNum.setNumber(countNum.getNumber() + 1);
        // 修改
        countNumMapper.updateById(countNum);
    
        return countNum.getNumber().toString();
    }
    复制代码

通过IDEA的插件RestServices(也可以用postman)测试，先请求/t1接口，这里会睡眠6s来模拟事务延时提交，在去请求/t2接口，可以看出得到的数据会是相同的。

![format_png][]

2、原因分析

只有两个线程都能形成两个相同的code，仔细分析一下，假设synchronized锁是锁住的，那为什么会出现这样的问题呢？当t1线程访问getCount()方法，此时他拿到synchronized的锁，在进行获取数据并且+1操作后进行update操作，此时synchronized的锁已经被释放了，但是父事务却没有提交，也就是没有写回到数据库中，接下来t2线程过来了，也拿到了这把锁，又从数据库获取了数据，此时获得的是脏数据，最后就会导致出现了相同的code。

![format_png 1][]

3、解决方法

这里是因为事务的先后提交导致，可以使用Transactional注解的配置来解决，使用@Transactional(propagation = Propagation.REQUIRES\_NEW)，每次都会启动一个新的事务，是Spring事务传播机制的一种级别，表示当前方法必须在自己的事务中运行，如果当前已经存在一个事务，则会挂起该事务，创建一个新的事务用于执行当前方法。当当前方法执行完成后，新事务被提交，原事务恢复执行。

#### 问题二 ####

此次测试是使用apache-jmeter-5.4.3测试工具来测试20次请求的并发情况（接口每次会创建100次，一共会又20\*100次），在以上代码的条件下编写新的接口。

1、问题复现

以下是每次请求都会创建100个线程，getCount()除了使用propagation = Propagation.REQUIRES\_NEW，其他不变。

@GetMapping("/t3")
    @Transactional(rollbackFor = Exception.class)
    public void getTest1() {
        for (int i = 0; i <100 ; i++) {
            new Thread(()->{
                String taskCode = countNumService.getCount();
                System.out.println("t1 " + Thread.currentThread().getName() + " code: " + taskCode);
            }).start();
        }
    }
    复制代码

测试结果就会发现并发下出现了种种问题，会出现相同的code。

![format_png 2][]

2、原因分析

这是由于父子事务嵌套，子事务与锁一起使用，导致了synchronized锁的失效。当我把事务去掉的时候，则就不会出现并发的问题。

![format_png 3][]

问题就是出在事务与synchronized锁的共同使用导致的，如果既要保证并发不出问题，又要保证在异常的时候需要回滚数据，在实际应用中，getCount()内部又其他对数据库的操作，因此需要事务来保证异常的回滚，也就是一定需要父子事务的嵌套，在这种情况下需要怎么做处理？ 首先先来了解事务Transactional与锁synchronized一同使用会带来什么问题。

### 事务Transactional与锁synchronized ###

事务Transactional与锁synchronized他们是两种不一样的机制，两种机制要是一起使用，可能会出现一些问题。

#### 1、synchronized与Transactional区别 ####

首先，synchronized锁是用来实现线程同步，防止多个线程同时访问共享资源导致的并发问题。而Transactional是Spring框架中用于管理事务的机制，用于保证多个操作的四个特性（原子性、一致性、隔离性和持久性）。

#### 2、可能带来的问题 ####

1.  事务可能被锁定：如果在一个方法中使用synchronized锁定了某个共享资源，同时该方法又使用了Transactional来管理事务，那么其他线程在访问该方法时可能会被阻塞，因为事务被锁定了。
2.  死锁问题：如果在多个线程中同时使用synchronized和Transactional，可能会导致死锁问题，因为synchronized锁定的资源可能被多个线程同时访问，而Transactional又会对这些操作进行管理，可能会导致事务的死锁。
3.  性能问题：如果在一个高并发的系统中同时使用synchronized和Transactional，可能会导致性能问题，因为synchronized会导致线程阻塞，而Transactional又会增加事务的开销，从而影响系统的性能。

#### 3、针对问题二的解决 ####

可以将子事务中的锁移到父事务中，优化一下细粒度，就只对获取任务编码的这条语句进行上锁。

@GetMapping("/t4")
    @Transactional(rollbackFor = Exception.class)
    public void getTest4() {
        for (int i = 0; i <100 ; i++) {
            new Thread(()->{
                synchronized(CountNumController.class) {
                    String taskCode = countNumService.getCount();
                    System.out.println("t4 " + Thread.currentThread().getName() + " code: " + taskCode);
                }
            }).start();
        }
    }
    复制代码

这样就能保证并发不出问题，也能保证将父子事务都存在。

![format_png 4][]

[format_png]: https://img-blog.csdnimg.cn/img_convert/bcf6a55b786aba3926483ca503c3bf82.webp?x-oss-process=image/format,png
[format_png 1]: https://img-blog.csdnimg.cn/img_convert/66f08ec96ef58d88f1270c040c52c0d0.webp?x-oss-process=image/format,png
[format_png 2]: https://img-blog.csdnimg.cn/img_convert/0f14cafca3bf47fc5585bb5d23159512.webp?x-oss-process=image/format,png
[format_png 3]: https://img-blog.csdnimg.cn/img_convert/1258d3c953920a0869e66c7b9913f00c.webp?x-oss-process=image/format,png
[format_png 4]: https://img-blog.csdnimg.cn/img_convert/b2a5f5f91b2e2d37708713595e8a3344.webp?x-oss-process=image/format,png