Java-Thread-Pool

Ein Thread-Pool ist, wie der Name schon sagt, eine Sammlung von Threads, die wiederverwendet werden können. Diese Threads wurden zuvor erstellt und können auch dazu dienen, Overhead-Lösungen anzubieten, wenn bereits eine Sammlung von Threads verfügbar ist; Diese können wiederverwendet werden und lösen das Problem der Thread-Zyklen und des Wartens darauf, dass Threads ihre Aufgabe abschließen. Da der Thread bei Eingang der Anfrage bereits vorhanden ist, entfällt der Prozess der Thread-Erstellung, wodurch Zeit gespart und die Verarbeitung beschleunigt wird. In diesem Thema lernen wir etwas über Java Thread Pool.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

Funktionsweise des Java-Thread-Pools

Alle Threads in Thread-Pools implementieren die Methoden von java.util.concurrent. Es gibt einen Thread-Pool, der vom Java-Thread-Pool verwaltet wird. Der einfachste Weg, diesen Pool zu sehen, besteht darin, dass je mehr Threads Sie verwenden, desto weniger Zeit benötigt jeder Thread für die eigentliche Arbeit. Dies ist eine Möglichkeit, Ressourcen in einer Anwendung zu sparen, in der Multithreading verwendet werden kann. Es gibt eine Warteschlange, die von diesem Java-Thread für Pools verwaltet wird.

Die Worker-Threads warten ständig darauf, dass Aufgaben zugewiesen und ausgeführt werden. Um einen Thread-Pool zu erstellen, wird ThreadPoolExecutor in Java verwendet. Die Sammlung ausführbarer Threads ist für die Verwaltung der Threads im Java-Thread-Pool verantwortlich. Danach kommen die Arbeitsthreads in Bild- und Formwarteschlangen. Der Thread-Pool überwacht diese Warteschlangen.

Die java.util.concurrent.Executors helfen uns bei den Factory- und Support-Methoden, die für die Verwaltung der Threads erforderlich sind. Diese Klasse ist auch für die Erstellung des Thread-Pools verantwortlich. Ihre nächste Frage könnte nun lauten: Was ist dieser Executor? Executor stellt verschiedene Klassen bereit, die Teil der Utility-Klasse sind.

Die technische Funktionsweise des Thread-Pools kann man sich wie einen Pool vorstellen, in dem Sie Ihren gleichzeitigen Code haben, der in Aufgaben aufgeteilt ist, die parallel ausgeführt werden können. Anschließend werden sie zur Ausführung an den Pool übermittelt. Es gibt Aufgabenübermittler, Executor Services, Aufgabenwarteschlangen und schließlich den Thread-Pool. Das Muster kann Ihnen dabei helfen, die Anzahl der Threads zu steuern, die in der Anwendung vorhanden sind. Es entscheidet über seinen Lebenszyklus, plant die Aufgaben und hält die eingehenden Aufgaben in der Arbeitswarteschlange.

Die Executorshelper-Klasse verfügt über verschiedene Methoden, die über vorkonfigurierte Thread-Pool-Instanzen verfügen. Die Schnittstellen Executor und ExecutorService helfen bei der Arbeit mit verschiedenen Implementierungen im Pool. Der Code muss vor der eigentlichen Implementierung im entkoppelten Format vorliegen. Es gibt eine weitere Schnittstelle, die verwendet wird. Es ist ein ThreadPoolExecutor. Es handelt sich um eine erweiterbare Thread-Pool-Implementierung, bei der viele Parameter angegeben werden können und die zu einer Feinabstimmung führt. Zu den Parametern, die verwendet werden können, gehören die Kernpoolgröße, die maximale Poolgröße und die Keepalive-Zeit. Die Warteschlange kann nur bis zur maximalen Poolgröße wachsen.

Beispiel für einen Java-Thread-Pool

Lassen Sie uns einen Pool erstellen und sehen, wie es funktioniert.

Code:

import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
// The Job class will be executed in this case
class Job implements Runnable
{
private String name;
public Job(String s)
{
name = s;
}
// The task name will be populated first for the ones which were not running already, and the thread will sleep for 2s
//This entire method will be repeated 6 times
public void run()
{
try
{
for (int i = 0; i<=5; i++)
{
if (i==0)
{
Date d = new Date();
System.out.println("We are in "
+ " task name - "+ name);
//prints the task name every time the new task is started
}
else
{
System.out.println("The job "+
name +" is already running ");
// prints the job name which is already running
}
Thread.sleep(2000); // The thread is in sleep mode for 2 secs
}
System.out.println(name+" job is completes");
}
catch(InterruptedException e)
{
e.printStackTrace();
}
}
}
public class Test
{
// Here we define the maximum threads we have
static final int MAX_Threads= 5;
public static void main(String[] args)
{
Runnable run1 = new Job("task 1");
Runnable run2 = new Job("task 2");
Runnable run3 = new Job("task 3");
//A new thread pool is created with maximum number of threads
ExecutorService newpool = Executors.newFixedThreadPool(MAX_Threads);
newpool.execute(run1);
newpool.execute(run2);
newpool.execute(run3);
newpool.shutdown();
}
}

Der obige Code deckt jeden Schritt von der Erstellung des Threads bis zu seiner Schließung ab. Es ist ein maximales Thread-Limit festgelegt und erstellt. Sobald dies erledigt ist, werden drei Jobs erstellt, die nacheinander ausgeführt werden. Für jeden Job ist außerdem eine Ruhezeit von 2 Sekunden vorgesehen. Da der Thread-Pool erstellt wird und alle Jobs gleichzeitig ausgeführt werden, können wir sehen, dass der gesamte Prozess sechsmal ausgeführt wird. Wenn die if-Anweisung im Thread-Pool ausgeführt wird, prüft sie, ob der Job bereits ausgeführt wird oder nicht. Wenn die Ausführung des Jobs noch nicht begonnen hat, führt er den if-Block aus. Wenn er bereits ausgeführt wird, wird der else-Block ausgeführt. Es wird der Jobname angezeigt und es wird angezeigt, dass er bereits ausgeführt wird. Der Thread-Pool wird erstellt und dann werden alle drei Jobs ausgeführt. Sobald die Jobs ausgeführt sind, fahren wir den Thread-Pool herunter, den wir erstellt haben.

Unten finden Sie die Ausgabe des angegebenen Programms.

Ausgabe:

Es läuft, bis alle Aufgaben abgeschlossen sind.

Vor- und Nachteile von Thread-Pools

Wir haben mehrere Vorteile von Thread Pool in Java. Um nur einige zu nennen, sind im Folgenden die Hauptvorteile aufgeführt:

• Dies führt zu einer besseren und effizienteren Leistung der CPU und des Programms.
• Da alle Prozesse von verschiedenen Threads bearbeitet werden, spart das Zeit.
• Der Hauptvorteil des Thread-Pools ist die Wiederverwendung bereits vorhandener Threads. Es besteht keine Notwendigkeit, immer wieder neue Threads zu erstellen.
• Es bietet Echtzeitzugriff, was die Arbeit mit Echtzeitdaten erleichtert.

Wir haben jedoch auch einige Nachteile des Thread-Pools. Nachfolgend sind die Nachteile aufgeführt:

• Sie können die Priorität von Aufgaben nicht festlegen und diese können auch nicht verfolgt werden.
• Bei häufigerer Nutzung können diese automatisch gelöscht werden.

Fazit

Daher sind Thread-Pools eine effiziente Möglichkeit, die vielfältigen Aufgaben, die uns bevorstehen, zu bewältigen. Java bietet uns die Möglichkeit, die Threads wiederzuverwenden und die vorhandenen Ressourcen zu nutzen.

Das obige ist der detaillierte Inhalt vonJava-Thread-Pool. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!