SpringBoot实现多线程

多线程方式一：实现AsyncConfigurer 接口

配置类实现接口AsyncConfigurer，返回一个ThreadPoolTaskExecutor 线程池对象。

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {

    // ThredPoolTaskExcutor的处理流程
    // 当池子大小小于corePoolSize，就新建线程，并处理请求
    // 当池子大小等于corePoolSize，把请求放入workQueue中，池子里的空闲线程就去workQueue中取任务并处理
    // 当workQueue放不下任务时，就新建线程入池，并处理请求，如果池子大小撑到了maximumPoolSize，就用RejectedExecutionHandler来做拒绝处理
    // 当池子的线程数大于corePoolSize时，多余的线程会等待keepAliveTime长时间，如果无请求可处理就自行销毁

    @Override
    @Bean
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数：线程池创建的时候初始化的线程数
        executor.setCorePoolSize(10);
        // 最大线程数：线程池最大的线程数，只有缓冲队列满了之后才会申请超过核心线程数的线程
        executor.setMaxPoolSize(100);
        // 缓冲队列：用来缓冲执行任务的队列
        executor.setQueueCapacity(50);
        // 线程池关闭：等待所有任务都完成再关闭
        executor.setWaitForTasksToCompleteOnShutdown(true);
        // 等待时间：等待5秒后强制停止
        executor.setAwaitTerminationSeconds(5);
        // 允许空闲时间：超过核心线程之外的线程到达60秒后会被销毁
        executor.setKeepAliveSeconds(60);
        // 线程名称前缀
        executor.setThreadNamePrefix("learn-Async-");
        // 初始化线程
        executor.initialize();
        return executor;
    }

    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return null;
    }
}

通过@Async注解表明该方法是异步方法，如果注解在类上，那表明这个类里面的所有方法都是异步的。 

@Service
public class AsyncService {
    @Async  // 表明该方法是异步方法。如果注解在类上，那表明类里面的所有方法都是异步
    public void executeAsyncTask(int i) {
        System.out.println("线程" + Thread.currentThread().getName() + " 执行异步任务：" + i);
    }
}

多线程方式二：配置 java.util.concurrent.TaskExecutor

新增一个配置类，默认情况下使用 SimpleAsyncTaskExecutor

@Configuration
@EnableAsync //启用异步任务
public class ThreadConfig {
    @Bean("asyncServiceExecutor")
    public ThreadPoolTaskExecutor executor(){
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
      	//配置核心线程数
        executor.setCorePoolSize(15);
      	//配置最大线程数
        executor.setMaxPoolSize(30);
      	//配置队列大小
        executor.setQueueCapacity(1000);
      	//线程的名称前缀
        executor.setThreadNamePrefix("Executor-");
      	//线程活跃时间（秒）
        //executor.setKeepAliveSeconds(60);
      	//等待所有任务结束后再关闭线程池
        executor.setWaitForTasksToCompleteOnShutdown(true);
      	//设置拒绝策略
        //executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
      	//执行初始化
        executor.initialize();
        return executor;
    }
}

使用线程池：可以使用@Async注解或者直接调用TaskExecutor的submit或者execute方法提交任务。

//-----------------------接口类--------------------------
public interface UserService{
    /**
  	 * 执行异步任务
  	 */
    void writeText();
}
//-----------------------接口实现类----------------------
@Service
public class UserServiceImpl implement UserService{
    private static Logger logger = LogManager.getLogger(AsyncServiceImpl.class.getName());

    @Async("asyncServiceExecutor")
    @Over
    public void writeTxt(String fileName){
        logger.info("线程-" + Thread.currentThread().getId() + "在执行写入");
        try {
            File file = new File(fileName);
            List<String> lines = FileUtils.readLines(file);
            File copyFile = new File(fileName + "_copy.txt");
            lines.stream().forEach(string->{
                try {
                    FileUtils.writeStringToFile(copyFile,string,"utf8",true);
                    FileUtils.writeStringToFile(copyFile,"\r\n","utf8",true);
                } catch (IOException e) {
                    logger.info(e.getMessage());
                }
            });
        }catch (Exception e) {
            logger.info(e.getMessage());
        }
    }
}
//-----------------------测试----------------------------
@RunWith(SpringRunner.class)
@SpringBootTest
public class BootApplicationTests {
    @Autowired
    private AsyncService asyncService;

    @Test
    public void write() {
        File file = new File("F://ac_code_1//test.txt");
        try {
            FileUtils.writeStringToFile(file, "ceshi", "utf8");
            FileUtils.writeStringToFile(file, "\r\n", "utf8");
            FileUtils.writeStringToFile(file, "ceshi2", "utf8");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

@Async原理

本质上Async注解的实现依赖于动态代理，代理过程中将任务提交给线程池，存在以下流程：

如上图所示，Spring为使用Async注解Bean对象生产一个动态代理对象，当Async注解的方法被调用时，会进入代理流程，选择线程池、封装调用逻辑并提交给线程池执行，返回执行结果。

注意：未被@Async注解的方法则不会执行上述流程(static方法也不会)

由于异步的本质是基于代理实现，所以同一个类中的方法调用会导致被调用方的异步作用失效，该场景与Spring的事务失效原因相同。

注解@Async失效的情况

• 注解@Async的方法不是public方法
• 注解@Async的返回值只能为void或Future
• 注解@Async方法使用static修饰也会失效
• spring无法扫描到异步类，没加注解@Async或@EnableAsync注解
• 调用方与被调用方不能在同一个类（因为没走代理）
• 类中需要使用@Autowired或@Resource等注解自动注入，不能自己手动new对象
• 在Async方法上标注@Transactional是没用的，但在Async方法调用的方法上标注@Transcational是有效的