instructions
Using the @async annotation to create multiple threads is very convenient and can be configured to implement thread pools. Much simpler than using thread pools directly. In addition, it is no different from ordinary methods in use, with an @async annotation to achieve asynchronous calls.
usage
AsyncTask.java
@Component
public class AsyncTask {
private static final Logger LOG = LoggerFactory.getLogger(AsyncTask.class);
@Async
public void register(){
LOG.info("Multithreading starts registration emulation");
try {
Thread.sleep(1000*1);
} catch (InterruptedException e) {
e.printStackTrace();
}
LOG.info("Multi-thread registration successful"); }}Copy the code
This is just a simple printout, printed using Log4J to make it easy to see the thread name
AsyncTaskController.java
@RestController
@RequestMapping(value = "/async")
public class AsyncTaskController {
private final static Logger LOG = LoggerFactory.getLogger(AsyncTaskController.class);
@Autowired
private AsyncTask asyncTask;
@GetMapping(value = "/test")
public Object test() {for (int i = 0; i < 10; i++) {
asyncTask.register();
}
System.out.println("End of main thread");
return "OK"; }}Copy the code
This loop creates 10 threads
Enable the Async
Enabling Async requires the @enableAsync annotation
@SpringBootApplication @ServletComponentScan @EnableAsync public class App { public static void main(String[] args) { SpringApplication.run(App.class, args); }}Copy the code
The results of
As you can see, the main thread termination has ended. There is proof that multithreading works. In addition, by looking at the thread name, you can see that 10 threads were created to execute.
Using thread pools
As you can see from the above results, using the @async annotation directly creates the thread to execute it. However, in practical development, thread pools should be used to manage threads and save thread overhead.
configuration
TaskExecutorConfig.class
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
@Configuration
public class TaskExecutorConfig implements AsyncConfigurer {
/**
* Set the ThreadPoolExecutor's core pool size. */ private static final int CORE_POOL_SIZE = 2; /** * Set the ThreadPoolExecutor's maximum pool size.
*/
private static final int MAX_POOL_SIZE = 2;
/**
* Set the capacity for the ThreadPoolExecutor's BlockingQueue. */ private static final int QUEUE_CAPACITY = 10; /** * The AsyncConfigurer interface is implemented by overriding the getAsyncExcutor method to specify the default task execution. And return a ThreadPoolTaskExevutor * so we get a TaskExecutor based thread pool */ @override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor(); taskExecutor.setCorePoolSize(CORE_POOL_SIZE); taskExecutor.setMaxPoolSize(MAX_POOL_SIZE); taskExecutor.setQueueCapacity(QUEUE_CAPACITY); taskExecutor.initialize(); return taskExecutor; }}Copy the code
A maximum of two threads are set here.
test
Restart the program to test:
The results of
You can see that only two threads are executing, proving that the configured thread pool is working.