Bei der asynchronen Verarbeitung mit "@ Async" können Sie die Anzahl der gleichzeitigen Ausführungen steuern, indem Sie "ThreadPoolTaskExecutor" ausführen. Wenn jedoch wichtige Prozesse und weniger wichtige Prozesse im selben Thread-Pool verwaltet werden und eine große Anzahl unwichtiger Prozesse auf die Ausführung wartet, selbst wenn Sie versuchen, wichtige Prozesse auszuführen, ist die Ausführung schwierig. Machen.

Daher möchte ich den von der Verarbeitung verwendeten TaskExecutor aufteilen und mit einem anderen ThreadPool verwalten.

Implementierungsmethode

Definieren Sie zwei TaskExecutor-Beans. Beide sind ThreadPoolTaskExecutors, und die Anzahl der gleichzeitigen Ausführungen beträgt 1.

@SpringBootApplication
@EnableAsync
public class TaskApplication {

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

    @Bean
    TaskExecutor importantTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(1);
        executor.setMaxPoolSize(1);
        executor.setQueueCapacity(5);
        return executor;
    }

    @Bean
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(1);
        executor.setMaxPoolSize(1);
        executor.setQueueCapacity(5);
        return executor;
    }
}

Der Teil, der die asynchrone Verarbeitung ausführt, wird wie folgt implementiert. (Schnittstelle weggelassen) Geben Sie den Namen des TaskExecutors an, der in "@ Async" verwendet wird. Indem Sie 10 Sekunden lang in den Ruhezustand versetzen, wird der Wartestatus für die Ausführung generiert.

@Service
@Slf4j
public class TaskServiceImpl implements TaskService {

    @Async("importantTaskExecutor")
    @Override
    public void importantTask() {
        try {
            log.info("start important task");
            TimeUnit.SECONDS.sleep(10);
            log.info("end important task");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Async("taskExecutor")
    @Override
    public void task() {
        try {
            log.info("start normal task");
            TimeUnit.SECONDS.sleep(10);
            log.info("end normal task");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Ich habe den Vorgang mit dem folgenden Code bestätigt.

@RestController
@RequiredArgsConstructor
public class TaskAsyncController {

    private final TaskService taskService;

    @GetMapping("/")
    public String task() {
        taskService.task();
        taskService.task();
        taskService.task();
        taskService.task();
        taskService.importantTask();

        return "Success!!";
    }
}

Bei der Ausführung wird eine Taskmethode ausgeführt, die restlichen drei befinden sich jedoch im Wartezustand der Ausführung. Die Methode "ImportantTask" wartet jedoch nicht auf die Ausführung und wird sofort ausgeführt.

Jetzt können Sie sehen, dass ein anderer ThreadPoolTaskExecutor verfügbar ist.

[JAVA] Separate Task Executors, die von @Async im Frühjahr verwendet werden

Implementierungsmethode