Asynchronous call and synchronous call
Synchronous call: sequential execution, return the result again by calling Execute the next call
Asynchronous call: By calling, there is no need to wait for the return result, execute the next call
The annotation code of @Async is as follows:
@Target({ElementType.TYPE, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface Async { String value() default ""; }
Annotations can be used in types and methods.
Define its value through value, and the default is empty.
Generally, this annotation needs to be matched. @EnableAsync, the origin code is as follows
@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Import({AsyncConfigurationSelector.class}) public @interface EnableAsync { Class<? extends Annotation> annotation() default Annotation.class; boolean proxyTargetClass() default false; AdviceMode mode() default AdviceMode.PROXY; int order() default Integer.MAX_VALUE; }
Mainly place this annotation in the startup class for configuration startup
Add the following in the startup class:
@SpringbootApplication @EnableAsync public class Application{ public static void main(String[] args){ SrpingApplication.run(Application.class, args); } }
The next step can only be executed from the call to the returned function result, which is called synchronous call
Service layer code:
public class Service{ public void test01() throws InterruptedException{ Thread.sleep(5000); System.out.println("保存日志"); } }
Control layer code module:
public class Controler{ @Autowired private Service service; @GetMapping("/test") public String getTest(){ try{ System.out.println("开始"); service.test01(); System.out.println("结束"); }catch(InterruptedException e){ e.prinStackTrace(); } } }
After starting through the springboot startup class
The output is as follows:
Start
//This is to wait for 5 seconds, the terminal does not The display is not closed either
End
Asynchronous call, the executing function can execute the next step without waiting for the return result
service Layer code:
Mainly adds the @Async annotation to identify this method
public class Service{ @Async public void test01() throws InterruptedException{ Thread.sleep(500); System.out.println("保存日志"); } }
Control layer code module:
By calling the service layer function
public class Controler{ @Autowired private Service service; @GetMapping("/test") public String getTest(){ try{ System.out.println("开始"); service.test01(); System.out.println("结束"); }catch(InterruptedException e){ e.prinStackTrace(); } } }
and in the startup class Add the annotation to start @EnableAsync
@SpringbootApplication @EnableAsync public class Application{ public static void main(String[] args){ SrpingApplication.run(Application.class, args); } }
For some basic knowledge of the thread pool, please see my previous article:
How to close the thread correctly in java And thread pool (code practice including source code analysis)
Detailed analysis of the creation method of java thread pool (full)
If you do not specify a thread pool, the default thread pool used is SimpleAsyncTaskExecutor (create a task when it comes) Threads, constantly creating threads will cause excessive CPU and cause OOM). The built-in thread pool generally has disadvantages. It is generally recommended to use ThreadPoolExecutor (clear the resources of the thread pool and avoid risks)
The details are as follows:
newFixedThreadPool: The number of threads is fixed, but the task queue is still unbounded (the maximum number of threads will only be created when the queue is full), so it will cause OOM
newCachedThreadPool: There is no upper limit for the maximum number of threads. Creating a large number of threads is prone to lag or direct OOM
You can adjust the configuration of the thread pool through a custom thread pool, which is better The resources use the
@Async annotation to find the AsyncConfigurer interface (the implementation class is AsyncConfigurerSupport, the default configuration and methods are empty), so the interface can be rewritten to specify the thread pool.
By implementing the interface AsyncConfigurer
Inherit AsyncConfigurerSupport
Customize TaskExecutor (replace the built-in task execution Device)
The third method:
Define some variables of the thread pool in application.xml
thread.core.size=16 thread.max.size=16 thread.queue.size=30 thread.prefix=xx-
Customize the thread pool as follows
import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; import java.util.concurrent.ThreadPoolExecutor; @Configuration public class ThreadPoolConfig { // 线程名称前缀 @Value("${thread.prefix}") private String threadPrefix; // 核心线程数 @Value("${thread.core.size}") private int coreSize; // 最大线程数 @Value("${thread.max.size}") private int maxSize; // 队列长度 @Value("${thread.queue.size}") private int queueSize; // 通过bean注解注入 @Bean("xx") public ThreadPoolTaskExecutor taskExecutor() { ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor(); //设置线程池参数信息 taskExecutor.setCorePoolSize(coreSize); taskExecutor.setMaxPoolSize(maxSize); taskExecutor.setQueueCapacity(queueSize); taskExecutor.setThreadNamePrefix(threadPrefix); taskExecutor.setWaitForTasksToCompleteOnShutdown(true); taskExecutor.setAwaitTerminationSeconds(30); //修改拒绝策略为使用当前线程执行 taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); //初始化线程池 taskExecutor.initialize(); return taskExecutor; } }
The above is the detailed content of Methods called asynchronously by @Async in java. For more information, please follow other related articles on the PHP Chinese website!