Как организуешь решение фоновых задач

# Организация фоновых задач в Java

Фоновые задачи — критическая часть современных приложений. Существует множество подходов для их реализации в зависимости от требований.

1. Spring @Scheduled — простые периодические задачи

Настройка

@Configuration
@EnableScheduling
public class SchedulingConfig {
    @Bean(name = "taskScheduler")
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(5);
        scheduler.setThreadNamePrefix("scheduled-task-");
        scheduler.setWaitForTasksToCompleteOnShutdown(true);
        scheduler.setAwaitTerminationSeconds(30);
        return scheduler;
    }
}

Примеры использования

@Service
public class EmailService {
    
    // Выполнять каждые 5 минут
    @Scheduled(fixedRate = 300000)
    public void sendPendingEmails() {
        System.out.println("Sending pending emails...");
        // логика
    }
    
    // Выполнять с задержкой 1 сек после окончания предыдущего
    @Scheduled(fixedDelay = 1000)
    public void cleanupExpiredEmails() {
        System.out.println("Cleaning up expired emails...");
    }
    
    // Выполнять по расписанию (cron)
    @Scheduled(cron = "0 0 * * * *")  // Каждый час в 0 минут
    public void dailyReport() {
        System.out.println("Generating daily report...");
    }
    
    // Выполнять один раз при старте (после delay)
    @Scheduled(initialDelay = 5000, fixedRate = 60000)
    public void startupTask() {
        System.out.println("Startup task after 5 seconds delay");
    }
}

Cron выражения

┌─────────────── секунды (0-59)
│ ┌───────────── минуты (0-59)
│ │ ┌─────────── часы (0-23)
│ │ │ ┌───────── день месяца (1-31)
│ │ │ │ ┌─────── месяц (1-12)
│ │ │ │ │ ┌───── день недели (0-6) (0=воскресенье)
│ │ │ │ │ │
│ │ │ │ │ │
* * * * * *

Примеры:
0 0 * * * *        // Каждый день в 00:00
0 */6 * * * *       // Каждые 6 часов
0 9 * * MON-FRI *   // Каждый день с понедельника по пятницу в 09:00
0 0 1 * * *         // Первого числа каждого месяца
0 0 1 1 * *         // 1 января в 00:00

2. Spring Task Executor — асинхронные задачи

@Configuration
@EnableAsync
public class AsyncConfig {
    @Bean(name = "taskExecutor")
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("async-task-");
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(30);
        executor.initialize();
        return executor;
    }
}

@Service
public class UserService {
    
    @Async("taskExecutor")
    public void sendWelcomeEmail(User user) {
        System.out.println("Sending welcome email to " + user.getEmail());
        emailService.send(user.getEmail(), "Welcome!");
    }
    
    @Async
    public CompletableFuture<String> processUserData(User user) {
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("Processing user: " + user.getId());
            return "Processed user: " + user.getId();
        });
    }
    
    public void registerUser(User user) {
        userRepository.save(user);
        sendWelcomeEmail(user);  // Выполнится асинхронно
    }
}

3. Spring @Transactional для фоновых задач

@Service
public class NotificationService {
    @Autowired
    private NotificationRepository repository;
    
    @Async
    @Transactional
    public void processPendingNotifications() {
        List<Notification> pending = repository.findByStatus("PENDING");
        
        for (Notification notification : pending) {
            try {
                sendNotification(notification);
                notification.setStatus("SENT");
                repository.save(notification);
            } catch (Exception e) {
                notification.setStatus("FAILED");
                notification.setError(e.getMessage());
                repository.save(notification);
            }
        }
    }
}

4. Message Queue подход (RabbitMQ, Kafka)

RabbitMQ

@Configuration
public class RabbitConfig {
    public static final String QUEUE_SEND_EMAIL = "email-queue";
    public static final String EXCHANGE_NAME = "app-exchange";
    public static final String ROUTING_KEY = "email.*";
    
    @Bean
    public DirectExchange exchange() {
        return new DirectExchange(EXCHANGE_NAME);
    }
    
    @Bean
    public Queue emailQueue() {
        return new Queue(QUEUE_SEND_EMAIL, true);
    }
    
    @Bean
    public Binding binding(Queue queue, DirectExchange exchange) {
        return BindingBuilder.bind(queue)
            .to(exchange)
            .with(ROUTING_KEY);
    }
}

@Service
public class EmailProducer {
    @Autowired
    private RabbitTemplate rabbitTemplate;
    
    public void sendEmail(EmailRequest request) {
        rabbitTemplate.convertAndSend(
            RabbitConfig.EXCHANGE_NAME,
            "email.send",
            request
        );
    }
}

@Service
public class EmailConsumer {
    @RabbitListener(queues = RabbitConfig.QUEUE_SEND_EMAIL)
    public void receiveMessage(EmailRequest request) {
        System.out.println("Processing email: " + request.getTo());
        emailService.send(request);
    }
}

5. Quartz Job Scheduler — сложные расписания

@Configuration
public class QuartzConfig {
    @Bean
    public JobDetail reportJobDetail() {
        return JobBuilder.newJob(ReportGenerationJob.class)
            .withIdentity("reportJob")
            .storeDurably()
            .build();
    }
    
    @Bean
    public Trigger reportJobTrigger(JobDetail jobDetail) {
        return TriggerBuilder.newTrigger()
            .forJob(jobDetail)
            .withIdentity("reportTrigger")
            .withSchedule(
                CronScheduleBuilder
                    .cronSchedule("0 0 2 * * ?")
                    .inTimeZone(TimeZone.getTimeZone("UTC"))
            )
            .build();
    }
}

@Component
public class ReportGenerationJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Generating report at " + context.getFireTime());
        try {
            generateReport();
        } catch (Exception e) {
            throw new JobExecutionException("Failed to generate report", e);
        }
    }
    
    private void generateReport() {
        // Логика генерации отчёта
    }
}

6. Обработка ошибок и retry логика

@Service
public class ReliableBackgroundTask {
    private static final int MAX_RETRIES = 3;
    private static final int RETRY_DELAY = 1000;  // 1 сек
    
    @Async
    public void executeWithRetry(String taskId) {
        int attempts = 0;
        while (attempts < MAX_RETRIES) {
            try {
                performTask(taskId);
                return;  // Успех
            } catch (RetryableException e) {
                attempts++;
                if (attempts >= MAX_RETRIES) {
                    logFailure(taskId, e);
                    notifyAdmins(taskId, e);
                    throw new UnrecoverableException("Task failed after retries", e);
                }
                sleep(RETRY_DELAY * attempts);  // Exponential backoff
            } catch (NonRetryableException e) {
                logFailure(taskId, e);
                throw e;
            }
        }
    }
    
    @Retryable(
        value = {TemporaryException.class},
        maxAttempts = 3,
        backoff = @Backoff(delay = 1000, multiplier = 2.0)
    )
    public void executeWithSpringRetry() {
        // Автоматический retry
        performTask("task-id");
    }
    
    @Recover
    public void recover(TemporaryException e) {
        logger.error("Task failed permanently after retries", e);
    }
}

7. Мониторинг и метрики

@Service
public class MonitoredBackgroundTask {
    @Autowired
    private MeterRegistry meterRegistry;
    
    @Scheduled(fixedRate = 60000)
    public void executeTask() {
        Timer.Sample sample = Timer.start(meterRegistry);
        
        try {
            performTask();
            meterRegistry.counter("task.success").increment();
        } catch (Exception e) {
            meterRegistry.counter("task.failure").increment();
            throw e;
        } finally {
            sample.stop(
                Timer.builder("task.duration")
                    .register(meterRegistry)
            );
        }
    }
}

8. Распределённые фоновые задачи

Для систем с несколькими инстансами приложения:

@Service
public class DistributedLockService {
    @Autowired
    private LockProvider lockProvider;
    
    @Scheduled(fixedRate = 60000)
    public void executeTaskWithLock() {
        lockProvider.lock()
            .withName("background-task")
            .withLockAtMostUntil(Instant.now().plusSeconds(120))
            .withLockAtLeastUntil(Instant.now().plusSeconds(10))
            .execute(() -> {
                System.out.println("Executing distributed task");
                performTask();
            });
    }
}

Сравнение подходов

Лучшие практики

1. Используй @Transactional для фоновых задач с БД
2. Реализуй retry логику для нестабильных операций
3. Логируй всё — ошибки, начало, окончание
4. Мониторь метрики — время выполнения, количество ошибок
5. Используй Message Queue для критических операций
6. Избегай блокировок — используй асинхронность
7. Устанавливай тайм-ауты для всех фоновых задач
8. Для распределённых систем используй distributed locks