Spring Boot utilise @ASync Asynchronous Call: Explication détaillée de l'utilisation de l'avenir et de la définition du délai d'expiration

Préface

J'ai écrit plusieurs articles sur la mise en œuvre d'appels asynchrones à l'aide de @async, et j'ai également reçu des commentaires de nombreuses chaussures pour enfants. Parmi eux, le plus de problèmes concerne l'utilisation des futurs et le contrôle du délai d'exécution de l'exécution asynchrone. Je vais donc parler ensemble de la gestion de ces deux problèmes.

Si vous ne connaissez pas l'utilisation des annotations @async, vous pouvez consulter l'article précédent, comme suit:

• Implémentez les appels asynchrones à l'aide de @async
• Implémentation d'appels asynchrones avec @async: pool de threads personnalisés
• Implémentation d'appel asynchrone avec @async: les ressources sont fermées gracieusement

Définir les tâches asynchrones

Tout d'abord, nous utilisons d'abord l'annotation @async pour définir une tâche asynchrone. Cette méthode renvoie le type futur, comme suit:

 @ Slf4j @ ComponentPublic Class tâche {public static aléal aléatoire = new random (); @Async ("taskexecutor") public future <string> run () lève une exception {long sleep = random.nextint (10000); Log.info ("Démarrez la tâche, temps pour prendre:" + Sleep + "MSILS"); Thread.Sleep (sommeil); log.info ("terminer la tâche"); retourner un nouveau asyncresult <> ("test"); }}

Conseils: Quel est le type futur?

L'avenir est une interface qui annule les résultats d'exécution de tâches exécutables ou appelables spécifiques, vérifie si la requête est terminée et obtient les résultats. Si nécessaire, vous pouvez obtenir le résultat d'exécution via la méthode GET, qui bloque jusqu'à ce que la tâche renvoie le résultat.

Sa définition d'interface est la suivante:

 Interface publique Future <v> {booléen annuler (booléen MayInterrupfrunning); Boolean Iscancelled (); Boolean Isdone (); V get () lève InterruptedException, ExecutionException; V Get (temps de temps long, unité TimeUnit) lance InterruptedException, ExecutionException, TimeoutException;}

Il déclare cinq méthodes comme ceci:

• La méthode d'annulation est utilisée pour annuler la tâche et renvoie True si la tâche d'annulation est réussie et renvoie Faux si la tâche d'annulation est en panne. Le paramètre peut interruption indique s'il faut permettre l'annulation des tâches qui sont exécutées mais non terminées. Si cela est vrai, cela signifie que les tâches exécutées peuvent être annulées. Si la tâche a été terminée, que la conduite peut-être pas ou non réelle, cette méthode reviendra certainement fausse, c'est-à-dire que si la tâche terminée est annulée, FALSE sera renvoyé; Si la tâche est en cours d'exécution, si May Interrupfrunning est défini sur true, True sera renvoyé, si MayInterrupfrunning est défini sur False, False sera renvoyé; Si MayInterrupTifrunning est défini sur False, False sera certainement retourné.
• La méthode isCancelled indique si la tâche a été annulée avec succès. S'il a été annulé avec succès avant la fin de la tâche normalement, il renvoie vrai.
• La méthode Isdone indique si la tâche a été terminée. Si la tâche est terminée, elle renvoie vrai;
• La méthode get () est utilisée pour obtenir le résultat d'exécution. Cette méthode provoquera un blocage et attendra que la tâche soit exécutée avant de retourner;
• GET (temps d'attente longue, unité TimeUnit) est utilisé pour obtenir le résultat d'exécution. Si le résultat n'a pas été obtenu dans le délai spécifié, il renverra directement NULL.

En d'autres termes, Future fournit trois fonctions:

1. Déterminer si la tâche est terminée;
2. Capacité à interrompre les tâches;
3. Capable d'obtenir des résultats d'exécution des tâches.

Test d'exécution et de détente de définition

Après avoir terminé la définition de la tâche asynchrone qui renvoie à l'avenir, nous essayons d'implémenter un test unitaire pour utiliser cet avenir pour terminer l'exécution de la tâche, telle que:

 @ Slf4j @ runwith (springjunit4classrunner.class) @springboottestpublic class applicationTests {@Autowired Private tâche; @Test public void test () lève une exception {future <string> futureResult = task.run (); String result = futureResult.get (5, timeunit.seconds); log.info (résultat); }}

Dans le code ci-dessus, nous définissons également l'heure de délai d'exécution pour que le thread puisse exécuter dans la méthode GET. En exécutant ce test, nous pouvons observer que lorsque le temps d'exécution dépasse 5 secondes, une exception de temps mort sera lancée ici. Le thread d'exécution peut être relâché dans le pool de threads en raison du délai d'exécution, afin de ne pas bloquer et occuper les ressources.

Exemple complet:

Les lecteurs peuvent choisir les deux référentiels suivants pour afficher les projets du chapitre4-1-4 en fonction de leurs préférences:

Github: https://github.com/dyc87112/springboot-learning/

Gitee: https://gitee.com/diidispace/springboot-learning/

Téléchargement local: http://xiazai.vevb.com/201805/yuanma/springboot-learning(vevb.com).rar

Résumer

Ce qui précède est l'intégralité du contenu de cet article. J'espère que le contenu de cet article a une certaine valeur de référence pour l'étude ou le travail de chacun. Si vous avez des questions, vous pouvez laisser un message pour communiquer. Merci pour votre soutien à wulin.com.