前言

只有光头才能变强。

文本已收录至我的GitHub仓库,欢迎Star:https://github.com/ZhongFuCheng3y/3y

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

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

https://www.zhihu.com/question/277812143

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

Service层代码:

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

用1000个线程跑代码:

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

一、我的思考

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

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

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

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

(参考我之前写过的Spring事务:一文带你看懂Spring事务!)

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

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

  
  1. @RestController 
  2. public class EmployeeController { 
  3.  
  4.     @Autowired 
  5.     private EmployeeService employeeService; 
  6.  
  7.     @RequestMapping("/add"
  8.     public void addEmployee() { 
  9.         for (int i = 0; i < 1000; i++) { 
  10.             new Thread(() -> employeeService.addEmployee()).start(); 
  11.         } 
  12.     } 
  13.  
  14.  
  15.  
  16. @Service 
  17. public class EmployeeService { 
  18.  
  19.     @Autowired 
  20.     private EmployeeRepository employeeRepository; 
  21.  
  22.  
  23.     @Transactional 
  24.     public synchronized void addEmployee() { 
  25.  
  26.         // 查出ID为8的记录,然后每次将年龄增加一 
  27.         Employee employee = employeeRepository.getOne(8); 
  28.         System.out.println(employee); 
  29.         Integer age = employee.getAge(); 
  30.         employee.setAge(age + 1); 
  31.  
  32.         employeeRepository.save(employee); 
  33.     } 
  34.  

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

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

二、图解出现的原因

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

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

  
  1. public static void main(String[] args) { 
  2.  
  3.         // 目标对象 
  4.         Object target ; 
  5.  
  6.         Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), Main.class, new InvocationHandler() { 
  7.             @Override 
  8.             public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
  9.  
  10.                 // 但凡带有@Transcational注解的方法都会被拦截 
  11.  
  12.                 // 1... 开启事务 
  13.  
  14.                 method.invoke(target); 
  15.  
  16.                 // 2... 提交事务 
  17.  
  18.                 return null
  19.             } 
  20.              
  21.         }); 
  22.     } 

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

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

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

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

三、解决问题

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

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

  
  1. @RestController 
  2. public class EmployeeController { 
  3.  
  4.     @Autowired 
  5.     private SynchronizedService synchronizedService ; 
  6.  
  7.     @RequestMapping("/add"
  8.     public void addEmployee() { 
  9.         for (int i = 0; i < 1000; i++) { 
  10.             new Thread(() -> synchronizedService.synchronizedAddEmployee()).start(); 
  11.         } 
  12.     } 
  13.  
  14. // 新建的Service类 
  15. @Service 
  16. public class SynchronizedService { 
  17.  
  18.     @Autowired 
  19.     private EmployeeService employeeService ; 
  20.      
  21.     // 同步 
  22.     public synchronized void synchronizedAddEmployee() { 
  23.         employeeService.addEmployee(); 
  24.  
  25.     } 
  26.  
  27. @Service 
  28. public class EmployeeService { 
  29.  
  30.     @Autowired 
  31.     private EmployeeRepository employeeRepository; 
  32.  
  33.      
  34.     @Transactional 
  35.     public void addEmployee() { 
  36.  
  37.         // 查出ID为8的记录,然后每次将年龄增加一 
  38.         Employee employee = employeeRepository.getOne(8); 
  39.         System.out.println(Thread.currentThread().getName() + employee); 
  40.         Integer age = employee.getAge(); 
  41.         employee.setAge(age + 1); 
  42.  
  43.         employeeRepository.save(employee); 
  44.  
  45.     } 

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

最后

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

【责任编辑: 庞桂玉 TEL:(010)68476606】

点赞 0

你可能感兴趣的文章