[JAVA] Asynchronous processing with Spring Boot using @Async

About this document

Since I investigated what is necessary when performing asynchronous processing with SpringBoot, in this document,

1. Asynchronous processing method using @Async
2. Setting up threads using TaskExcecuter

I summarized about.

Execution environment

java8 + Spring Boot 2.1.0 + lombok

build.gradle is as follows

buildscript {
    ext {
        springBootVersion = '2.1.0.RELEASE'
    }
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
    }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'io.spring.dependency-management'

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
    mavenCentral()
}


dependencies {
    implementation('org.springframework.boot:spring-boot-starter-web')
    compileOnly('org.projectlombok:lombok')
    testImplementation('org.springframework.boot:spring-boot-starter-test')
}

Try

Implement the process you want to execute asynchronously

Implementation

Create a process that just sleeps properly

@Slf4j
@Service
public class AsyncService {

    @Async("Thread2")
    public CompletableFuture<String> findName(String name, Long sleepTime) throws InterruptedException {
        log.warn("Async function started. processName: " + name + "sleepTime: " + sleepTime);
        Thread.sleep(sleepTime);
        
        //Use the return value you actually want to use in the Completable Future so that you can handle asynchronous processing.
        return CompletableFuture.completedFuture(name);
    }

}

Commentary

• The process itself is logged and just sleeping
• The return value returns a CompletableFuture object so that asynchronous processing can be handled.
• If you feed the value you actually want to use to CompletableFuture and return it, you can use it as the caller of the function.
• Add @Async to the function you want to process asynchronously
• "Thread2" described in @Async will be described later.

Implement the process of calling and handling the above logic

Implementation

Implement an appropriate Controller to handle asynchronous processing

@Slf4j
@RequiredArgsConstructor
@RestController
public class FindNameContoller {

    private final AsyncService asyncService;

    @GetMapping("/users/")
    public List<String> findUsers() throws Exception {
        long start = System.currentTimeMillis();
        long heavyProcessTime = 3000L;
        long lightProcessTime = 1000L;

        log.warn("request started");
        CompletableFuture<String> heavyProcess = asyncService.findName("heavy", heavyProcessTime);
        CompletableFuture<String> lightProcess = asyncService.findName("light", lightProcessTime);

        //Process to be executed when heavyProcess is finished
        heavyProcess.thenAcceptAsync(heavyProcessResult -> {
            log.warn("finished name=" + heavyProcessResult + ", sleep = " + heavyProcessTime);
        });

        //Process to be executed when lightProcess is finished
        lightProcess.thenAcceptAsync(lightProcessResult -> {
            log.warn("finished name=" + lightProcessResult + ", sleep = " + lightProcessTime);
        });

        //When the specified process is completed, the subsequent processes will be executed.
        CompletableFuture.allOf(heavyProcess, lightProcess).join();

        //Creating a return value
        List<String> names = new ArrayList<>();
        names.add(heavyProcess.get());
        names.add(lightProcess.get());

        Thread.sleep(10L);

        long end = System.currentTimeMillis();
        //Output the time of the entire process
        log.warn("request finished. time: " + ((end - start))  + "ms");

        return names;
    }

}

Commentary

• As a whole process, heavy process and light process are executed asynchronously in parallel, and when all the processes are executed, the log is entered and the process ends.
• Asynchronous processing is handled using the function of CompletableFuture or the function of the object of CompletableFuture type of the return value.
• If you want to do it individually, use the return value object, but if you feel like waiting for all to finish, use CompletableFuture.allOf.
• There seem to be some handling methods, but I will omit them here.

Set the upper limit of Thread, etc.

Implementation

Describe various settings in the main Application class

@EnableAsync
@SpringBootApplication
public class AsyncTrainingApplication {

    public static void main(String[] args) {
        SpringApplication.run(AsyncTrainingApplication.class, args);
    }

    @Bean("Thread1") //This setting is not specified and is not used
    public Executor taskExecutor1() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(20);
        executor.setThreadNamePrefix("Thread1--");
        executor.initialize();
        return executor;
    }

    @Bean("Thread2") //Set here"Thread2"Is set to @Async and that setting is used
    public Executor taskExecutor2() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5); //The default Thread size. When it overflows, it queues up to the size of Queue Capacity
        executor.setQueueCapacity(1); //The size of the waiting queue. Increase Thread to MaxPoolSize when overflowing
        executor.setMaxPoolSize(500); //Setting how much Thread to increase. If it overflows from this value, the process will be rejected and an Exception will occur.
        executor.setThreadNamePrefix("Thread2--");
        executor.initialize();
        return executor;
    }

    @Bean("Reject") //With this setting, queuing cannot be performed, Thread cannot be increased, and a RejectedExecutionException occurs.
    public Executor rejectTaskExecuter() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(1);
        executor.setQueueCapacity(0);
        executor.setMaxPoolSize(1);
        executor.setThreadNamePrefix("Reject--");
        executor.initialize();
        return executor;
    }

}

Commentary

• Add @EnableAsync to enable @Async
• The settings are matched with the character string described in @Bean. In this case, the "Thread2" bean is used.
• If TaskExecuter is not set, it seems to work by default (I haven't checked it in detail)
• As mentioned in the comment, Thread is created according to the following flow.
• Create Thread up to CorePoolSize
• When Thread is full, it will be queued to Queue Capacity
• Threads are created up to MaxPoolSize when overflowing from queuing
• RejectedExecutionException occurs when overflowing from MaxPoolSize

Execute

When you execute the process, the following log appears and you can see that it is running asynchronously

2018-11-27 20:19:13.181  WARN 8711 --- [nio-8080-exec-5] c.e.asynctraining.FindNameContoller      : request started
2018-11-27 20:19:13.181  WARN 8711 --- [TaskExecutor-31] com.example.asynctraining.AsyncService   : Async function started. processName: heavysleepTime: 3000
2018-11-27 20:19:13.182  WARN 8711 --- [TaskExecutor-32] com.example.asynctraining.AsyncService   : Async function started. processName: lightsleepTime: 1000
2018-11-27 20:19:14.187  WARN 8711 --- [onPool-worker-2] c.e.asynctraining.FindNameContoller      : finished name=light, sleep = 1000
2018-11-27 20:19:16.182  WARN 8711 --- [onPool-worker-2] c.e.asynctraining.FindNameContoller      : finished name=heavy, sleep = 3000
2018-11-27 20:19:16.194  WARN 8711 --- [nio-8080-exec-5] c.e.asynctraining.FindNameContoller      : request finished. time: 3013ms

Rough summary

• Return the process you want to run asynchronously with CompletableFuture and add @Async
• Use CompletableFuture well for handling asynchronous processing
• Add @EnableAsync to the class with @Configuration
• Thread settings are made with TaskExecuter, and it is difficult to understand the internal settings, so be careful.

Impressions

• I did it while looking at the official reference, but I felt that it was fairly easy to introduce
• I thought that tuning Thread would be a hassle. I would like to know if there is a solid setting, but I felt that I had to do it while performing a performance test
• It was very easy to understand because the thread settings were described in detail on Shin's blog. It was a little tight without it

Referenced materials

• Getting Started · Creating Asynchronous Methods
• BLOG.IK.AM --Mistakenly misunderstood ThreadPoolTaskExecutor settings