Implémentation de Springboot Multitasking Parallel + Thread Pool Processing

Préface

Les articles précédents se concentrent sur l'optimisation de la base de données de services back-end et du traitement parallèle multithread, et des exemples de logique de pseudocode avant et après transformation. Bien sûr, l'optimisation est infinie. Les générations précédentes sont des arbres de plante et des générations ultérieures profitent de l'ombre. En tant que développeurs, puisque nous nous tenons sur les épaules des géants, nous devons écrire des programmes plus optimisés.

Springboot Development Case JDBCTemplate Batch Operation
Cas de développement de Springboot: CountdownLatch Multitasking Parallel Processing

Rénovation

Théoriquement, plus il y a de threads, plus le programme peut être rapide, mais en usage réel, nous devons considérer la consommation de ressources de la création et de la destruction du fil lui-même, ainsi que le but de protéger le système d'exploitation lui-même. Nous devons généralement limiter les threads à une certaine plage, et les pools de threads jouent ce rôle.

Logique du programme

Multitâche parallèle + thread Pool Processing.png

Les problèmes qui peuvent être résolus par une image devraient être le plus peu possible. Bien sûr, le principe sous-jacent doit encore être rappelé et compris par tout le monde.

Piscine de fil Java

Java fournit quatre types de pools de fil par le biais d'exécuteurs, à savoir:

1. NewCachedThreadpool crée une piscine de fil cacheable. Si la longueur du pool de filetage dépasse les besoins de traitement, il peut recycler flexiblement les threads inactifs. S'il n'y a pas de recyclage, créez un nouveau fil.
2. NewFixEdThreadPool crée un pool de threads de longueur fixe qui peut contrôler le nombre maximum de threads concurrencés, et les threads excédentaires attendront dans la file d'attente.
3. NewsCheDuleDThreadPool crée un pool de threads de longueur fixe qui prend en charge l'exécution de tâches chronométrée et périodique.
4. NewsingEthreAdExecutor crée un pool de threads unique, qui n'utilisera qu'un thread de travailleur unique pour exécuter des tâches, en veillant à ce que toutes les tâches soient exécutées dans l'ordre spécifié (FIFO, LIFO, priorité).

avantage

1. Réutilisez les threads existants pour réduire les frais généraux de la création et de l'extinction d'objets, et bien performer.
2. Il peut contrôler efficacement le nombre maximal de threads simultanés, améliorer le taux d'utilisation des ressources du système et éviter une concurrence excessive des ressources et éviter le blocage.
3. Fournit des fonctions telles que l'exécution chronométrée, l'exécution régulière, le threading unique, le contrôle des nombres simultanés, etc.

Implémentation de code

Méthode 1 (compte à rebours)

 / ** * Multitasking Paralall + Thread Pool Statistics * Temps de création 17 avril 2018 * / public class StatSdemo {final static SimpledateFormat sdf = new SimpledateFormat ("yyyy-mm-dd hh: mm: ss"); Final Static String startTime = sdf.format (new Date ()); / ** * Tâches Io en attente = Généralement 2 * Nombre de cœurs de CPU (souvent dans les threads: interaction de données de base de données, téléchargement de fichiers et téléchargement, transmission des données réseau, etc.) * Tâches à forte intensité de processe Runtime.getRuntime (). DisponibleProcessors (); / ** * public threadpoolExecutor (int corepoolSize, int maximumpoolSize, long keepalivetime, * timeUnit Unit, blockingQueue <runnable> workQueue) * CorePoolSize est utilisé pour spécifier le nombre de threads de base * MaximuMumpoolSize spécifie le nombre maximum de threads * La file d'attente de tampon du pool de threads et les threads qui n'ont pas encore été exécutés attendent dans la file d'attente * la longueur de la file d'attente du moniteur pour garantir que la file d'attente * une mauvaise taille de pool de threads peut ralentir la vitesse de traitement, réduire la stabilité et entraîner une fuite de mémoire. S'il y a trop peu de threads configurés, la file d'attente continuera de grandir et de consommer trop de mémoire. * Et trop de threads ralentiront la vitesse de l'ensemble du système en raison de la commutation de contexte fréquente - et le même résultat final sera obtenu. La longueur de la file d'attente est cruciale, elle doit être bornée de sorte que si le pool de threads est submergé, il peut temporairement rejeter de nouvelles demandes. * L'implémentation par défaut de ExecutorService est un liendblockingque Linked Blocking. * / Private Static ThreadPoolExecutor Executor = new ThreadPoolExecutor (CorePoolSize, CorePoolSize + 1, 10L, timeunit.seconds, new LinkedBlockingQueue <Runnable> (1000)); public static void main (String [] args) lève InterruptedException {CountdownLatch latch = new CountdownLatch (5); // Utilisez Execute Method Executor.Exécute (nouvelles statistiques ("Tâche A", 1000, Latch)); Executor.Execute (nouvelles statistiques ("Tâche B", 1000, Latch)); Executor.Execute (nouvelles statistiques ("tâche C", 1000, Latch)); Executor.Execute (nouvelles statistiques ("tâche D", 1000, Latch)); Executor.Execute (nouvelles statistiques ("Tâche E", 1000, Latch)); latch.await (); // attendez que la tâche de tout le monde mette fin à System.out.println ("toutes les tâches statistiques que l'exécution est terminée:" + sdf.format (new Date ())); } static static statts implémente runnable {String statSname; int runtime; CountdownLatch Latch; Public Stats (String StatSname, int runtime, CountdownLatch Latch) {this.statsname = statSname; this.runtime = runtime; this.latch = latch; } public void run () {try {System.out.println (statSname + "Do statistiques commencent à" + starttime); // Simuler le temps d'exécution de la tâche Thread.Sleep (Runtime); System.out.println (StatsName + "DO STATS ENTRÉMENTATIVE AT" + SDF.Format (new Date ())); Latch.CountDown (); // Une seule tâche se termine, le compteur est réduit d'un} catch (InterruptedException e) {e.printStackTrace (); }}}}

Méthode 2 (futur)

 / ** * Multitasking Paralall + Thread Pool Statistics * Temps de création 17 avril 2018 * / public class StatSdemo {final static SimpledateFormat sdf = new SimpledateFormat ("yyyy-mm-dd hh: mm: ss"); Final Static String startTime = sdf.format (new Date ()); / ** * Tâches Io en attente = Généralement 2 * Nombre de cœurs de CPU (souvent dans les threads: interaction de données de base de données, téléchargement de fichiers et téléchargement, transmission des données réseau, etc.) * Tâches à forte intensité de processe Runtime.getRuntime (). DisponibleProcessors (); / ** * public threadpoolExecutor (int corepoolSize, int maximumpoolSize, long keepalivetime, * timeUnit Unit, blockingQueue <runnable> workQueue) * CorePoolSize est utilisé pour spécifier le nombre de threads de base * MaximuMumpoolSize spécifie le nombre maximum de threads * La file d'attente de tampon du pool de threads et les threads qui n'ont pas encore été exécutés attendent dans la file d'attente * la longueur de la file d'attente du moniteur pour garantir que la file d'attente * une mauvaise taille de pool de threads peut ralentir la vitesse de traitement, réduire la stabilité et entraîner une fuite de mémoire. S'il y a trop peu de threads configurés, la file d'attente continuera de grandir et de consommer trop de mémoire. * Et trop de threads ralentiront la vitesse de l'ensemble du système en raison de la commutation de contexte fréquente - et le même résultat final sera obtenu. La longueur de la file d'attente est cruciale, elle doit être bornée de sorte que si le pool de threads est submergé, il peut temporairement rejeter de nouvelles demandes. * L'implémentation par défaut de ExecutorService est un liendblockingque Linked Blocking. * / Private Static ThreadPoolExecutor Executor = new ThreadPoolExecutor (CorePoolSize, CorePoolSize + 1, 10L, timeunit.seconds, new LinkedBlockingQueue <Runnable> (1000)); public static void main (String [] args) lève InterruptedException {list <future <string>> resultList = new ArrayList <futur <string >> (); // Utiliser la tâche Asynchrones Soumettre et obtenir la valeur de retour en tant que future resultList.add (exécutor.Submit (nouvelles statistiques ("tâche A", 1000))); resultList.add (exécutor.sumit (nouvelles statistiques ("tâche B", 1000))); resultList.add (exécutor.sumit (nouvelles statistiques ("tâche C", 1000))); resultList.add (exécutor.sumit (nouvelles statistiques ("tâche D", 1000))); resultList.add (exécutor.sumit (nouvelles statistiques ("tâche E", 1000))); // Résultat de la tâche de traversée pour (futur <string> fs: resultList) {try {system.out.println (fs.get ()); // imprime les résultats de chaque exécution de la tâche de ligne, appelez Future.get () pour bloquer le thread principal, et obtenir le résultat de retour de la tâche asynchronique} catch (interruptedException e) {e.printStackTrace (); } catch (EXECUTUTIONException e) {e.printStackTrace (); } Enfin {// Démarrez une fois et exécutez les tâches précédemment soumises, mais n'acceptez pas de nouvelles tâches. S'il a été fermé, l'appel n'a aucun autre effet. exécuteur.shutdown (); }} System.out.println ("Toutes les tâches statistiques sont exécutées:" + sdf.format (new Date ())); } Static Class Statts implémente callable <string> {String statSname; int runtime; public statistiques (String statSname, int runtime) {this.statsname = statSname; this.runtime = runtime; } public String Call () {try {System.out.println (statSname + "Do Stats commence à" + starttime); // Simuler le temps d'exécution de la tâche Thread.Sleep (Runtime); System.out.println (StatsName + "DO STATS ENTRÉMENTATIVE AT" + SDF.Format (new Date ())); } catch (InterruptedException e) {e.printStackTrace (); } return call (); }}}

Temps d'exécution

Les codes ci-dessus sont tous des pseudo-codes, et les éléments suivants sont de réels enregistrements de plus de 2 000 étudiants.

2018-04-17 17: 42: 29.284 Enregistrement des tests d'information 81E51AB031EB4ADA92743DDF66528D82 Exécution séquentielle-thread, temps passé: 3797
2018-04-17 17: 42: 31.452 Enregistrement des tests d'informations 81E51AB031EB4ADA92743DDF66528D82 Tâche parallèle-threaded-thread, temps passé: 2167
2018-04-17 17: 42: 33.170 Enregistrement des tests d'informations 81E51AB031EB4ADA92743DDF66528D82 Tâche parallèle et thread-thread Pool, temps passé: 1717

Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.