一个Spring事务线程安全的问题，望周知！

系统管理员 2021-08-28 01:45 198阅读 0赞

## 前言 ##

Spring事务的一个奇怪的问题。

朋友问了我一个技术的问题(朋友实在是好学，佩服！)

该问题来源知乎(synchronized锁问题)：

*  [https://www.zhihu.com/question/277812143][https_www.zhihu.com_question_277812143]

> 开启10000个线程，每个线程给员工表的money字段【初始值是0】加1，没有使用悲观锁和乐观锁，但是在业务层方法上加了synchronized关键字，问题是代码执行完毕后数据库中的money 字段不是10000，而是小于10000 问题出在哪里？

Service层代码：

![代码][format_png]

SQL代码(没有加悲观/乐观锁)：

![SQL代码(没有加悲观/乐观锁)][SQL]

用1000个线程跑代码：

![用1000个线程跑代码：][1000]

简单来说：多线程跑一个使用**synchronized**关键字修饰的方法，方法内操作的是数据库，按正常逻辑应该最终的值是1000，但经过多次测试，结果是**低于**1000。这是为什么呢？

## 一、我的思考 ##

既然测试出来的结果是低于1000，那说明这段代码**不是线程安全**的。不是线程安全的，那问题出现在哪呢？众所周知，synchronized方法能够保证所修饰的`代码块、方法`保证`有序性、原子性、可见性`。

讲道理，以上的代码跑起来，问题中`Service`层的`increaseMoney()`是`有序的、原子的、可见的`，所以**断定**跟synchronized应该没关系。

(参考我之前写过的synchronize锁笔记：[Java锁机制了解一下][Java])

既然Java层面上找不到原因，那分析一下数据库层面的吧(因为方法内操作的是数据库)。在`increaseMoney()`方法前加了`@Transcational`注解，说明这个方法是带有**事务**的。事务能保证同组的SQL要么同时成功，要么同时失败。讲道理，如果没有报错的话，应该每个线程都对money值进行`+1`。从理论上来说，结果应该是1000的才对。

(参考我之前写过的Spring事务：[一文带你看懂Spring事务！][Spring])

根据上面的分析，我怀疑是**提问者没测试好**(hhhh，逃)，于是我也跑去测试了一下，发现是以提问者的方式来使用**是真的有问题**。

首先贴一下我的测试代码：

@RestController
    public class EmployeeController { 
    
        @Autowired
        private EmployeeService employeeService;
    
        @RequestMapping("/add")
        public void addEmployee() { 
            for (int i = 0; i < 1000; i++) { 
                new Thread(() -> employeeService.addEmployee()).start();
            }
        }
    
    
    }
    
    @Service
    public class EmployeeService { 
    
        @Autowired
        private EmployeeRepository employeeRepository;
    
    
        @Transactional
        public synchronized void addEmployee() { 
    
            // 查出ID为8的记录，然后每次将年龄增加一
            Employee employee = employeeRepository.getOne(8);
            System.out.println(employee);
            Integer age = employee.getAge();
            employee.setAge(age + 1);
    
            employeeRepository.save(employee);
        }
    
    }

简单地打印了每次拿到的employee值，并且拿到了SQL执行的顺序，如下(贴出小部分)：

![SQL执行的顺序][SQL 1]

从打印的情况我们可以得出：多线程情况下并**没有串行**执行`addEmployee()`方法。这就导致对同一个值做**重复**的修改，所以最终的数值比1000要少。

## 二、图解出现的原因 ##

发现并不是**同步**执行的，于是我就怀疑`synchronized`关键字和Spring肯定有点冲突。于是根据这两个关键字搜了一下，找到了问题所在。

我们知道Spring事务的底层是Spring AOP，而Spring AOP的底层是动态代理技术。跟大家一起回顾一下动态代理：

public static void main(String[] args) { 
    
            // 目标对象
            Object target ;
    
            Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), Main.class, new InvocationHandler() { 
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
    
                    // 但凡带有@Transcational注解的方法都会被拦截
    
                    // 1... 开启事务
    
                    method.invoke(target);
    
                    // 2... 提交事务
    
                    return null;
                }
                
            });
        }

(详细请参考我之前写过的动态代理：[给女朋友讲解什么是代理模式][Link 1])

实际上Spring做的处理跟以上的思路是一样的，我们可以看一下TransactionAspectSupport类中`invokeWithinTransaction()`：

![Spring事务管理是如何实现的][Spring 1]

调用方法**前**开启事务，调用方法**后**提交事务

![Spring事务和synchronized锁互斥问题][Spring_synchronized]

在多线程环境下，就可能会出现：**方法执行完了(synchronized代码块执行完了)，事务还没提交，别的线程可以进入被synchronized修饰的方法，再读取的时候，读到的是还没提交事务的数据，这个数据不是最新的**，所以就出现了这个问题。

![事务未提交，别的线程读取到旧数据][format_png 1]

## 三、解决问题 ##

从上面我们可以发现，问题所在是因为`@Transcational`注解和`synchronized`一起使用了，**加锁的范围没有包括到整个事务**。所以我们可以这样做：

新建一个名叫SynchronizedService类，让其去调用`addEmployee()`方法，整个代码如下：

@RestController
    public class EmployeeController { 
    
        @Autowired
        private SynchronizedService synchronizedService ;
    
        @RequestMapping("/add")
        public void addEmployee() { 
            for (int i = 0; i < 1000; i++) { 
                new Thread(() -> synchronizedService.synchronizedAddEmployee()).start();
            }
        }
    }
    
    // 新建的Service类
    @Service
    public class SynchronizedService { 
    
        @Autowired
        private EmployeeService employeeService ;
    	
        // 同步
        public synchronized void synchronizedAddEmployee() { 
            employeeService.addEmployee();
    
        }
    }
    
    @Service
    public class EmployeeService { 
    
        @Autowired
        private EmployeeRepository employeeRepository;
    
        
        @Transactional
        public void addEmployee() { 
    
            // 查出ID为8的记录，然后每次将年龄增加一
            Employee employee = employeeRepository.getOne(8);
            System.out.println(Thread.currentThread().getName() + employee);
            Integer age = employee.getAge();
            employee.setAge(age + 1);
    
            employeeRepository.save(employee);
    
        }
    }

我们将synchronized锁的范围**包含到整个Spring事务上**，这就不会出现线程安全的问题了。在测试的时候，我们可以发现1000个线程跑起来**比之前要慢得多**，当然我们的数据是正确的：

![正确的数据][format_png 2]

可以发现的是，虽然说Spring事务用起来我们是非常方便的，但如果不了解一些Spring事务的细节，很多时候出现Bug了就百思不得其解。还是得继续加油努力呀~~~

#### 涵盖Java后端所有知识点的开源项目（已有5.8K star）：https://github.com/ZhongFuCheng3y/3y ####

如果大家想要**实时**关注我更新的文章以及分享的干货的话，微信搜索**Java3y**。

PDF文档的内容**均为手打**，有任何的不懂都可以直接**来问我**（公众号有我的联系方式）。

![format_png 3][]

![format_png 4][]

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA2dE5iUndseTFnYjBuenBuOHo3ZzMwZ28wZ29rYnAuZ2lm][]

![aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY3Rza203d3lsZzMwOGMwNTJuazUuZ2lm][]

[https_www.zhihu.com_question_277812143]: https://www.zhihu.com/question/277812143
[format_png]: /images/20210827/a1698831fa0d4932bcbda97b5596c42a.png
[SQL]: /images/20210827/46f710a247274ae9b2b45d651ed0bbbf.png
[1000]: /images/20210827/bec330916dd2443ea3648a6cc64390db.png
[Java]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484198&idx=1&sn=4d8e372165bb49987a6243f17153a9b4&chksm=ebd74227dca0cb31311886f835092c9360d08a9f0a249ece34d4b1e49a31c9ec773fa66c8acc&scene=21#wechat_redirect
[Spring]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484721&idx=5&sn=67467f35a9e9314aa3d1c07ff250af6b&chksm=ebd74430dca0cd26c94daf2d3e34806c29d05583de2255b98d20d34cd86e12ae94624d33be1b&token=1885756144&lang=zh_CN#rd
[SQL 1]: /images/20210827/763e551a162b4a34ad5099aedd9f5e44.png
[Link 1]: https://mp.weixin.qq.com/s?__biz=MzI4Njg5MDA5NA==&mid=2247484222&idx=1&sn=5191aca33f7b331adaef11c5e07df468&chksm=ebd7423fdca0cb29cdc59b4c79afcda9a44b9206806d2212a1b807c9f5879674934c37c250a1&scene=21#wechat_redirect
[Spring 1]: /images/20210827/5f4bfbc81601456eb36fdca00e7174d0.png
[Spring_synchronized]: /images/20210827/348eb65dcad6483a8a8c8eb9faabda81.png
[format_png 1]: /images/20210827/573bee7641c0471c8d7aabb100638722.png
[format_png 2]: /images/20210827/91ef44ec5ba3468f861b334b26bdb1ab.png
[format_png 3]: /images/20210827/0d2559c89bd14daf8a15b82e9e313f8d.png
[format_png 4]: /images/20210827/9855b59e0de14adc874635d0718ebf4b.png
[aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA2dE5iUndseTFnYjBuenBuOHo3ZzMwZ28wZ29rYnAuZ2lm]: /images/20210827/0850701fe1b5467c8bb5fc0ca5270827.png
[aHR0cHM6Ly90dmExLnNpbmFpbWcuY24vbGFyZ2UvMDA4MzFyU1RseTFnY3Rza203d3lsZzMwOGMwNTJuazUuZ2lm]: /images/20210827/a9a3ea0010db4111ab7874282c05a06b.png