Die Programmiersprache Java arbeitet sehr effizient mit Anwendungen, bei denen die Aufgaben gleichzeitig in einem Thread ausgeführt werden müssen. Es wird für jede Anwendung schwierig, eine große Anzahl von Threads gleichzeitig auszuführen. Um dieses Problem zu lösen, kommt mit ExecutorService, einer Subschnittstelle der . In diesem Artikel werden wir die Funktionalität von ExecutorService in Java diskutieren. Im Folgenden sind die Themen aufgeführt, die in diesem Blog behandelt werden:
- Was ist Executor Framework?
- ExecutorService in Java Beispiel
- Java ExecutorService-Implementierungen
- ExecutorService-Nutzung
- Runnable vs Callable
- ExecutorService herunterfahren
Was ist Executor Framework?
Es ist ziemlich einfacher, ein oder zwei Threads gleichzeitig zu erstellen und auszuführen. Es wird jedoch schwierig, wenn die Anzahl der Threads auf eine signifikante Anzahl ansteigt. Bei großen Multithread-Anwendungen werden Hunderte von Threads gleichzeitig ausgeführt. Daher ist es absolut sinnvoll, die Thread-Erstellung von der Thread-Verwaltung in einer Anwendung zu trennen.
Der Testamentsvollstrecker ist a hilft Ihnen beim Erstellen und Verwalten von Threads in einer Anwendung. Das hilft Ihnen bei den folgenden Aufgaben.
Thread-Erstellung: Es bietet eine Vielzahl von Methoden zum Erstellen von Threads, mit denen Sie Ihre Anwendungen gleichzeitig ausführen können.
Thread-Verwaltung: Verwaltet auch den Thread-Lebenszyklus. Sie müssen sich keine Sorgen machen, ob der Thread aktiv, beschäftigt oder tot ist, bevor Sie die Aufgabe zur Ausführung senden.
Übermittlung und Ausführung von Aufgaben: Das Executor-Framework bietet Methoden für die Übermittlung von Aufgaben im Thread-Pool. Außerdem können Sie entscheiden, ob der Thread ausgeführt wird oder nicht.
ExecutorService in Java Beispiel
Es ist eine Unterschnittstelle des Executor-Frameworks, die bestimmte Funktionen zum Verwalten des Thread-Lebenszyklus einer Anwendung hinzufügt. Es bietet auch eine submit () -Methode, die sowohl ausführbare als auch aufrufbare Methoden akzeptieren kann Objekte.
Im folgenden Beispiel erstellen wir einen ExecutorService mit einem einzelnen Thread und senden dann die auszuführende Aufgabe innerhalb des Threads.
import java.util.concurrent.ExecutorService import java.util.concurrent.Executors öffentliche Klasse Beispiel {public static void main (String [] args) {System.out.println ('Inside:' + Thread.currentThread (). getName ( )) System.out.println ('ExecutorService erstellen') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('Runnable erstellen') Runnable runnable = () -> {System.out.println ('inside: '+ Thread.currentThread (). GetName ())} System.out.println (' Senden Sie die von der ausführbaren Datei angegebene Aufgabe an den ausführenden Dienst ') executorservice.submit (ausführbare Datei)}}Ausgabe: Inside: main create ExecutorService beim Erstellen einer ausführbaren Datei Senden Sie die von der ausführbaren Datei angegebene Aufgabe an den ausführenden Dienst in: pool-1-thread-1
Obenstehendes zeigt, wie wir einen ExecutorService erstellen und eine Aufgabe im Executor ausführen können. Wenn eine Aufgabe zur Ausführung gesendet wird und der Thread gerade eine andere Aufgabe ausführt, wartet die Aufgabe in einer Warteschlange, bis der Thread frei ist, sie auszuführen.
Wenn Sie das obige Programm ausführen, wird das Programm niemals beendet. Sie müssen es explizit herunterfahren, da der Executor-Dienst ständig auf neue Aufgaben wartet.
Java ExecutorService-Implementierungen
ExecutorService ist einem Thread-Pool sehr ähnlich. In der Tat die Implementierung des ExecutorService in der java.util.concurrent Paket ist eine Threadpool-Implementierung. Der ExecutorService verfügt über die folgenden Implementierungen im Paket java.util.concurrent:
ThreadPoolExecutor
Der ThreadPoolExecutor führt die angegebenen Aufgaben mithilfe eines seiner intern zusammengefassten Threads aus.
Erstellen eines threadPoolExecutor
int corePoolSize = 5 int maxPoolSize = 10 long keepAliveTime = 5000 ExecutorService threadPoolExecutor = neuer threadPoolExecutor (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, new LinkedBlockingQueue ())
ScheduledThreadPoolExecutor
Der java.util.concurrent.ScheduledThreadPoolExecutor ist ein ExecutorService, der festlegen kann, dass Aufgaben nach einer Verzögerung ausgeführt oder wiederholt mit einem festgelegten Zeitintervall zwischen den einzelnen Ausführungen ausgeführt werden.
Beispiel
ScheduledExecutorService scheduledexecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture ScheduledFuture = ScheduledExecutorService.schedule (new Callable () {public Object call () löst eine Ausnahme aus {System.out.println ('ausgeführt') return 'aufgerufen'}}, 5, TimeUnit. SEKUNDEN)ExecutorService-Nutzung
Es gibt verschiedene Möglichkeiten, Aufgaben an einen ExecutorService zu delegieren.
ausführen (ausführbar)
submit (Runnable)
invokeAny ()
invokeAll ()
Führen Sie Runnable aus
Java ExecutorService execute (Runnable) nimmt ein java.lang.Runnable-Objekt und führt es asynchron aus.
ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execute (new Runnable () {public void run () {System.out.println ('asynchrone Aufgabe')}}) executorService.shutdown ()Es gibt keine Möglichkeit, das Ergebnis der Ausführung von Runnable abzurufen. Dazu müssen Sie Callable verwenden.
Senden Sie Runnable
Die Java ExecutorService-Submit-Methode (Runnable) verwendet eine Runnable-Implementierung und gibt ein zukünftiges Objekt zurück. Mit dem zukünftigen Objekt kann überprüft werden, ob die Ausführung des Runnable abgeschlossen ist.
Future future = executorService.submit (new Runnable () {public void run () {System.out.println (: asynchrone Aufgabe ')}}) future.get () // gibt null zurück, wenn die Aufgabe korrekt abgeschlossen wurde.Senden Callable
Die Java ExecutorService-Submit-Methode (Callable) ähnelt der Submit-Methode (Runnable), verwendet jedoch Java Callable anstelle von Runnable.
Future future = executorService.submit (new Callable () {public Object call () löst eine Ausnahme aus {System.out.println ('Asynchronous callable') gibt 'Callable Result' zurück}}) System.out.println ('future.get ( ) = 'future.get ())Ausgabe: Asynchroous callable future.get = Callable Result
invokeAny ()
Die invokeAny () -Methode verwendet eine Sammlung von Callable-Objekten. Das Aufrufen dieser Methode gibt keine Zukunft zurück, sondern das Ergebnis eines der aufrufbaren Objekte.
ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = neues HashSet () callables.add (new Callable () {public String call () löst eine Ausnahme aus {return'task A '}}) callables.add (new Callable () {public String call () löst eine Ausnahme aus {return'task B'} }) callables.add (new Callable () {public String call () löst eine Ausnahme aus {return'task C '}}) String result = executorService.invokeAny (callables) System.out.println (' result = '+ result) executorService .schließen()
Wenn Sie den obigen Code ausführen, ändert sich das Ergebnis. Dies kann Aufgabe A, Aufgabe B usw. sein.
InvokeAll ()
Die Methode invokeAll () ruft alle als Parameter übergebenen aufrufbaren Objekte auf. Es gibt die zukünftigen Objekte zurück, mit denen die Ergebnisse der Ausführung jedes Callable abgerufen werden können.
ExecutorService executorService = Executors.newSingleThreadExecutor () Setcallables = neues HashSet () callables.add (new Callable () {public String call () löst eine Ausnahme aus {return 'Task A'}}) callables.add (new Callable () {public String call () löst eine Ausnahme aus {return 'Task B'} }) callables.add (new Callable () {public String call () löst eine Ausnahme aus {return 'Task C'}}) List futures = executorService.invokeAll (callables) für (Future future: futures) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()
Runnable vs Callable
Die ausführbaren und aufrufbaren Schnittstellen sind einander sehr ähnlich. Der Unterschied ist in der Erklärung der sichtbar Schnittstellen. Beide Schnittstellen stellen eine Aufgabe dar, die gleichzeitig von einem Thread oder ExecutorService ausgeführt werden kann.
Abrufbare Erklärung:
öffentliche Schnittstelle Callable {public object call () löst eine Ausnahme aus}Ausführbare Erklärung:
öffentliche Schnittstelle Runnable {public void run ()}Der Hauptunterschied zwischen beiden besteht darin, dass die Methode call () ein Objekt aus dem Methodenaufruf zurückgeben kann. Und die Methode call () kann eine auslösen while run () Methode kann nicht.
So legen Sie den Klassenpfad in Java über die Eingabeaufforderung fest
Aufgabe abbrechen
Sie können die an ExecutorService übermittelte Aufgabe abbrechen, indem Sie einfach die Abbruchmethode für die zukünftige Übermittlung aufrufen, wenn die Aufgabe übermittelt wird.
future.cancel ()
ExecutorService herunterfahren
Damit die Threads auch nach Abschluss der Ausführung nicht ausgeführt werden, sollten Sie den ExecutorService herunterfahren.
schließen()
Um die Threads in einem ExecutorService zu beenden, können Sie die Methode shutdown () aufrufen.
executorService.shutdown ()
Dies bringt uns zum Ende dieses Artikels, wo wir gelernt haben, wie wir ExecutorService verwenden können, um Aufgaben in einem Thread auszuführen. Ich hoffe, Sie sind mit allem klar, was Ihnen in diesem Tutorial mitgeteilt wurde.
Wenn Sie diesen Artikel zu 'ExecutorService in Java' relevant fanden, lesen Sie die Ein vertrauenswürdiges Online-Lernunternehmen mit einem Netzwerk von mehr als 250.000 zufriedenen Lernenden auf der ganzen Welt.
Wir sind hier, um Ihnen bei jedem Schritt auf Ihrer Reise zu helfen und einen Lehrplan zu erstellen, der für Studenten und Fachleute konzipiert ist, die Java-Entwickler werden möchten. Der Kurs soll Ihnen einen Vorsprung in die Java-Programmierung verschaffen und Sie sowohl für Kern- als auch für fortgeschrittene Java-Konzepte sowie für verschiedene Konzepte schulen mögen Überwintern & .
Wenn Sie auf Fragen stoßen, können Sie alle Ihre Fragen im Kommentarbereich von „ExecutorService in Java“ stellen. Unser Team beantwortet diese gerne.