异步事务？关于异步@Async + 事务@Transactional的结合使用问题分析【享学Spring MVC】

╰+攻爆jí腚メ 2021-11-08 23:34 1110阅读 0赞

#### 每篇一句 ####

> 将依赖做到精简是中间件岗位最基本的素养，美国童子军也有一条军规：让营地比你来时更干净。 请参阅书籍《Clean Code》

#### 前言 ####

如题，如果把这两者拆开来看的话，两者你应该都不陌生：`@Async`你不陌生，`@Transactional`你应该更不陌生，若单独拿来使用，理论上应该木有不会用的吧。本文不废话，分析一下他俩结合一起使用的case，因为据我了解很多人对结合一起使用时，心里还是打鼓的，这样对生产环境使用还是有隐患的。

相较于`@Transactional`的使用，关于`@Async`的一些使用case相对我估计还是陌生一点，所以文章开头先简单回顾一下`@Async`的使用。

#### `@Async`的使用 ####

关于它的基本使用原理篇，这篇文章其实有过非常详细的分析了，可前往此处深入了解：[【小家Spring】Spring异步处理@Async的使用以及原理、源码分析（@EnableAsync）][Spring_Spring_Async_EnableAsync]

此处我的异步配置`AsyncConfig`如下：

@EnableAsync
    @Configuration
    public class AsyncConfig implements AsyncConfigurer { 
    
        @Override
        public Executor getAsyncExecutor() { 
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    
            executor.setCorePoolSize(10); //核心线程数
            executor.setMaxPoolSize(20);  //最大线程数
            executor.setQueueCapacity(1000); //队列大小
            executor.setKeepAliveSeconds(300); //线程最大空闲时间
            executor.setThreadNamePrefix("fsx-Executor-"); 指定用于新创建的线程名称的前缀。
            executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略（一共四种，此处省略）
    
            executor.initialize();
            return executor;
        }
    
        // 异常处理器：当然你也可以自定义的，这里我就这么简单写了~~~
        @Override
        public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() { 
            return new SimpleAsyncUncaughtExceptionHandler();
        }
    }

示例代码：

> 备注：这个示例代码比你平时使用的应该复杂些，它的特点是**异步里调异步**

@Slf4j
    @Service
    public class HelloServiceImpl implements HelloService { 
    
        @Autowired
        private ApplicationContext applicationContext;
    
        @Override
        public void enter() { 
            System.out.println("enter入口线程：" + Thread.currentThread().getName());
            applicationContext.getBean(HelloService.class).eat();
        }
    
        @Async
        @Override
        public void eat() { 
            System.out.println("eat的线程：" + Thread.currentThread().getName());
            // 在异步线程内继续启动异步线程
            applicationContext.getBean(HelloService.class).play();
        }
    
        @Async
        @Override
        public void play() { 
            System.out.println("play线程：" + Thread.currentThread().getName());
        }
    }

运行测试用例：

@Slf4j
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = { RootConfig.class, AsyncConfig.class})
    public class TestSpringBean { 
    
        @Autowired
        private HelloService helloService;
    
        @Test
        public void test1() { 
            helloService.hello();
        }
    
    }

打印如下：

enter入口线程：main
    eat的线程：fsx-Executor-1
    play线程：fsx-Executor-2

这里我用一个比较极端的案例来说明问题：主线程调用异步线程，**异步线程里继续调用异步线程**的case。  
从打印结果中是可以得出结论的：**只要`@Async`生效，它都会新启一个线程去执行目标方法的，哪怕你不在main线程里启动的都木有关系。**

那么现在开始引入本文关注的情景：`@Async` \+ `@Transactional`把**异步和事务**结合起来。对下面三个方法进行情景代入哈（不喜勿喷）

1.  `enter`方法：餐馆里进来一个人（添加一条记录）
2.  `eat`方法：进来人后开始吃饭（会和数据库打交道）
3.  `play`方法：进来人后在餐馆里玩（会和数据库打交道）

他们三都各自独立完成着一件事，但很显然入口处都在`enter`方法上（进来了才能吃、才能玩嘛~）

下面以全代码示例，模拟一些场景，并给出参考结论（若有若无请给我留言~）：

##### 场景一： #####

@Slf4j
    @Service
    public class HelloServiceImpl implements HelloService { 
        @Autowired
        private ApplicationContext applicationContext;
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        @Transactional
        @Override
        public void enter(Integer age) { 
            String name = "fsx-" + age;
            // 向数据库插入一条记录
            String sql = "insert into user (name,age) values ('" + name + "'," + age + ")";
            jdbcTemplate.update(sql);
    
            // 抛出运行异常
            throw new RuntimeException("enter抛出运行异常");
        }
    }

> 说明：关于案例的基础配置（如配置Async、配置数据源本文就不列出了），参见前面相关文章

运行单测：

当然喽，控制台肯定会有如下异常信息：

java.lang.RuntimeException: 抛出运行异常
    
    	at com.fsx.service.HelloServiceImpl.enter(HelloServiceImpl.java:30)
    	...

现象：异常抛出，`insert`语句未生效（被回滚）。  
结论：事务生效。

##### 场景二： #####

@Slf4j
    @Service
    public class HelloServiceImpl implements HelloService { 
    
        @Autowired
        private ApplicationContext applicationContext;
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        @Transactional
        @Override
        public void enter(Integer age) { 
            System.out.println("enter的线程：" + Thread.currentThread().getName());
    
            String name = "fsx-" + age;
            String sql = "insert into user (name,age) values ('" + name + "'," + age + ")";
            jdbcTemplate.update(sql);
    
            // 进来后开始吃饭（但因为吃饭比较耗时 所以放到Async异步线程里去做）
            applicationContext.getBean(HelloService.class).eat(age);
    
            throw new RuntimeException("enter抛出运行异常");
        }
    
        @Transactional // 因为吃饭也需要原子 所以也加上事务惊醒控制
        @Async
        @Override
        public void eat(Integer age) { 
            System.out.println("eat的线程：" + Thread.currentThread().getName());
    
            String name = "eat-" + age;
            String sql = "insert into eat (eat_name) values ('" + name + "')";
            jdbcTemplate.update(sql);
    
            throw new RuntimeException("eat抛出运行异常");
        }
    }

运行单测：

@Slf4j
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration(classes = { RootConfig.class, AsyncConfig.class, JdbcConfig.class})
    public class TestSpringBean { 
        @Autowired
        private HelloService helloService;
    
        @Test
        public void test1() throws InterruptedException { 
            try { 
                helloService.enter(10);
            } catch (Exception e) { 
                e.printStackTrace();
            }
    
            // 若是单测 请务必持有住主线程 否则子线程被提前结束不生效
            TimeUnit.SECONDS.sleep(3);
        }
    }

这里单测的两个小细节请注意，**否则你可能看不到效果的**：

1.  请使用`try`把主线程的包住（避免因为异常导致主线程中断）
2.  `TimeUnit.SECONDS.sleep(3)`，防止主线程提前退出

打印输出：

enter的线程：main
    java.lang.RuntimeException: enter抛出运行异常
    	at com.fsx.service.HelloServiceImpl.enter(HelloServiceImpl.java:34)
    
    eat的线程：fsx-Executor-1
    java.lang.RuntimeException: eat抛出运行异常
    	at com.fsx.service.HelloServiceImpl.eat(HelloServiceImpl.java:47)

现象：两个异常信息都有输出，异步线程生效，`insert`插入均没有生效（双双完成回滚）  
结论：**主线程和子线程的在事务上是相互隔离的**，子线程的异常不会影响主线程的事务混滚与否（让若主线程不主动throw出异常，子线程即使抛出了异常也不会影响主线程的）。

> 说明：本文中案例所指的主线程并非生产环境实际意义的请求线程，请注意差异~  
> 另外：不同线程中通过`JdbcTemplate`拿到的`Connection`链接一般不是同一个~

##### 场景三： #####

@Slf4j
    @Service
    public class HelloServiceImpl implements HelloService { 
    
        @Autowired
        private ApplicationContext applicationContext;
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        @Transactional
        @Override
        public void enter(Integer age) { 
            System.out.println("enter的线程：" + Thread.currentThread().getName());
    
            String name = "fsx-" + age;
            String sql = "insert into user (name,age) values ('" + name + "'," + age + ")";
            jdbcTemplate.update(sql);
    
            // 进来后开始吃饭（但因为吃饭比较耗时 所以放到Async异步线程里去做）
            applicationContext.getBean(HelloService.class).eat(age);
            applicationContext.getBean(HelloService.class).play(age);
        }
    
        @Transactional // 因为吃饭也需要原子 所以也加上事务惊醒控制
        @Async
        @Override
        public void eat(Integer age) { 
            System.out.println("eat的线程：" + Thread.currentThread().getName());
    
            String name = "eat-" + age;
            String sql = "insert into eat (eat_name) values ('" + name + "')";
            jdbcTemplate.update(sql);
    
            throw new RuntimeException("eat抛出运行异常");
        }
    
        @Transactional
        @Async
        @Override
        public void play(Integer age) { 
            System.out.println("play的线程：" + Thread.currentThread().getName());
    
            String name = "play-" + age;
            String sql = "insert into play (play_name) values ('" + name + "')";
            jdbcTemplate.update(sql);
    
            throw new RuntimeException("play抛出运行异常");
        }
    }

**请注意示例区别：enter方法并没有主动throw抛出异常。**  
现象：user表插入成功。eat和play表均插入无效（被回滚）  
结论：同上

##### 场景四： #####

此场是我模拟的最后一个场景：**异步线程里继续调用异步线程，并且加上事务**。

@Slf4j
    @Service
    public class HelloServiceImpl implements HelloService { 
    
        @Autowired
        private ApplicationContext applicationContext;
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
        @Transactional
        @Override
        public void enter(Integer age) { 
            System.out.println("enter的线程：" + Thread.currentThread().getName());
    
            String name = "fsx-" + age;
            String sql = "insert into user (name,age) values ('" + name + "'," + age + ")";
            jdbcTemplate.update(sql);
    
            // 进来后开始吃饭（但因为吃饭比较耗时 所以放到Async异步线程里去做）
            applicationContext.getBean(HelloService.class).eat(age);
        }
    
        @Transactional // 因为吃饭也需要原子 所以也加上事务惊醒控制
        @Async
        @Override
        public void eat(Integer age) { 
            System.out.println("eat的线程：" + Thread.currentThread().getName());
    
            String name = "eat-" + age;
            String sql = "insert into eat (eat_name) values ('" + name + "')";
            jdbcTemplate.update(sql);
    
            applicationContext.getBean(HelloService.class).play(age);
            throw new RuntimeException("eat抛出运行异常");
        }
    
        @Transactional
        @Async
        @Override
        public void play(Integer age) { 
            System.out.println("play的线程：" + Thread.currentThread().getName());
    
            String name = "play-" + age;
            String sql = "insert into play (play_name) values ('" + name + "')";
            jdbcTemplate.update(sql);
        }
    }

请注意此示例区别：enter里没主动抛出异常。enter异步调用eat，eat**再异步**调用play，并且play里没有抛出异常

现象：user插入成功。eat插入无效（被回滚），play插入成功  
结论：不同线程之间的事务完全隔离，异步线程内仍是可以调用异步~

#### 总结 ####

本文没有新的内容，源于跟一个小伙伴讨论这块时，自己也有些打鼓的地方，因此就写了本文做一个记录，还好所有结论和我"预估"的保持一致。

本文主要是把异步`@Async`和事务`@Transactional`结合使用的一个场景来进行分析，因为开发中也比较常见，因此希望把这两块内容集合使用做些示例，希望可以做到心中有数，这样使用起来才会**更加的胸有成竹**嘛~

--------------------

# 关注A哥 #

<table> 
 <thead> 
  <tr> 
   <th>Author</th> 
   <th><a href="https://www.yourbatman.cn/about" rel="nofollow">A哥(YourBatman)</a></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>个人站点</td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow">www.yourbatman.cn</a></td> 
  </tr> 
  <tr> 
   <td>E-mail</td> 
   <td>yourbatman@qq.com</td> 
  </tr> 
  <tr> 
   <td><strong>微 信</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat.png" rel="nofollow">fsx641385712</a></td> 
  </tr> 
  <tr> 
   <td><strong><code>活跃平台</code></strong></td> 
   <td><a href="https://www.yourbatman.cn" rel="nofollow"><img src="https://img-blog.csdnimg.cn/2020071015182276.png" alt=""></a> <a href="https://fangshixiang.blog.csdn.net/" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151913394.png" alt=""></a><a href="https://yourbatman.cnblogs.com" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151929355.png" alt=""></a><a href="https://juejin.im/user/5b44d178f265da0fa1220efe/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151938937.png" alt=""></a><a href="https://www.zhihu.com/people/fangshixiang/posts" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710151950629.png" alt=""></a><a href="https://www.jianshu.com/u/8740f1fdd684" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152000530.png" alt=""></a><a href="https://segmentfault.com/u/yourbatman/articles" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152008726.png" alt=""></a><a href="https://github.com/yourbatman" rel="nofollow"><img src="https://img-blog.csdnimg.cn/20200710152015895.png" alt=""></a></td> 
  </tr> 
  <tr> 
   <td><strong>公众号</strong></td> 
   <td><a href="https://www.yourbatman.cn/images/wechat_channel.jpg" rel="nofollow">BAT的乌托邦（ID：BAT-utopia）</a></td> 
  </tr> 
  <tr> 
   <td>知识星球</td> 
   <td><a href="https://t.zsxq.com/nQBi66I" rel="nofollow">BAT的乌托邦</a></td> 
  </tr> 
  <tr> 
   <td>每日文章推荐</td> 
   <td><a href="https://github.com/yourbatman/reading/issues" rel="nofollow">每日文章推荐</a></td> 
  </tr> 
 </tbody> 
</table>

![BAT的乌托邦][BAT]

[Spring_Spring_Async_EnableAsync]: https://blog.csdn.net/f641385712/article/details/89430276
[BAT]: /images/20211108/a4d437ff32934883bb26414decb192c6.png