Что нужно сделать, чтобы выполнить работу в многопоточном режиме в Spring?

Многопоточность в Spring: @Async, Executor и Task Scheduling

Это вопрос о асинхронном выполнении задач в Spring Framework. Рассмотрим все способы запуска работ в отдельных потоках.

1. @Async аннотация (самый простой способ)

@Async позволяет выполнять метод асинхронно, в отдельном потоке.

Шаг 1: Включить @EnableAsync

@Configuration
@EnableAsync  // ОБЯЗАТЕЛЬНО для работы @Async
public class AsyncConfig {
}

Шаг 2: Использовать @Async на методе

@Service
public class EmailService {
    
    // Без возврата значения
    @Async
    public void sendEmailAsync(String email, String message) {
        System.out.println(\"Sending email from thread: \" + 
            Thread.currentThread().getName());
        // Отправка займёт время, но не будет блокировать клиента
        sendEmail(email, message);
    }
    
    // С возврата значения (Future)
    @Async
    public Future<Boolean> sendEmailAsyncWithResult(String email) {
        try {
            sendEmail(email, \"Hello\");
            return new AsyncResult<>(true);
        } catch (Exception e) {
            return new AsyncResult<>(false);
        }
    }
}

// Использование в контроллере
@RestController
@RequestMapping(\"/api\")  
public class EmailController {
    
    @Autowired
    private EmailService emailService;
    
    @PostMapping(\"/send-email\")
    public String sendEmail(String email) {
        // Метод вернёт результат сразу, письмо отправится в фоне
        emailService.sendEmailAsync(email, \"Hello\");
        return \"Email queued for sending\";
    }
    
    @PostMapping(\"/send-and-wait\")
    public String sendEmailAndWait(String email) throws Exception {
        Future<Boolean> result = emailService.sendEmailAsyncWithResult(email);
        
        // Ждём результата с таймаутом
        Boolean sent = result.get(5, TimeUnit.SECONDS);
        
        return sent ? \"Email sent\" : \"Email failed\";
    }
}

2. Конфигурация Thread Pool

По умолчанию Spring использует SimpleAsyncTaskExecutor, но для production нужна своя конфигурация:

@Configuration
@EnableAsync
public class AsyncConfig implements AsyncConfigurer {
    
    @Override
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        
        // Количество потоков, всегда работающих
        executor.setCorePoolSize(5);
        
        // Максимальное количество потоков
        executor.setMaxPoolSize(20);
        
        // Очередь ожидающих задач
        executor.setQueueCapacity(100);
        
        // Имя для потоков
        executor.setThreadNamePrefix(\"async-executor-\");
        
        // Тайм-аут при выключении приложения
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        
        executor.initialize();
        return executor;
    }
    
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (throwable, method, params) -> {
            System.err.println(\"Exception in async method: \" + method.getName());
            throwable.printStackTrace();
        };
    }
}

3. TaskExecutor Bean

Вы можете создать несколько Executors для разных задач:

@Configuration
public class TaskExecutorConfig {
    
    // Для email отправки
    @Bean(name = \"emailExecutor\")
    public Executor emailExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(3);
        executor.setMaxPoolSize(5);
        executor.setQueueCapacity(50);
        executor.setThreadNamePrefix(\"email-thread-\");
        executor.initialize();
        return executor;
    }
    
    // Для обработки отчётов
    @Bean(name = \"reportExecutor\")
    public Executor reportExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(15);
        executor.setQueueCapacity(200);
        executor.setThreadNamePrefix(\"report-thread-\");
        executor.initialize();
        return executor;
    }
}

// Использование
@Service
public class TaskService {
    
    @Async(\"emailExecutor\")
    public void sendEmail(String email) {
        // Выполнится в потоке из emailExecutor
    }
    
    @Async(\"reportExecutor\")
    public void generateReport(String reportId) {
        // Выполнится в потоке из reportExecutor
    }
}

4. @Scheduled для периодических задач

@Configuration
@EnableScheduling  // ОБЯЗАТЕЛЬНО
public class SchedulingConfig {
}

@Component
public class ScheduledTasks {
    
    // Выполнять каждые 5 секунд
    @Scheduled(fixedRate = 5000)
    public void scheduleTask() {
        System.out.println(\"Task running at \" + System.currentTimeMillis());
    }
    
    // Выполнять с задержкой 2 сек между завершением и следующим запуском
    @Scheduled(fixedDelay = 2000)
    public void scheduleTaskWithDelay() {
        System.out.println(\"Task with delay\");
    }
    
    // Выполнять по расписанию (cron)
    @Scheduled(cron = \"0 0 * * * *\")  // Каждый час
    public void scheduleTaskWithCron() {
        System.out.println(\"Hourly task\");
    }
    
    // Выполнять один раз с задержкой 5 сек после старта
    @Scheduled(initialDelay = 5000, fixedRate = 10000)
    public void scheduleTaskWithInitialDelay() {
        System.out.println(\"Task with initial delay\");
    }
}

5. Директное использование Executor

@Service
public class TaskExecutionService {
    
    @Autowired
    @Qualifier(\"taskExecutor\")
    private Executor executor;
    
    public void executeTask() {
        executor.execute(() -> {
            System.out.println(\"Running in thread: \" + 
                Thread.currentThread().getName());
            // Долгая операция
        });
    }
    
    public void executeTasks() {
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println(\"Task \" + taskId + \" started\");
                // Обработка
            });
        }
    }
}

6. CompletableFuture для более сложных сценариев

@Service
public class AsyncComputingService {
    
    @Autowired
    private Executor executor;
    
    public CompletableFuture<String> fetchData(String id) {
        return CompletableFuture.supplyAsync(() -> {
            // Асинхронная операция
            return \"Data for \" + id;
        }, executor);
    }
    
    public void complexAsyncWorkflow() {
        CompletableFuture<String> task1 = 
            CompletableFuture.supplyAsync(() -> \"Step 1 complete\", executor);
        
        CompletableFuture<String> task2 = task1.thenApplyAsync(result -> {
            return result + \" -> Step 2 complete\";
        }, executor);
        
        CompletableFuture<String> task3 = 
            CompletableFuture.allOf(task1, task2)
                .thenApply(v -> \"All tasks complete\");
        
        task3.whenComplete((result, exception) -> {
            if (exception == null) {
                System.out.println(result);
            } else {
                System.err.println(\"Error: \" + exception.getMessage());
            }
        });
    }
}

7. Обработка ошибок в асинхронных методах

@Service
public class RobustAsyncService {
    
    @Async
    public Future<String> executeWithErrorHandling(String input) {
        try {
            // Рискованная операция
            String result = processData(input);
            return new AsyncResult<>(result);
        } catch (Exception e) {
            return new AsyncResult<>(\"Error: \" + e.getMessage());
        }
    }
    
    @Async
    public void executeWithCallback(String input, Consumer<String> callback) {
        try {
            String result = processData(input);
            callback.accept(result);
        } catch (Exception e) {
            callback.accept(\"Error: \" + e.getMessage());
        }
    }
}

// Использование
@RestController
public class Controller {
    @Autowired
    private RobustAsyncService service;
    
    @GetMapping(\"/process\")
    public void process(String input) {
        service.executeWithCallback(input, result -> {
            System.out.println(\"Processing complete: \" + result);
        });
    }
}

Чеклист многопоточности в Spring

• @EnableAsync включена в конфигурации
• Thread Pool настроен с правильными параметрами
• Таймауты установлены (AwaitTerminationSeconds)
• Обработка ошибок реализована
• Logging добавлен для отладки
• Не используется SimpleAsyncTaskExecutor в production

Типичный ответ на собеседовании

\"Для многопоточного выполнения в Spring можно использовать
@Async аннотацию — это самый простой способ.

Прежде всего нужно включить @EnableAsync в конфигурации.
Потом просто добавить @Async на методы, которые должны 
выполняться асинхронно.

Для production нужно настроить свой ThreadPoolTaskExecutor
с нужным количеством потоков, размером очереди и таймаутами.

Для периодических задач используется @Scheduled с
@EnableScheduling.

Для более сложных сценариев можно использовать
CompletableFuture или напрямую работать с Executor.

Важно обрабатывать исключения и правильно настроить
thread pool, чтобы приложение корректно завершалось.\"

Вывод: Spring предоставляет удобные инструменты для многопоточности через @Async, @Scheduled и TaskExecutor. Главное — правильно настроить thread pool и обработать ошибки.