Shulou(Shulou.com)06/03 Report--

What is the Springboot annotation @ Async thread pool example? to solve this problem, this article introduces the corresponding analysis and solution in detail, hoping to help more partners who want to solve this problem to find a simpler and easier way.

Starting with Spring3, the @ Async annotation is provided, which can be annotated on the method so that it can be called asynchronously. The caller will return immediately when it is called, and the actual execution of the method will be submitted to the task of the Spring TaskExecutor and executed by the thread in the specified thread pool.

1. TaskExecutor

The interface class of Spring asynchronous thread pool, which is essentially java.util.concurrent.Executor

The exception thread pool that Spring has implemented:

1. SimpleAsyncTaskExecutor: not a real thread pool, this class does not reuse threads, and each call creates a new thread.

2. SyncTaskExecutor: this class does not implement an asynchronous call, just a synchronous operation. Only suitable for places where multithreading is not needed

3. The adaptation class of ConcurrentTaskExecutor:Executor is not recommended. Consider using this only if the ThreadPoolTaskExecutor does not meet the requirements

Class 4. SimpleThreadPoolTaskExecutor: is the class of Quartz's SimpleThreadPool. This class is required when thread pools are used by both quartz and non-quartz

5. ThreadPoolTaskExecutor: most commonly used, recommended. Its essence is the packaging of java.util.concurrent.ThreadPoolExecutor.

2. @ EnableAsync @ Async

(1) the startup class of springboot. The @ EnableAsync annotation enables asynchronous calls.

(2) spring defines asynchronous tasks for @ Async

There are three ways to asynchronize.

1. The simplest asynchronous call, the return value is void, based on @ Async no return value call, directly in the use of classes, the use of methods (recommended in the use of methods), plus comments. If you need to throw an exception, you need to manually new an exception.

two。 Asynchronous methods called asynchronously with parameters can pass parameters

3. The exception call returns Future and will not be handled by AsyncUncaughtExceptionHandler. We need to catch the exception in the method and handle it, or catch the exception when the caller calls Futrue.get to handle it.

3. @ Async App default thread pool

Spring applies the default thread pool, which means that the name of the thread pool is not specified when the @ Async annotation is in use. Looking at the source code, the default thread pool for @ Async is SimpleAsyncTaskExecutor.

Disadvantages of default thread pool

In thread pool application, refer to Alibaba java development specification: thread pool is not allowed to be created using Executors or the system default thread pool. It is recommended to use ThreadPoolExecutor, which allows developers to know the running rules of thread pool more clearly and avoid the risk of resource exhaustion. Disadvantages of each method of Executors:

NewFixedThreadPool and newSingleThreadExecutor: the main problem is that stacked request processing queues can consume a lot of memory, even OOM.

NewCachedThreadPool and newScheduledThreadPool: the problem is that the maximum number of threads is Integer.MAX_VALUE, which may create a very large number of threads, or even OOM.

@ Async default asynchronous configuration uses SimpleAsyncTaskExecutor, which defaults to a task to create a thread. If threads are constantly created in the system, it will eventually cause the system to occupy too much memory and cause OutOfMemoryError errors. To solve the problem of thread creation, SimpleAsyncTaskExecutor provides a current-limiting mechanism, which uses the concurrencyLimit attribute to control the switch. When concurrencyLimit > = 0, the current-limiting mechanism is enabled, and the current-limiting mechanism, namely concurrencyLimit=-1, is disabled by default. When the thread is closed, new threads will be created to handle the task. Based on the default configuration, SimpleAsyncTaskExecutor is not strictly a thread pool and cannot achieve the function of thread reuse.

4. @ Async Application Custom Thread Pool

Custom thread pool, can be more fine-grained control of the thread pool in the system, easy to adjust the thread pool size configuration, threads to perform exception control and handling. When setting a system custom thread pool instead of the default thread pool, although it can be set in a variety of modes, replacing the default thread pool will result in only one thread pool (multiple classes cannot be set to inherit AsyncConfigurer). Custom thread pools have the following modes:

Reimplement interface AsyncConfigurer inherit AsyncConfigurerSupport configuration replace built-in task executor with custom TaskExecutor

By looking at the default calling rules for @ Async in the Spring source code, we will first query the class in the source code that implements the interface AsyncConfigurer, and the class that implements this interface is AsyncConfigurerSupport. However, the default configured thread pool and asynchronous processing methods are empty, so whether you inherit or reimplement the interface, you need to specify a thread pool. And re-implement the public Executor getAsyncExecutor () method.

(1) implement the interface AsyncConfigurer

@ Configurationpublic class AsyncConfiguration implements AsyncConfigurer {@ Bean ("kingAsyncExecutor") public ThreadPoolTaskExecutor executor () {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor (); int corePoolSize = 10; executor.setCorePoolSize (corePoolSize); int maxPoolSize = 50; executor.setMaxPoolSize (maxPoolSize); int queueCapacity = 10; executor.setQueueCapacity (queueCapacity); executor.setRejectedExecutionHandler (new ThreadPoolExecutor.CallerRunsPolicy ()); String threadNamePrefix = "kingDeeAsyncExecutor-"; executor.setThreadNamePrefix (threadNamePrefix); executor.setWaitForTasksToCompleteOnShutdown (true); / / use custom cross-thread request-level thread factory class RequestContextThreadFactory threadFactory = RequestContextThreadFactory.getDefault () Executor.setThreadFactory (threadFactory); int awaitTerminationSeconds = 5; executor.setAwaitTerminationSeconds (awaitTerminationSeconds); executor.initialize (); return executor;} @ Override public Executor getAsyncExecutor () {return executor ();} @ Override public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler () {return (ex, method, params)-> ErrorLogger.getInstance (). Log (String.format ("execute asynchronous task'% s'", method), ex);}}

(2) inherit AsyncConfigurerSupport

@ Configuration @ EnableAsync class SpringAsyncConfigurer extends AsyncConfigurerSupport {@ Bean public ThreadPoolTaskExecutor asyncExecutor () {ThreadPoolTaskExecutor threadPool = new ThreadPoolTaskExecutor (); threadPool.setCorePoolSize (3); threadPool.setMaxPoolSize (3); threadPool.setWaitForTasksToCompleteOnShutdown (true); threadPool.setAwaitTerminationSeconds (60 * 15); return threadPool;} @ Override public Executor getAsyncExecutor () {return asyncExecutor;} @ Override public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler () {return (ex, method, params)-> ErrorLogger.getInstance (). Log (String.format ("execute asynchronous tasks'% s', method), ex);}}

(3) configure custom TaskExecutor

Because the default thread pool of AsyncConfigurer is empty in the source code, Spring first checks whether there is a thread pool through beanFactory.getBean (TaskExecutor.class). When it is not configured, it uses beanFactory.getBean (DEFAULT_TASK_EXECUTOR_BEAN_NAME, Executor.class) to query whether there is a thread pool with the default name TaskExecutor. So in your project, define a bean named TaskExecutor to generate a default thread pool. You can also declare a thread pool without specifying the name of the thread pool, which is based on TaskExecutor.class.

For example:

Executor.class:ThreadPoolExecutorAdapter- > ThreadPoolExecutor- > AbstractExecutorService- > ExecutorService- > Executor (in this mode, the bottom layer is Executor.class. When you replace the default thread pool, you need to set the default thread pool name as TaskExecutor)

Executor.class:ThreadPoolTaskExecutor- > SchedulingTaskExecutor- > AsyncTaskExecutor- > TaskExecutor (in this mode, the underlying layer is TaskExecutor.class, and the thread pool name is not specified when replacing the default thread pool. )

Package intellif.configs;import org.apache.logging.log4j.LogManager;import org.apache.logging.log4j.Logger;import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;import org.springframework.beans.factory.annotation.Value;import org.springframework.scheduling.annotation.AsyncConfigurer;import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;import org.springframework.stereotype.Component;import java.util.concurrent.Executor;import java.util.concurrent.ThreadPoolExecutor / * @ author liuyu * @ className TaskConfiguration * @ date, 2019-12-17 11:40 * @ description * / @ Componentpublic class TaskConfiguration implements AsyncConfigurer {private static Logger logger = LogManager.getLogger (TaskConfiguration.class); @ Value ("${thread.pool.corePoolSize:10}") private int corePoolSize; @ Value ("${thread.pool.maxPoolSize:20}") private int maxPoolSize; @ Value ("${thread.pool.keepAliveSeconds:4}") private int keepAliveSeconds @ Value ("${thread.pool.queueCapacity:512}") private int queueCapacity; @ Value ("${thread.pool.waitForTasksToCompleteOnShutdown:true}") private boolean waitForTasksToCompleteOnShutdown; @ Value ("${thread.pool.awaitTerminationSeconds:60}") private int awaitTerminationSeconds; @ Override public Executor getAsyncExecutor () {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor (); / / executor.setCorePoolSize (corePoolSize) / / the maximum number of threads in the thread pool. Only after the buffer queue is full will the thread executor.setMaxPoolSize (maxPoolSize) be applied for exceeding the number of core threads; / / allow idle time for threads. When threads other than core threads are exceeded, executor.setKeepAliveSeconds (keepAliveSeconds) will be destroyed when idle time arrives; / queue executor.setQueueCapacity (queueCapacity) used to buffer tasks / / the prefix of the thread pool name, which can be used to locate the thread pool executor.setThreadNamePrefix ("taskExecutor-") where the task is being processed; / / the thread pool processing policy executor.setRejectedExecutionHandler ((Runnable r, ThreadPoolExecutor exe)-> {logger.warn ("current task thread pool queue is full");}) / / this method is used to set when thread pool is closed, wait for all tasks to be completed, and then continue to destroy other Bean, so that the destruction of these asynchronous tasks will precede the destruction of database connection pool objects. Executor.setWaitForTasksToCompleteOnShutdown (waitForTasksToCompleteOnShutdown); / / this method is used to set the wait time of a task in the thread pool, which is forced to be destroyed if it has not been destroyed, to ensure that the application can eventually be closed rather than blocked. Executor.setAwaitTerminationSeconds (awaitTerminationSeconds); executor.initialize (); return executor;} @ Override public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler () {return (ex, method, params)-> logger.error ("unknown exception occurred in thread pool task execution.", ex);}}

Multiple thread pools

@ Async annotation, using the system default or custom thread pool (instead of the default thread pool). Multiple thread pools can be set in the project to indicate the name of the thread pool that needs to be called when called asynchronously, such as @ Async ("new_task").

5. @ Async comment failure reason

There is no past to the proxy class, when this class is called, it is directly called internally and does not go to the proxy class.

1. The @ EnableAsync annotation was not added to the @ SpringBootApplication startup class.

two。 The return value of asynchronous methods using the annotation @ Async can only be void or Future.

3. There is no proxy class for Spring. Because the implementation of @ Transactional and @ Async annotations is based on Spring's AOP, while the implementation of AOP is based on the dynamic proxy pattern. Then the reason for the invalidation of the annotation is obvious, probably because the method is called by the object itself rather than the proxy object, because it does not go through the Spring container.

Solution:

Here is a specific solution to the third situation.

1. The method of the annotation must be the public method.

two。 The method must be called from another class, that is, from outside the class, and the internal call to the class is invalid.

3. If you need to call from within the class, you need to get its proxy class first, as shown in the following code

@ Servicepublic class AsyncService {public void methodA () {... AsyncService asyncServiceProxy = SpringUtil.getBean (AsyncService.class); asyncServiceProxy .methodB ();.} @ Async public void methodB () {...}}

Asynchronous multithreaded methods that implement the class called in this class can be defined in this class

Two things that must be achieved:

Public method to obtain spring bean manually

The utility class of SpringUtils, which gets the bean method manually:

Package intellif.util;import org.springframework.beans.BeansException;import org.springframework.context.ApplicationContext;import org.springframework.context.ApplicationContextAware;import org.springframework.stereotype.Component;/** * @ author liuyu * @ className SpringUtils * @ date 2019-12-16 20:55 * @ description * / @ Component ("springContextUtil") public class SpringUtils implements ApplicationContextAware {private static ApplicationContext applicationContext = null; public static ApplicationContext getApplicationContext () {return applicationContext } @ SuppressWarnings ("unchecked") public static T getBean (String beanId) {return (T) applicationContext.getBean (beanId);} public static T getBean (Class requiredType) {return (T) applicationContext.getBean (requiredType) } / * after the Spring container is started, applicationContext is automatically injected, and then we assign applicationContext * to the static variable to facilitate the subsequent acquisition of the container object * @ see org.springframework.context.ApplicationContextAware#setApplicationContext (org.springframework.context.ApplicationContext) * / @ Override public void setApplicationContext (ApplicationContext applicationContext) throws BeansException {SpringUtils.applicationContext = applicationContext;}}

This is the answer to the question about what the Springboot annotation @ Async thread pool instance is. I hope the above content can be of some help to you. If you still have a lot of doubts to be solved, you can follow the industry information channel for more related knowledge.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.