Home > Java > javaTutorial > body text

Methods called asynchronously by @Async in java

PHPz
Release: 2023-05-05 19:10:04
forward
1775 people have browsed it

    Preface

    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

    1. @Async explanation

    The annotation code of @Async is as follows:

    @Target({ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Async {
        String value() default "";
    }
    Copy after login

    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;
    }
    Copy after login

    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);
        }
    }
    Copy after login
    Copy after login

    2. Usage

    2.1 Synchronous call

    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("保存日志");
        }
    }
    Copy after login

    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();
            }
        }
        
    }
    Copy after login
    Copy after login

    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

    2.2 Asynchronous call

    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("保存日志");
        }
    }
    Copy after login

    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();
            }
        }
        
    }
    Copy after login
    Copy after login

    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);
        }
    }
    Copy after login
    Copy after login

    3. Custom thread pool

    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-
    Copy after login

    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;
        }
    }
    Copy after login

    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!

    Related labels:
    source:yisu.com
    Statement of this Website
    The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
    Popular Tutorials
    More>
    Latest Downloads
    More>
    Web Effects
    Website Source Code
    Website Materials
    Front End Template