Spring Boot utilise @async pour implémenter les appels asynchrones: pool de thread personnalisé

Préface

Dans la série de didacticiels Spring Boot précédente, l'article "Utilisation de @async pour implémenter les appels asynchrones dans Spring Boot" a été introduit comment utiliser @async Annotation pour implémenter les appels asynchrones. Cependant, le contrôle de ces exécutions asynchrones est notre compétence de base pour assurer la santé de nos propres applications. Dans cet article, apprenons si nous contrôlons la concurrence des appels asynchrones via des pools de threads personnalisés.

Nous pouvons modifier les exemples de cet article en fonction des exemples précédents, ou créer un tout nouveau projet Spring Boot à essayer.

Définir la piscine de thread

La première étape consiste à définir un pool de threads dans la classe principale de démarrage de printemps, comme:

 @SpringBootApplicationPublic class Application {public static void main (String [] args) {springApplication.run (application.class, args); } @Enableasync @configuration class taskpoolconfig {@bean ("taskexecutor") public exécutor taskexecutor () {threadpooltaskexecutor exécutor = new ThreadPoolTasKExECutor (); Executor.SetCorePoolSize (10); Executor.SetMaxPoolSize (20); Executor.SetQueUeCapacity (200); Executor.SetkeepalivesEnconds (60); EMECTOR.SetThreadNamePrefix ("TaskExEcutor-"); Executor.SetRejectEdExecutionHandler (new ThreadPoolExecutor.CallerRunspolicy ()); return exécuteur; }}}

Ci-dessus, nous avons créé un pool de thread en utilisant ThreadPoolTasKexeCutor et définissez les paramètres suivants:

• Nombre de threads de base 10: le nombre de threads initialisés lorsque le pool de threads est créé
• Nombre maximum de threads 20: Le plus grand nombre de threads dans le pool de threads. Ce n'est qu'après que la file d'attente de tampon est pleine que les threads dépasseront le nombre de threads de base appliqués.
• Buffer Fitre 200: Une file d'attente utilisée pour tamponner les tâches d'exécution
• Permet le temps d'inactivité des threads pendant 60 secondes: lorsque les threads qui dépassent le thread noyau seront détruits après l'arrivée du temps d'inactivité.
• Préfixe du nom du pool de threads Nom du pool: après l'avoir réglé, il peut nous faciliter la localisation du pool de threads où la tâche est traitée
• Stratégie de traitement du pool de threads pour les tâches rejetées: la politique Callerserrunspolicy est adoptée ici. Lorsque le pool de threads n'a aucune capacité de traitement, la stratégie exécutera directement la tâche rejetée dans le thread d'appel de la méthode d'exécution; Si le programme d'exécution est fermé, la tâche sera rejetée.

Utilisation de la piscine de threads

Après avoir défini le pool de threads, comment pouvons-nous faire fonctionner les tâches d'exécution de manière asynchrone à l'aide des ressources de ce pool de threads? La méthode est très simple. Nous avons juste besoin de spécifier le nom du pool de threads dans l'annotation @async, par exemple:

 @ Slf4j @ ComponentPublic Class tâche {public static aléal aléatoire = new random (); @Async ("taskexecutor") public void dotaskone () lève une exception {log.info ("Démarrer la tâche un"); Long start = System.CurrentTimemillis (); Thread.sleep (random.nextint (10000)); Long End = System.Currenttimemillis (); log.info ("Tâche complète un, temps pris:" + (end - démarrer) + "millisecondes"); } @Async ("taskexecutor") public void dotasktwo () lève une exception {log.info ("Démarrer la tâche 2"); Long start = System.CurrentTimemillis (); Thread.sleep (random.nextint (10000)); Long End = System.Currenttimemillis (); Log.info ("Tâche complète 2, temps pris:" + (end - start) + "millisecondes"); } @Async ("taskexecutor") public void dotaskThere () lève l'exception {log.info ("Démarrer la tâche trois"); Long start = System.CurrentTimemillis (); Thread.sleep (random.nextint (10000)); Long End = System.Currenttimemillis (); Log.info ("Tâche complète trois, qui prend du temps:" + (end - start) + "millisecondes"); }}

Tests unitaires

Enfin, écrivons un test unitaire pour le vérifier

 @Runwith (springjunit4classrunner.class) @springboottestpublic class applicationTests {@autowired tâche privée tâche; @Test public void test () lève une exception {tâche.dotaskone (); tâche.dotasktwo (); tâche.dotaskThere (); Thread.currentThread (). JOIN (); }}

Effectuez le test unitaire ci-dessus, nous pouvons voir dans la console que tous les noms de threads de sortie sont préfixés par le pool de threads que nous avons défini auparavant, ce qui signifie que notre expérience utilisant du pool de threads pour effectuer des tâches asynchrones a été réussie!

2018-03-27 22: 01: 15.620 Info 73703 --- [taskexecutor-1] com.didispace.async.task: commencez à faire la tâche un
2018-03-27 22: 01: 15.620 Info 73703 --- [taskexecutor-2] com.didispace.async.task: Démarrer la tâche 2
2018-03-27 22: 01: 15.620 Info 73703 --- [taskexecutor-3] com.didispace.async.task: Démarrer la tâche trois
2018-03-27 22: 01: 18.165 Info 73703 --- [TASKEXECUTOR-2] com.didispace.async.task: Tâche complète 2, temps pris: 2545 millisecondes
2018-03-27 22: 01: 22.149 Info 73703 --- [taskexecutor-3] com.didispace.async.task: Tâche complète trois, temps pris: 6529 millisecondes
2018-03-27 22: 01: 23.912 Info 73703 --- [TASKEXECUTOR-1] com.didispace.async.task: Tâche complète, temps pris: 8292 millisecondes

Exemple complet:

Les lecteurs peuvent choisir de voir le projet du chapitre 4-1-3 selon 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.