Introduction à plusieurs méthodes de mise en œuvre et différences du pool de threads Java
import java.text.dateformat; import java.text.simpledateFormat; import java.util.arraylist; import java.util.date; import java.util.list; import java.util.lit; java.util.concurrent.execcutors; import java.util.concurrent.future; public class TestThreadpool {// -newfixedThreadpool est similaire à CachethReadpool, et peut également être utilisé s'il est réutilisé, mais il ne peut pas créer de nouveaux fils à tout moment // - son non-effort: à tout point dans le temps, dans le plus, il peut y avoir un numéro actif. À l'heure actuelle, s'il y a un nouveau fil à établir, il ne peut être placé que dans une autre file d'attente et attendre qu'un fil dans le thread actuel se termine et est déplacé directement de la piscine // - Contrairement à CachethReadpool, FixedThreadpool n'a pas de mécanisme de ralenti (il peut également y avoir, mais comme le document ne le mentionne pas, il doit être très long, similaire à TCP ou UDP // FixedThereadpool est principalement destiné à certains threads simultanés réguliers très stables et fixe, principalement utilisés dans les serveurs // - à partir du code source de la méthode, le pool de cache et la fixe des appels de pool le même pool sous-jacent, mais les paramètres sont différents: // Le nombre de threads de pool fixe est fixe, et il est 0 seconde de ralenti (pas de ralenti) // le comptage de threads de pool de cache est 0-INTERGE. pas du tout considéré), 60 secondes inactif statique privé ExecutorService fixeService = exécutor.NewFixEdThreadPool (6); // -cache Pool, vérifiez d'abord s'il y a des threads précédemment établis dans la piscine, s'il y en a, réutiliser. Sinon, créez un nouveau thread et ajoutez-le au pool // -cache Pool est généralement utilisé pour effectuer certaines tâches asynchrones avec une durée de vie très courte // Par conséquent, il n'est pas utilisé beaucoup dans certains serveurs de type démon axé sur la connexion. // - Le fil qui peut réutiliser doit être un fil dans la piscine dans le délai d'attente. Le délai d'expiration par défaut est de 60s. Si le temps inactif dépasse la durée, l'instance de fil sera terminée et déplacée de la piscine. // Notez que le fil mettant le fil dans le CacheThreadpool n'a pas à s'inquiéter de sa fin. S'il est inactif après le temps mort, il sera automatiquement terminé. Private Static ExecutorService CacheService = Executor.NewCachedThreadPool (); // -Singleton Thread, il ne peut y avoir qu'un seul thread dans n'importe quel pool de temps // -Le pool sous-jacent est le même que le pool de cache et la piscine fixe, mais le nombre de threads est de 1-1,0 seconde inactif (pas d'inactivité) privé statique ExecutorService SingleService = exécutor // - Pool de threadscheduled //-les threads de ce pool peuvent être retardés dans la séquence en fonction du calendrier, ou le STATIC ExecutorService privé ScheduledService = Exécutors.NewScheduledThreadPool (10); public static void main (String [] args) {dateFormat format = new SimpledateFormat ("yyyy-mm-dd hh: mm: ss"); List <Integer> CustomerList = new ArrayList <Integer> (); System.out.println (format.format (new Date ())); TestFixEdThreadPool (CorrectService, CustomerList); System.out.println ("--------------------------"); TestFixEdThreadPool (CorrectService, CustomerList); fixeService.shutdown (); System.out.println (fixeService.isshutdown ()); System.out.println ("------------------------------------------------"); TestCacheThReadPool (CacheService, CustomerList); System.out.println ("------------------------------------------------"); TestCacheThReadPool (CacheService, CustomerList); cacheservice.shutdownNow (); System.out.println ("------------------------------------------------"); TestSingleServiceThreadpool (SingleService, CustomerList); TestSingleServiceThreadpool (SingleService, CustomerList); SingleService.shutdown (); System.out.println ("------------------------------------------------"); TestScheduledServiceThreadpool (ScheduledService, CustomerList); TestScheduledServiceThreadpool (ScheduledService, CustomerList); ScheduledService.shutdown (); } public static void TestScheduledServiceThreadpool (ExecutorService Service, list <Integer> CustomerList) {list <callable <Integer>> listCallable = new ArrayList <callable <nteger>> (); pour (int i = 0; i <10; i ++) {callable <Integer> callable = new Callable <Integer> () {@Override public Integer Call () lève une exception {return new Random (). NextInt (10); }}; listCallable.add (callable); } essayez {list <futur <Integer>> listfuture = service.invokeAll (listCallable); pour (futur <Integer> futur: listFuture) {Integer id = future.get (); CustomerList.add (id); }} catch (exception e) {e.printStackTrace (); } System.out.println (CustomerList.ToString ()); } public static void TestSingleServiceThreadpool (ExecutorService Service, list <Integer> CustomerList) {list <callable <list <nteger>>> listCallable = new ArrayList <callable <list <nteger>>> (); pour (int i = 0; i <10; i ++) {callable <list <nteger>>> callable = new Callable <list <Integer>> () {@Override public list <nteger> call () lève exception {list <nteger> list = getList (new random (). NextInt (10)); booléen isstop = false; while (list.size ()> 0 &&! isStop) {System.out.println (thread.currentThread (). getID () + "- Sleep: 1000"); isStop = true; } Retour List; }}; listCallable.add (callable); } essayez {list <future <list <Integer>>> listfuture = service.invokeAll (listCallable); pour (futur <list <Integer>> futur: listFuture) {list <Integer> list = future.get (); CustomerList.Addall (liste); }} catch (exception e) {e.printStackTrace (); } System.out.println (CustomerList.ToString ()); } public static void testCacheThreadpool (ExecutorService Service, list <Integer> CustomerList) {list <callable <list <nteger>>> listCallable = new ArrayList <callable <list <nteger>> (); for (int i = 0; i <10; i ++) {callable <list <nteger>> callable = new Callable <list <nteger>> () {@Override public list <nteger> call () lève exception {list <nteger> list = getList (new Random (). NextInt (10)); booléen isstop = false; while (list.size ()> 0 &&! isStop) {System.out.println (thread.currentThread (). getID () + "- Sleep: 1000"); isStop = true; } Retour List; }}; listCallable.add (callable); } essayez {list <future <list <Integer>>> listfuture = service.invokeAll (listCallable); pour (futur <list <Integer>> futur: listFuture) {list <Integer> list = future.get (); CustomerList.Addall (liste); }} catch (exception e) {e.printStackTrace (); } System.out.println (CustomerList.ToString ()); } public static void testFixEdThreadpool (ExecutorService Service, list <Integer> CustomerList) {list <callable <list <nteger>>> listCallable = new ArrayList <callable <list <nteger>>> (); for (int i = 0; i <10; i ++) {callable <list <nteger>> callable = new Callable <list <nteger>> () {@Override public list <nteger> call () lève exception {list <nteger> list = getList (new Random (). NextInt (10)); booléen isstop = false; while (list.size ()> 0 &&! isStop) {System.out.println (thread.currentThread (). getID () + "- Sleep: 1000"); isStop = true; } Retour List; }}; listCallable.add (callable); } essayez {list <future <list <Integer>>> listfuture = service.invokeAll (listCallable); pour (futur <list <Integer>> futur: listFuture) {list <Integer> list = future.get (); CustomerList.Addall (liste); }} catch (exception e) {e.printStackTrace (); } System.out.println (CustomerList.ToString ()); } public static list <Integer> getList (int x) {list <Integer> list = new ArrayList <Integer> (); list.add (x); list.add (x * x); Liste de retour; }}Utilisation: LinkedBlockingQueue pour implémenter l'explication du pool de threads
// Par exemple: CorePoolSize = 3, maximumpoolSize = 6, LinkedBlockerQueue (10) // RejectEdExecutionHandler La méthode de traitement par défaut est: ThreadPoolExecutor.AbortPolicy // ThreadPoolExecutor Executorvice = new ThreadPoolExecutor (CorePoolSize, MaximuMuSize, 1L, timeunit.sonconds, new LinkedBlockingQueue <Runnable> (10)); // 1. Si le thread fonctionnant dans le pool de threads (c'est-à-dire l'appel EMMIRCESTERVICE.EXECUTE) n'atteint pas LinkedBlockingQueue.init (10), le nombre de threads actuellement exécutés est: CorePoolSize (3) // 2. Si le nombre de threads dépassait LinkedBlockingQueue.init (10) et dépassait> = init (10) + corepoolSize (3), et est inférieur à init (10) + maximumpoolSize. Le nombre de threads actuellement démarrés est: (actuels threads-init (10)) // 3. Si le nombre de threads appelés dépasse init (10) + maximumpoolSize Ceci est géré en fonction des règles de rejettedExecutionHandler.
À propos: Explication de plusieurs implémentations par défaut de RejettedExecutionHandler
// Par défaut est utilisé: ThreadPoolExecutor.AbortPolicy. Le gestionnaire est rejeté et lancera un rejette de conduite RejectEdExecutionException. RejectEdExecutionHandler Policy = new ThreadPoolExecutor.AbortPolicy (); //// dans ThreadPoolExecutor.CallerSpolicy, le thread appelle l'exécution elle-même qui exécute la tâche. Cette stratégie fournit un mécanisme de contrôle de rétroaction simple qui peut ralentir la soumission de nouvelles tâches. // Policy = new ThreadPoolExecutor.CallerRunspolicy (); //// dans ThreadPoolExecutor.DiscardPolicy, les tâches qui ne peuvent pas être exécutées seront supprimées. // Policy = new ThreadPoolExecutor.DiscardPolicy (); //// dans ThreadPoolExecutor.DiscardoldestPolicy, si l'exécuteur n'a pas été fermé, la tâche à la tête de la file d'attente de travail sera supprimée et que l'exécution du programme sera réchauffée (répétez ce processus si elle échoue). // Policy = new ThreadPoolExecutor.DiscardolDestPolicy ();
L'introduction ci-dessus aux méthodes d'implémentation et les différences du pool de threads Java est tout le contenu que j'ai partagé avec vous. J'espère que vous pourrez vous faire référence et j'espère que vous pourrez soutenir Wulin.com plus.