Methods called asynchronously by @Async in java

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 "";
}

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);
    }
}

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

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

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

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);
    }
}

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-

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!