springboot异步执任务

1.同步方式

controller

 /**
     * 同步处理
     * @return
     */
    @RequestMapping(value = "test2",method = RequestMethod.GET)
    public String test2(){
        loginService.getTest2();
        logger.info(Thread.currentThread().getName()+"==========主线程名");
        return "同步,正在解析......";
    }

serviceImpl

 /**同步方法*/
    @Override
    public void getTest2(){
        Building building = new Building();
        synchronized (building){
            try {
                for (int i = 1;i <= 100;i++){
                    logger.info(Thread.currentThread().getName()+"----------同步：>"+i);
                    building.wait(200);
                }
            }catch (Exception ex){
                ex.printStackTrace();
            }
        }
    }

这种同步的方式处理，会发现，当这100此循环完成后，页面才会返回 ：同步,正在解析......。当后台在循环处理时，前台的页面始终处于等待状态。可以发现，使用都是一个线程在处理：

2.异步任务方式一

使用线程池，创建新的线程去处理，如下：

controller

/**
     * 异步处理1：线程池，创建新线程处理
     * @return
     */
    @RequestMapping(value = "test3",method = RequestMethod.GET)
    public String test3(){
        ExecutorService service = Executors.newFixedThreadPool(5);
        RunnableTask1 task1 = new RunnableTask1();
        service.execute(task1);
        logger.info("=========》当前线程名："+Thread.currentThread().getName());
        return "异步,正在解析......";
    }

线程任务

public class RunnableTask1 implements Runnable{
    private final Logger logger = LoggerFactory.getLogger(getClass());
 
    @Override
    public void run(){
        Building building = new Building();
        synchronized (building){
            try {
                for (int i = 1;i <= 100;i++){
                    System.out.println(Thread.currentThread().getName()+"----------异步：>"+i);
                    building.wait(200);
                }
            }catch (Exception ex){
                ex.printStackTrace();
            }
        }
    }
}

我们看控制台，会发现，主线程，和处理任务的线程，不是一个线程，也就是，当页面请求后，主线程会返回我们想要返回的标识，这里返回的是一个字符串：异步，正在解析......，而线程池新开了一个线程，在后台处理业务逻辑。所以，此时访问接口后，会立马返回，页面不用等待，处理逻辑在后台默默进行。控制台如下：

 

3.异步任务 方式二

这种方式，是springBoot自身的一种异步方式，使用注解实现，非常方便，我们在想要异步执行的方法上加上@Async注解，在启动类上加上@EnableAsync，即可。注意，这里的异步方法，只能在自身之外调用，在本类调用是无效的。

启动类：添加@EnableAsync注解

@SpringBootApplication
@EnableAsync
public class Application{
 
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

异步任务执行类 添加@Async注解

import java.util.concurrent.Future;
 
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;
 
/**
 * 功能描述：异步任务业务类（@Async也可添加在方法上）
 */
@Component
@Async("taskExecutor")
public class AsyncTask {
    
 
    //获取异步结果
    public Future<String> task4() throws InterruptedException{
        long begin = System.currentTimeMillis();
        Thread.sleep(2000L);
        long end = System.currentTimeMillis();
        System.out.println("任务4耗时="+(end-begin));
        return new AsyncResult<String>("任务4");
    }
    
    
    public Future<String> task5() throws InterruptedException{
        long begin = System.currentTimeMillis();
        Thread.sleep(3000L);
        long end = System.currentTimeMillis();
        System.out.println("任务5耗时="+(end-begin));
        return new AsyncResult<String>("任务5");
    }
    
    public Future<String> task6() throws InterruptedException{
        long begin = System.currentTimeMillis();
        Thread.sleep(1000L);
        long end = System.currentTimeMillis();
        System.out.println("任务6耗时="+(end-begin));
        return new AsyncResult<String>("任务6");
    }
        
}

异步线程池

配置

package com.boot.common.conf;
 
import java.util.concurrent.ThreadPoolExecutor;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
/**
 * 线程池配置
 * @author zhh
 *
 */
@Configuration
@EnableAsync
public class ThreadPoolTaskConfig {
    
    private static final int corePoolSize = 10;               // 核心线程数（默认线程数）线程池创建时候初始化的线程数
    private static final int maxPoolSize = 100;                // 最大线程数 线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
    private static final int keepAliveTime = 10;            // 允许线程空闲时间（单位：默认为秒）当超过了核心线程之外的线程在空闲时间到达之后会被销毁
    private static final int queueCapacity = 200;            // 缓冲队列数 用来缓冲执行任务的队列
    private static final String threadNamePrefix = "Async-Service-"; // 线程池名前缀 方便我们定位处理任务所在的线程池
    
    @Bean("taskExecutor") // bean的名称，默认为首字母小写的方法名
    public ThreadPoolTaskExecutor taskExecutor(){
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);   
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(keepAliveTime);
        executor.setThreadNamePrefix(threadNamePrefix);
        
        // 线程池对拒绝任务的处理策略 采用了CallerRunsPolicy策略，当线程池没有处理能力的时候，该策略会直接在 execute 方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化
        executor.initialize();
        return executor;
    }
}

异步任务执行 controller

import java.util.concurrent.Future;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.jincou.task.AsyncTask;
import com.jincou.util.JsonData;

@RestController
@RequestMapping("/api/v1")
public class UserController {
    
    @Autowired
    private AsyncTask task;
    
    @GetMapping("async_task")
    public JsonData exeTask() throws InterruptedException{
        
        long begin = System.currentTimeMillis();
        
        Future<String> task4 = task.task4();
        Future<String> task5 = task.task5();
        Future<String> task6 = task.task6();
        
        //如果都执行往就可以跳出循环,isDone方法如果此任务完成，true
        for(;;){
            if (task4.isDone() && task5.isDone() && task6.isDone()) {
                break;
            }
        }
                
        long end = System.currentTimeMillis();    
        long total = end-begin;
        System.out.println("执行总耗时="+total);
        return JsonData.buildSuccess(total);
    }    
}

使用异步任务比同步任务耗时少

注意事项：

如下方式会使@Async失效
一、异步方法使用static修饰
二、异步类没有使用@Component注解（或其他注解）导致spring无法扫描到异步类
三、异步方法不能与调用异步方法的方法在同一个类中
四、类中需要使用@Autowired或@Resource等注解自动注入，不能自己手动new对象
五、如果使用SpringBoot框架必须在启动类中增加@EnableAsync注解
六、在Async 方法上标注@Transactional是没用的。 在Async 方法调用的方法上标注@Transactional 有效。