每篇一句
将依赖做到精简是中间件岗位最基本的素养,美国童子军也有一条军规:让营地比你来时更干净。 请参阅书籍《Clean Code》
前言
如题,如果把这两者拆开来看的话,两者你应该都不陌生:@Async你不陌生,@Transactional你应该更不陌生,若单独拿来使用,理论上应该木有不会用的吧。本文不废话,分析一下他俩结合一起使用的case,因为据我了解很多人对结合一起使用时,心里还是打鼓的,这样对生产环境使用还是有隐患的。
相较于@Transactional的使用,关于@Async的一些使用case相对我估计还是陌生一点,所以文章开头先简单回顾一下@Async的使用。
@Async的使用
此处我的异步配置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抛出运行异常");
}
}
运行单测:
@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);
}
}
这里单测的两个小细节请注意,否则你可能看不到效果的:
请使用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);
}
@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结合使用的一个场景来进行分析,因为开发中也比较常见,因此希望把这两块内容集合使用做些示例,希望可以做到心中有数,这样使用起来才会更加的胸有成竹嘛~