Accueil › Spring Boot › Exécuter en arrière-plan avec @Async
Exécuter en arrière-plan avec @Async
Cache, tâches asynchrones et planifiéesintermediaire
@Async fait exécuter une méthode dans un autre thread : l'appelant récupère la main tout de suite, sans attendre la fin du traitement.
@Configuration
@EnableAsync
public class AsyncConfig { }
@Service
public class NotificationService {
@Async
public void envoyerEmail(String destinataire) {
// traitement lent, exécuté en arrière-plan
}
@Async
public CompletableFuture<Boolean> envoyerEtConfirmer(String destinataire) {
boolean succes = client.envoyer(destinataire);
return CompletableFuture.completedFuture(succes);
}
}
Une méthode @Async renvoie soit void (traitement « et oublie »), soit CompletableFuture<T> (ou Future<T>) pour transmettre un résultat à l'appelant sans le bloquer.
Points essentiels :
- Sans
Executordéfini, Spring Boot en auto-configure un (ThreadPoolTaskExecutor), réglable viaspring.task.execution.pool.*. - Une méthode
voidqui lève une exception : l'appelant ne le sait jamais. Seule une journalisation par défaut la signale. - La transaction et le contexte de sécurité du thread appelant ne suivent pas automatiquement le nouveau thread.
- Comme
@Transactional,@Asyncrepose sur un proxy : l'auto-invocation (this.methode()) le contourne.
Les termes à connaître
- @EnableAsync
Annotation posée sur une classe
@Configuration(ou la classe principale) qui active le traitement de@Async. Sans elle,@Asyncest silencieusement ignorée : la méthode s'exécute normalement, dans le thread appelant.- @Async
Posée sur une méthode, fait exécuter son corps dans un autre thread, fourni par un
Executor. L'appelant récupère la main immédiatement. La méthode doit renvoyervoid,Future<T>,CompletableFuture<T>(ou unListenableFuture, obsolète), jamais un type métier direct que l'appelant attendrait de façon synchrone.- ThreadPoolTaskExecutor
Exécuteur basé sur un pool de threads, utilisé par défaut par
@Async. Spring Boot en auto-configure un (beanapplicationTaskExecutor) si aucunExecutorn'est défini, configurable via les propriétésspring.task.execution.pool.*(core-size,max-size,queue-capacity…).- AsyncUncaughtExceptionHandler
Interface pour traiter les exceptions levées par une méthode
@Asyncqui renvoievoid: comme l'appelant ne peut récupérer aucun résultat, ces exceptions ne remontent jamais à lui. Par défaut, elles sont seulement journalisées (SimpleAsyncUncaughtExceptionHandler) ; on peut fournir sa propre implémentation viaAsyncConfigurer.- Propagation du contexte
La transaction en cours (liée au thread via
ThreadLocal) et le contexte de sécurité (SecurityContextHolder, par défaut lui aussi lié au thread) ne suivent pas l'exécution dans le nouveau thread créé par@Async. Une méthode@Transactionalappelée en asynchrone démarre donc sa propre transaction, indépendante de celle de l'appelant.- Auto-invocation
Comme
@Transactionalet@Cacheable,@Asyncrepose sur un proxy : un appel interne (this.methode()) le contourne, et l'exécution reste synchrone, sans erreur ni avertissement.- Threads virtuels (`spring.threads.virtual.enabled`)
Depuis Spring Boot 3.2, avec Java 21, la propriété
spring.threads.virtual.enabled=truefait remplacer les exécuteurs de tâches auto-configurés (dont celui utilisé par@Async) par un exécuteur qui crée un thread virtuel par tâche plutôt que de puiser dans un pool borné ; les propriétés de taille de pool (spring.task.execution.pool.*) n'ont alors plus d'effet.
Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.