异步@Async + 事务@Transactional的结合

今天药忘吃喽~ 2023-07-06 13:16 7阅读 0赞

每篇一句

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

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

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

@Async的使用

关于它的基本使用原理篇，这篇文章其实有过非常详细的分析了，可前往此处深入了解：【小家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把异步和事务结合起来。对下面三个方法进行情景代入哈（不喜勿喷）

enter方法：餐馆里进来一个人（添加一条记录）  
eat方法：进来人后开始吃饭（会和数据库打交道）  
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、配置数据源本文就不列出了），参见前面相关文章  
运行单测：

@Slf4j  
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(classes = \{RootConfig.class, AsyncConfig.class, JdbcConfig.class\})  
public class TestSpringBean \{  
    @Autowired  
    private HelloService helloService;

@Test  
    public void test1() \{  
        helloService.enter(10);  
    \}  
\}  
  
当然喽，控制台肯定会有如下异常信息：

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抛出运行异常");  
    \}  
\}  
  
运行单测：

@Test  
    public void test1() throws InterruptedException \{  
        try \{  
            helloService.enter(10);  
        \} catch (Exception e) \{  
            e.printStackTrace();  
        \}

// 若是单测 请务必持有住主线程  否则子线程被提前结束不生效  
        TimeUnit.SECONDS.sleep(3);  
    \}  
\}  
  
这里单测的两个小细节请注意，否则你可能看不到效果的：

请使用try把主线程的包住（避免因为异常导致主线程中断）  
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);  
    \}

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);  
    \}

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结合使用的一个场景来进行分析，因为开发中也比较常见，因此希望把这两块内容集合使用做些示例，希望可以做到心中有数，这样使用起来才会更加的胸有成竹嘛~  
————————————————  
原文链接：https://blog.csdn.net/f641385712/article/details/98642777