springboot 中使用@Async注解异步调用

异步调用的场景和好处我就不说了，基本上都是解放主线程的压力，将一些不涉及主线程的逻辑释放。废话不多说，直接上代码；

控制层：

和启动类一样，需要添加@EnableAsync注解

 启动类：

@EnableCaching
@SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })
@EnableScheduling
@EnableAsync
public class ShopendApplication {
	public static void main(String[] args) {
		SpringApplication.run(ShopendApplication.class, args);
		System.out.println("main启动成功！");
	}

	@Bean
	public RestTemplate restTemplate(RestTemplateBuilder builder){
		return builder.build();
	}
}

在相同包下新建一个类

AsynctaskExecutor，注意一定要加上@Component注解，不然spring会扫描不到，即无法动态代理（不懂的自行百度）

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.lmt.diandiancaidan.douyin.service.DouyinReleaseService;
import com.lmt.utils.QiniuUtils;
import lombok.extern.log4j.Log4j;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;
import java.util.concurrent.Future;

@Log4j
@Component
public class AsynctaskExecutor {
    @Autowired
    private DouyinReleaseService douyinReleaseService;

    @Async("taskExecutor")
    public void mywait(DouyinRelease release1) {
        log.info("进入taskExecutor------------------");
        Future<String> returnmsg = null;
        //此处填写自己的业务代码
        //此处填写自己的业务代码
        //此处填写自己的业务代码
        //此处填写自己的业务代码
    }
}

然后再controller里注入该类

@Autowired
private AsynctaskExecutor asyncTest;

在需要调用的方法里调用即可

值得关注的是，推荐创建线程池，不然会有高并发问题，在config包下新建以下线程池类

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * 异步线程池
 */
@Configuration
@EnableAsync
public class AsyncExecutorConfig {

    /**
     * Set the ThreadPoolExecutor's core pool size.
     */
    private int corePoolSize = 8;
    /**
     * Set the ThreadPoolExecutor's maximum pool size.
     */
    private int maxPoolSize = 16;
    /**
     * Set the capacity for the ThreadPoolExecutor's BlockingQueue.
     */
    private int queueCapacity = 200;

    private String threadNamePrefix = "AsyncExecutor-";

    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix(threadNamePrefix);

        // rejection-policy：当pool已经达到max size的时候，如何处理新任务
        // CALLER_RUNS：不在新线程中执行任务，而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }

}

写在后面：

如果需要返回值，异步调用类里的void换成future<String>即可,调用future的get()方法接收返回值，值得一提的的是，get()方法是线程阻塞的。建议不使用；

@Async注解失效的原因：

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