No progress with public concern for the latest articlesJavaStorm.png
== asynchronous call corresponds to a synchronous call, as will be appreciated synchronous call executed in the order defined ordering; asynchronous call when executing one instruction need not wait for the end of the call can continue. ==
We will create a Spring Boot project to illustrate. Specific reference may github project codes github.com/UniqueDong/... the async module
pom dependence follows:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<exclusions>
<exclusion>
<artifactId>spring-boot-starter-logging</artifactId>
<groupId>org.springframework.boot</groupId>
</exclusion>
</exclusions>
</dependency>
<!-- logback -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-access</artifactId>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-core</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.2</version>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
复制代码Start classes are as follows:
@SpringBootApplication
public class AsyncApplication {
public static void main(String[] args) {
SpringApplication.run(AsyncApplication.class, args);
}
}
复制代码Custom thread pool
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;
}
}
复制代码We ThreadPoolTaskExecutor code to create a thread pool. Meaning of the parameters are as follows:
- corePoolSize: the number of core threads in the thread pool created
- maxPoolSize: The maximum number of number of threads the thread pool thread pool, when the number of tasks exceeds corePoolSize and buffer queue was full after only application.
- setKeepAliveSeconds: allows threads to idle time of 60 seconds, when maxPoolSize thread idle time of arrival destroyed.
- ThreadNamePrefix: prefix task thread's name.
- RejectedExecutionHandler: When a thread pool is not processing power, this policy runs the rejected task directly in the calling thread of the execute method; if the executor has been shut down, the task is discarded
Use combat
@Slf4j
@Service
public class OrderService {
public static Random random = new Random();
@Autowired
private AsyncTask asyncTask;
public void doShop() {
try {
createOrder();
// 调用有结果返回的异步任务
Future<String> pay = asyncTask.pay();
if (pay.isDone()) {
try {
String result = pay.get();
log.info("异步任务返回结果{}", result);
} catch (ExecutionException e) {
e.printStackTrace();
}
asyncTask.vip();
asyncTask.sendSms();
}
otherJob();
} catch (InterruptedException e) {
log.error("异常", e);
}
}
public void createOrder() {
log.info("开始做任务1：下单成功");
}
/**
* 错误使用，不会异步执行：调用方与被调方不能在同一个类。主要是使用了动态代理，同一个类的时候直接调用，不是通过生成的动态代理类调用
*/
@Async("taskExecutor")
public void otherJob() {
log.info("开始做任务4：物流");
long start = System.currentTimeMillis();
try {
Thread.sleep(random.nextInt(10000));
} catch (InterruptedException e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
log.info("完成任务4，耗时：" + (end - start) + "毫秒");
}
}
复制代码Asynchronous task service class
mport lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;
import java.util.Random;
import java.util.concurrent.Future;
@Component
@Slf4j
public class AsyncTask {
public static Random random = new Random();
@Async("taskExecutor")
public void sendSms() throws InterruptedException {
log.info("开始做任务2：发送短信");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务1，耗时：" + (end - start) + "毫秒");
}
@Async("taskExecutor")
public Future<String> pay() throws InterruptedException {
log.info("开始做异步返回结果任务2：支付");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("完成任务2，耗时：" + (end - start) + "毫秒");
return new AsyncResult<>("会员服务完成");
}
/**
* 返回结果的异步调用
* @throws InterruptedException
*/
@Async("taskExecutor")
public void vip() throws InterruptedException {
log.info("开始做任务5：会员");
long start = System.currentTimeMillis();
Thread.sleep(random.nextInt(10000));
long end = System.currentTimeMillis();
log.info("开始做异步返回结果任务5，耗时：" + (end - start) + "毫秒");
}
}
复制代码unit test
@RunWith(SpringRunner.class)
@SpringBootTest(classes = AsyncApplication.class)
public class AsyncApplicationTests {
@Autowired
private OrderService orderService;
@Test
public void testAsync() {
orderService.doShop();
try {
Thread.currentThread().join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
复制代码The results show
2019-05-16 20:25:06.577 [INFO ] [main] - zero.springboot.study.async.service.OrderService-52 开始做任务1：下单成功
2019-05-16 20:25:06.586 [INFO ] [main] - zero.springboot.study.async.service.OrderService-60 开始做任务4：物流
2019-05-16 20:25:06.599 [INFO ] [AsyncExecutor-1] - zero.springboot.study.async.service.AsyncTask-38 开始做异步返回结果任务2：支付
2019-05-16 20:25:13.382 [INFO ] [AsyncExecutor-1] - zero.springboot.study.async.service.AsyncTask-42 完成任务2，耗时：6783毫秒
2019-05-16 20:25:14.771 [INFO ] [main] - zero.springboot.study.async.service.OrderService-68 完成任务4，耗时：8184毫秒
复制代码Some may see the name of the thread pool thread is that we prefix definition, description uses asynchronous execution thread pool. Which we demonstrate a wrong use case otherJob () , and did not execute asynchronously.
the reason:
spring on the scanning method scans when the bean contains @Async notes, if included, spring will generate a subclass (ie proxy class, proxy) for the bean dynamic proxy class inherits the original bean. At this time, when the annotated method is called, in fact, invoked by the agent class, proxy class role in increasing the asynchronous call. However, if the annotated method is invoked other methods in the same class, then call the method and not by proxy class, but directly by the original bean that is this. Method, so there is no increase asynchronous role, we see the phenomenon is @Async notes invalid.