Einführung in mehrere Implementierungsmethoden und Unterschiede des Java -Threadpools
importieren java.text.dateformat; import Java.text.SimpledateFormat; import Java.util.ArrayList; Import Java.util.date; importieren java.util.list; importieren java.util.list; java.util.concurrent.executors; importieren java.util.concurrent Wenn ein neuer Faden festgelegt werden muss, kann er nur in eine andere Warteschlange platziert werden und warten, bis ein Faden in der aktuellen Faden endet und direkt aus dem Pool verschoben wird // - im Gegensatz zu Cachetheadpool wird Fixed threadpool nicht mehr im Leerlaufmechanismus (es kann auch da sein, aber da das Dokument nicht erwähnt wird. FixedThreadpool richtet sich hauptsächlich auf einige sehr stabile und feste regelmäßige gleichzeitige Threads, die hauptsächlich in Servern verwendet werden. alle), 60 Second Idle Private Static Executorservice FixedService = Executors.NewFixed threadpool (6); // -Cache -Pool, prüfen Sie zunächst, ob zuvor festgelegte Threads im Pool vorhanden sind, falls vorhanden, wiederverwenden. Wenn nicht, erstellen Sie einen neuen Thread und fügen Sie ihn zum Pool hinzu // -Cache-Pool wird normalerweise verwendet, um asynchrone Aufgaben mit sehr kurzer Lebensdauer auszuführen. // - Der Thread, der wiederverwenden kann, muss ein Thread im Pool innerhalb des Zeitlimits im Leerlauf sein. Das Standard -Timeout beträgt 60er Jahre. Wenn die Leerlaufzeit die Dauer überschreitet, wird die Thread -Instanz beendet und aus dem Pool entfernt. // Beachten Sie, dass der Thread, der das zwischengespeicherte Threadpool einfügt, sich nicht um sein Ende sorgen muss. Wenn es nach der Zeitüberschreitung inaktiv ist, wird es automatisch beendet. private static Executorservice Cacheservice = Executors.NewCachedThreadpool (); // -Singleton -Thread, kann es in jedem Zeitpool nur einen Thread geben // Der zugrunde liegende Pool entspricht dem Cache -Pool und dem festen Pool, aber die Anzahl der Threads beträgt 1-1,0 Sekunden im Leerlauf (kein müßiges privates statischer Executorservice SingleService = Executor. // -Scheduled Thread Pool // Die Threads in diesem Pool können nach Zeitplan nacheinander verzögert werden, oder der private statische Ausführendeservice geplant. public static void main (String [] args) {DateFormat format = new SimpledateFormat ("yyyy-mm-dd hh: mm: ss"); LIST <NEger> customerList = new ArrayList <Ganzzahl> (); System.out.println (format.format (neues Datum ())); testfixedThreadpool (FixedService, CustomerList); System.out.println ("--------------------------"); testfixedThreadpool (FixedService, CustomerList); fixedService.shutdown (); System.out.println (FixedService.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 ("------------------------------------------------"); testsPeduledServicethreadpool (geplanter Service, CustomerList); testsPeduledServicethreadpool (geplanter Service, CustomerList); geplanter service.shutdown (); } public static void testsPeduledServicethreadpool (ExecutorService -Dienst, Liste <Integer> CustomerList) {list <Callable <Integer >> listCallable = new ArrayList <Callable <Integer >> (); für (int i = 0; i <10; i ++) {Callable <Integer> callable = new Callable <Integer> () {@Override public Integer call () löst eine Ausnahme aus {return New Random (). Nextint (10); }}; listCallable.add (Callable); } try {list <Future <Integer >> listfuture = service.invokeall (listCallable); für (Future <Integer> Future: ListFuture) {Integer id = Future.get (); CustomerList.add (ID); }} catch (Ausnahme e) {e.printstacktrace (); } System.out.println (CustomerList.toString ()); } public static void testsingleServicetHeadpool (ExecutorService -Dienst, Liste <Integer> CustomerList) {Liste <Callable <Liste <Integer >>> listCallable = new ArrayList <Callable <list <list <Integer >>> (); für (int i = 0; i <10; i ++) {callable <list <Integer >>> callable = new Callable <list <Integer >> () {@Override publiclist <Integer> call () löst Ausnahme aus {list <Integer> list = getList (new random (). nextint (10)); boolean isStop = false; while (list.size ()> 0 &&! isStop) {System.out.println (thread.currentThread (). getId () + " - schlaf: 1000"); isStop = true; } Rückgabeliste; }}; listCallable.add (Callable); } try {list <future <list <Integer >>> listfuture = service.invokeall (listCallable); für (Future <list <Integer >> Future: ListFuture) {list <Integer> list = Future.get (); CustomerList.addall (Liste); }} catch (Ausnahme e) {e.printstacktrace (); } System.out.println (CustomerList.toString ()); } public static void testcachTheadpool (ExecutorService -Dienst, Liste <Integer> CustomerList) {list <callable <list <Integer >>> listCallable = new ArrayList <callable <list <liste <Integer >> (); für (int i = 0; i <10; i ++) {callable <list <Integer >> callable = new Callable <Liste <Integer >> () {@Override publiclist <Integer> call () löst Ausnahme aus {list <Integer> list = getList (new random (). nextint (10)); boolean isStop = false; while (list.size ()> 0 &&! isStop) {System.out.println (thread.currentThread (). getId () + " - schlaf: 1000"); isStop = true; } Rückgabeliste; }}; listCallable.add (Callable); } try {list <future <list <Integer >>> listfuture = service.invokeall (listCallable); für (Future <list <Integer >> Future: ListFuture) {list <Integer> list = Future.get (); CustomerList.addall (Liste); }} catch (Ausnahme e) {e.printstacktrace (); } System.out.println (CustomerList.toString ()); } public static void testfixedThreadpool (ExecutorService -Dienst, Liste <Integer> CustomerList) {list <callable <list <Integer >>> listCallable = new ArrayList <Callable <list <list <Integer >>> (); für (int i = 0; i <10; i ++) {callable <list <Integer >> callable = new Callable <Liste <Integer >> () {@Override publiclist <Integer> call () löst Ausnahme aus {list <Integer> list = getList (new random (). nextint (10)); boolean isStop = false; while (list.size ()> 0 &&! isStop) {System.out.println (thread.currentThread (). getId () + " - schlaf: 1000"); isStop = true; } Rückgabeliste; }}; listCallable.add (Callable); } try {list <future <list <Integer >>> listfuture = service.invokeall (listCallable); für (Future <list <Integer >> Future: ListFuture) {list <Integer> list = Future.get (); CustomerList.addall (Liste); }} catch (Ausnahme e) {e.printstacktrace (); } System.out.println (CustomerList.toString ()); } public staticlist <Integer> getList (int x) {list <Integer> list = new ArrayList <Integer> (); list.add (x); list.add (x * x); Rückgabeliste; }}Verwendung: Linked BlockingQueue, um Thread Pool -Erläuterung zu implementieren
//For example: corePoolSize=3,maximumPoolSize=6,LinkedBlockingQueue(10)//RejectedExecutionHandler default processing method is: ThreadPoolExecutor.AbortPolicy//ThreadPoolExecutor executorService = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 1L, TimeUnit.SECONDS, new Linked BlockingQueue <Runnable> (10)); // 1. Wenn der Thread, der im Thread -Pool ausgeführt wird (dh aufgerufen wird, führt ExecutorService.execute) nicht zu linkedBlockingCrocking.init (10), ist die Anzahl der derzeit ausgeführten Threads: corepoolSize (3) // 2. Wenn die Anzahl der Threads Linked BlockingQueue überschritten hat. Die Anzahl der derzeit gestarteten Threads lautet: (aktuelle Threads-Init (10)) // 3. Wenn die Anzahl der genannten Threads init (10)+maximumpoolsize überschreitet, wird dies gemäß den Regeln der AblehnungsexecutionHandler behandelt.
Über: Erläuterung mehrerer Standardimplementierungen von AbleitungenexecutionHandler
// Standard wird verwendet: threadpoolexecutor.abortpolicy. Der Handler wird abgelehnt und wird eine Laufzeit abgelehnt. RejectsExecutionHandler Policy = new threadPoolexecutor.abortPolicy (); //// In ThreadPoolexecutor.Callerrunspolicy ruft der Thread die Ausführung selbst auf, die die Aufgabe ausführt. Diese Strategie bietet einen einfachen Rückkopplungssteuerungsmechanismus, der die Einreichung neuer Aufgaben verlangsamen kann. // Policy = new threadPoolexecutor.callerrunspolicy (); //// In ThreadPoolexecutor.discardpolicy, Aufgaben, die nicht ausgeführt werden können, werden gelöscht. // Policy = new threadPoolexecutor.discardPolicy (); //// In Threadpoolexecutor.DiscardoldestPolicy, wenn der Testamentsvollstrecker nicht geschlossen wurde, wird die Aufgabe an der Spitze der Arbeitswarteschlange gelöscht, und die Ausführung des Programms wird wiederholt (wiederholen Sie diesen Vorgang, wenn er erneut ausfällt). // Policy = new threadPoolexecutor.discardoldestpolicy ();
Die obige Einführung in die Implementierungsmethoden und Unterschiede des Java -Threadpools ist der gesamte Inhalt, den ich mit Ihnen geteilt habe. Ich hoffe, Sie können Ihnen eine Referenz geben und ich hoffe, Sie können wulin.com mehr unterstützen.