spring异步框架使用教程

背景

在需求开发过程中，为了提升效率，很容易就会遇到需要使用多线程的场景。这个时候一般都会选择建一个线程池去专门用来进行某一类动作，这种任务到来的时候往往伴随着大量的线程被创建调用。而还有另外一种场景是整个任务的执行耗时比较长，但又不适合起多线程去运行，只能后台起一个异步线程去慢慢跑。这个时候就需要一个公共的线程池。

可选方案

总体思想就是要有一个全局可用的线程池，可以用来执行一些零散的任务。

方案一

自定义一个全局的线程池，需要异步操作的就调用。这种方法好处是实现简单，并且调用起来也简单，直接当成一个方法就可以了。但需要同模块项目（或者导入了模块）才能使用。

方案二

使用Spring自带的注解@Async实现异步。这种方法的好处是注解可以跨模块使用，因为线程池对象会被注入容器，整个服务共用。而且更大的好处是使用简单，使用者只需要给所需异步操作的方法加上@Async("beanName")即可。其中beanName是指注入容器的对象的名称，也可以不加参数，不加参数代表使用默认线程池。

考虑到便捷性和新手友好性，选择了方案二。

实现（注意看我的调用的结构，可以避免循环依赖）

controller->async->service √

controller->service->async->service ×，这样会出现循环依赖

1.创建线程池配置类

java 复制代码

/**
*	必须加上@EnableAsync注解
*/
@EnableAsync
@Configuration
public class TaskPoolConfig {
	/**
	*	可以多创建几个bean注入容器，根据bean不同用来执行不同类型的任务
	*/
    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心线程池大小
        executor.setCorePoolSize(16);
        //最大线程数
        executor.setMaxPoolSize(20);
        //配置队列容量，默认值为Integer.MAX_VALUE
        executor.setQueueCapacity(99999);
        //活跃时间
        executor.setKeepAliveSeconds(60);
        //线程名字前缀
        executor.setThreadNamePrefix("asyncServiceExecutor -");
        //设置此执行程序应该在关闭时阻止的最大秒数，以便在容器的其余部分继续关闭之前等待剩余的任务完成他们的执行
        executor.setAwaitTerminationSeconds(60);
        //等待所有的任务结束后再关闭线程池
        executor.setWaitForTasksToCompleteOnShutdown(true);
        return executor;
    }


	@Bean("taskExecutor2")
    public Executor taskExecutor2() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心线程池大小
        executor.setCorePoolSize(16);
        //最大线程数
        executor.setMaxPoolSize(20);
        //配置队列容量，默认值为Integer.MAX_VALUE
        executor.setQueueCapacity(99999);
        //活跃时间
        executor.setKeepAliveSeconds(60);
        //线程名字前缀
        executor.setThreadNamePrefix("asyncServiceExecutor -");
        //设置此执行程序应该在关闭时阻止的最大秒数，以便在容器的其余部分继续关闭之前等待剩余的任务完成他们的执行
        executor.setAwaitTerminationSeconds(60);
        //等待所有的任务结束后再关闭线程池
        executor.setWaitForTasksToCompleteOnShutdown(true);
        return executor;
    }
}

2.使用异步

异步类：

java 复制代码

public interface AsyncService {
	void test();
}

java 复制代码

@Slf4j
@Service
public class AsyncServiceImpl implements AsyncService {
 	@Autowired
    private TestService testService;
    //这里的参数是只bean的名称，不填则使用默认的线程池。如果这个注解放在类上，代表这个类里面的全部方法都走异步
	@Async("taskExecutor")
	void test(){
		testService.todo();
	}
	
	@Async("taskExecutor2")
	void test2(){
		testService.todo2();
	}
}

业务类：

java 复制代码

public interface TestService {
	void todo();
	void todo2();
}

java 复制代码

@Slf4j
@Service
public class TestServiceImpl implements TestService{
    
	void todo(){
		LocalDateTime dateTime=LocalDateTime.now();
		log.info("已经进入异步方法，现在时间：{}，睡三秒",dateTime);
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		dateTime=LocalDateTime.now();
		log.info("三秒后时间为：{}",dateTime);
	}
	void todo2(){
	}
}

测试类：

java 复制代码

@Slf4j
@RestController
public class TestController {
	@Autowired
	private AsyncService asyncService;
	@RequestMapping("/test")
	public void test(){
		asyncService.test();
		LocalDateTime dateTime=LocalDateTime.now();
		log.info("这是主线程，现在时间为：{}",dateTime);
	}
}

结果：成功

坑点

1.异步失效

如果一个类里面有两个方法A、B，方法B添加了异步注解，方法A调用方法B，异步不会生效。

查了一下，好像是因为异步注解的实现用到了动态代理，而一个类内部方法的调用不会走代理，也就没法实现异步。

因此，建议把异步都放在一个专门的异步类里面，这个类的方法只用来实现异步，方法内部再去调用真正的业务逻辑方法。

2.循环依赖

正常来说，A类中注入B类对象，B类中再注入A类对象。这种情况在代码中并不会发生循环依赖。而在异步注解中会出现循环依赖，因为异步注解底层实现用的是动态代理。