multithreading java tutorial with examples
Dieses Tutorial erklärt alles über Multithreading in Java, Parallelitätsimplementierung, den Lebenszyklus eines Threads, Beispiel für eine Thread-Klasse, Thread mithilfe der ausführbaren Schnittstelle:
Die Parallelität in der Computerwelt ist die Fähigkeit eines Systems (sei es eine Anwendung, ein Computer oder eine Programmiersprache), mehrere Instanzen eines Programms oder einer Anwendung parallel auszuführen.
Durch gleichzeitiges Ausführen von Instanzen oder Programmen stellen wir einen hohen Durchsatz und eine höhere Leistung sicher, da wir die ungenutzten Ressourcen wie Betriebssystemhardware usw. nutzen können. Beispielsweise, Wenn ein System über mehrere CPUs verfügt, kann die Anwendung diese CPUs effektiv nutzen und den Durchsatz erhöhen.
=> Besuchen Sie hier für die exklusive Java Training Tutorial-Reihe.
Was du lernen wirst:
- Was ist Multithreading in Java?
- Was ist ein Thread in Java?
- Fazit
Was ist Multithreading in Java?
In Java können Threads als Rückgrat der Parallelität angesehen werden. Ein Thread ist eine ausführbare, leichtgewichtige Einheit, die auf gemeinsam genutzte Ressourcen sowie auf ihren eigenen Aufrufstapel zugreift.
Eine Java-Anwendung ist ein Prozess, und innerhalb dieser Anwendung können mehrere Threads vorhanden sein, um die Parallelität zu erreichen.
Wir wissen, dass eine auf dem System ausgeführte Anwendung mehrere Instanzen haben kann. Diese werden normalerweise als Multi-Doc-Anwendungen bezeichnet. Diese Anwendungsinstanzen werden als Prozesse bezeichnet. Jedem dieser Prozesse ist eine Ausführungseinheit zugeordnet, die als Thread bezeichnet wird.
Abhängig vom Betriebssystem und den Anwendungsanforderungen kann dem Prozess entweder ein einzelner Thread oder mehrere Threads zugewiesen werden. Wenn dem Anwendungsprozess mehrere Threads zugewiesen sind, müssen diese mehreren Threads gleichzeitig ausgeführt werden.
'' Diese Technik zum gleichzeitigen oder gleichzeitigen Ausführen oder Ausführen mehrerer Threads wird als Multithreading bezeichnet . '
Multithreading bedeutet einfach, dass mehr als ein Thread in derselben Anwendung ausgeführt wird.
Die Programmiersprache Java bietet integrierte Unterstützung für Multithreading.
Multithreading ist im obigen Diagramm dargestellt. Wie gezeigt, gibt es mehrere Threads, die gleichzeitig in einer Anwendung ausgeführt werden.
Beispielsweise, Eine Desktop-Anwendung mit Funktionen wie Bearbeiten, Drucken usw. ist eine Multithread-Anwendung. Da das Drucken in dieser Anwendung ein Hintergrundprozess ist, können wir Dokumente gleichzeitig bearbeiten und drucken, indem wir diese Funktionen zwei verschiedenen Threads zuweisen.
Die Threads in Multithread-Anwendungen werden gleichzeitig parallel ausgeführt. Multithreading ist daher auch Teil der Parallelität in Java. Beachten Sie, dass es zwar mehrere Threads gibt, diese sich jedoch den Speicherbereich teilen, wodurch Speicherplatz gespart wird. Außerdem können Threads in kürzester Zeit problemlos den Kontext wechseln.
Multithreading ist hauptsächlich nützlich, da es die gleichzeitige Ausführung von zwei oder mehr Teilen einer Anwendung ermöglicht. Auf diese Weise kann die Anwendung die CPU-Zeit maximal nutzen und die Leerlaufzeit auf ein Minimum beschränken.
Im Folgenden sind einige der Begriffe aufgeführt, die wir in Bezug auf die Multithreading-Umgebung kennen sollten, da sie häufig verwendet werden.
Multitasking: Beim Multitasking wird mehr als eine Aufgabe gleichzeitig ausgeführt.
Multithreading: Multithreading ist, wie bereits erwähnt, ein Prozess, bei dem mehrere Threads gleichzeitig ausgeführt werden.
der beste MP3-Musik-Downloader für Android
Multiprocessing: Bei der Mehrfachverarbeitung wird mehr als ein Prozess gleichzeitig ausgeführt. Ähnlich wie beim Multitasking, aber hier ist mehr als eine CPU beteiligt.
Parallelverarbeitung: Die parallele Verarbeitung ist eine Technik, bei der mehrere CPUs gleichzeitig in einem Computersystem arbeiten.
Nachdem wir über Multithreading gesprochen haben, stellt sich die Frage, warum wir überhaupt Multithreading brauchen.
Vorteile von Multithreading
Multithreading bietet verschiedene Vorteile, die eine effiziente Programmierung unterstützen.
Die folgenden Punkte werden es klar machen.
# 1) Effiziente Nutzung von Einzel-CPU-Systemen
Wenn sich nur eine CPU im System mit einem einzelnen Thread befindet, wird die CPU-Zeit verschwendet. Wenn der Thread andere Ressourcen wie E / A verwendet, ist die CPU inaktiv. Wir können dies verbessern und die CPU besser nutzen, indem wir Multithread-Anwendungen haben.
Wenn bei Verwendung von Multithreading ein Thread mit CPU ausgeführt wird, kann der andere Thread ihn verwenden. Bei mehreren Threads wird die CPU-Leerlaufzeit erheblich reduziert.
# 2) Effiziente Nutzung mehrerer CPU-Systeme
Genau wie einzelne CPUs können Multithread-Anwendungen auch bei Systemen mit mehreren CPUs mehrere CPUs effizient nutzen.
# 3) Verbesserte Benutzererfahrung in Bezug auf Reaktionsfähigkeit und Fairness
Die Reaktionsfähigkeit des Systems verbessert sich mit Multithread-Anwendungen. Wir erleben das nicht 'GUI hängen' Wenn mehrere Threads verschiedene Aufgaben in der Anwendung ausführen und die Benutzer nicht lange warten müssen, um eine Antwort auf ihre Anforderungen zu erhalten.
In ähnlicher Weise sind die Benutzer ordnungsgemäße Dienste in Multithread-Systemen.
So implementieren Sie Parallelität in Java
Die erste Klasse, mit der wir Parallelität in Java implementieren können, ist java.lang.Thread Klasse. Diese Thread-Klasse bildet die Grundlage für die Parallelität in Java.
Wir haben auch java.lang.Runnable Schnittstelle, die von einer Java-Klasse implementiert werden kann, um das Thread-Verhalten zu abstrahieren. Für die fortgeschrittene Anwendungsentwicklung können wir das nutzen java.util.concurrent Paket verfügbar seit Java 1.5.
In Zukunft werden wir die Parallelität in Java ausführlich diskutieren. Lassen Sie uns in diesem Tutorial das Konzept der Threads in Java diskutieren und verstehen. In unseren nachfolgenden Tutorials zum Thema Multithreading werden wir verschiedene Multithreading- und Parallelitätskonzepte untersuchen.
Was ist ein Thread in Java?
Ein einzelner Thread kann als kleinste und leichteste Verarbeitungseinheit definiert werden. In Java werden Threads in Programmen verwendet, die die Klasse 'Thread' verwenden.
Es gibt zwei Arten von Java-Threads:
# 1) Benutzer-Thread: Der Benutzerthread wird beim ersten Start der Anwendung erstellt. Dann können wir so viele Benutzer- und Daemon-Threads erstellen.
# 2) Daemon-Thread: Daemon-Threads werden hauptsächlich im Hintergrund verwendet und für Aufgaben wie das Bereinigen der Anwendung usw. verwendet.
Threads reduzieren die Wartungskosten der Anwendung. Es reduziert auch den Anwendungsaufwand.
Ein Beispiel für einen einzelnen Thread ist unten dargestellt:
public class Main{ public static void main (String () args){ System.out.println('This is a thread'); } } Das obige Programm zeigt 'Dies ist ein Thread' an, da beim Starten der Anwendung ein Benutzer-Thread erstellt wird. Im obigen Programm ist die Hauptfunktion der Startpunkt der Anwendung und erstellt einen Benutzer-Thread.
Der Lebenszyklus eines Threads
Das folgende Diagramm zeigt den Lebenszyklus eines Threads in Java.
Wie im obigen Diagramm gezeigt, hat ein Thread in Java die folgenden Zustände:
# 1) Neu: Anfänglich hat der gerade aus der Thread-Klasse erstellte Thread den Status 'Neu'. Es muss noch begonnen werden. Dieser Thread wird auch aufgerufen 'Geborener Faden' .
# 2) Runnable: In diesem Zustand wird die Instanz eines Threads mit der Methode aufgerufen 'Start' .
# 3) Laufen: Die Startmethode der Thread-Instanz wird aufgerufen und der Thread beginnt mit der Ausführung. Dies ist der Betriebszustand. Meistens plant und verwaltet der Scheduler die Threads.
# 4) Blockiert: Eine Anwendung enthält mehrere Threads. Diese Threads müssen auf einen anderen warten, da ihre Ausführung synchronisiert werden muss.
# 5) Beendet: Sobald der Ausführungsprozess des Threads beendet ist, wird der Thread beendet oder seine Ausführung gestoppt.
Also wird zuerst ein Thread erstellt, dann geplant und später führt der Scheduler den Thread aus. Während der laufende Thread möglicherweise für eine andere Aktivität blockiert oder angehalten wird. Dann wird es fortgesetzt und während die Verarbeitung abgeschlossen ist, wird der Thread ausgeführt.
Thread-Prioritäten
Eine Thread-Priorität entscheidet, wie ein Thread in Bezug auf die anderen Threads in einer Anwendung behandelt werden soll. Eine Thread-Priorität ist eine Ganzzahl.
Nachfolgend sind einige Punkte aufgeführt, an die Sie sich bei den Thread-Prioritäten erinnern sollten:
- Thread-Prioritäten sind Ganzzahlen.
- Mit der Thread-Priorität können wir entscheiden, wann wir von einem Thread im laufenden Zustand zu einem anderen wechseln sollen. Dies ist der Kontextwechselprozess, bei dem wir den Kontext der Threads wechseln.
- Jederzeit kann ein Thread freiwillig seine Kontrolle über die CPU freigeben. Dann kann der Thread mit der höchsten Priorität übernehmen.
- In ähnlicher Weise kann ein Thread mit höherer Priorität jeden anderen Thread mit niedrigerer Priorität verhindern.
- Die Thread-Klasse bietet eine setPriority () -Methode, mit der die Priorität für den Thread festgelegt wird.
- Wir können auch Konstanten MIN_PRIORITY, MAX_PRIORITY oder NORM_PRIORITY anstelle von Ganzzahlen verwenden.
Erstellen Sie einen Thread
Wir können einen Thread auf eine der folgenden Arten erstellen:
- Erweiterung der Java-Klasse 'Thread'.
- Implementierung von 'Runnable'.
Erweitern der Java-Thread-Klasse
Die Klasse 'Thread' enthält die Konstruktoren und Methoden, mit denen wir Operationen an einem Thread-Objekt erstellen und ausführen können. Intern implementiert die Thread-Klasse die Runnable-Schnittstelle und erweitert auch die Object-Klasse.
Die folgende Tabelle enthält eine Zusammenfassung verschiedener Konstruktoren und Methoden einer Thread () -Klasse.
| Erbauer / | Prototyp | Beschreibung |
|---|---|---|
| Schlaf | öffentlicher Leerschlaf (lange Millisekunden) | Die Ausführung des aktuellen Threads wird für bestimmte Millisekunden angehalten. |
| Thread () -Konstruktor | Faden() | Standardkonstruktor zum Erstellen eines Thread-Objekts. |
| Thread (Stringname) | Konstruktor zum Erstellen eines Thread-Objekts mit dem angegebenen Namen. | |
| Thread (Runnable r) | Erstellen Sie eine Thread-Instanz mit dem angegebenen Runnable-Schnittstellenobjekt. | |
| Thread (Runnable r, String name) | Erstellen Sie eine Thread-Instanz mit dem angegebenen Runnable-Schnittstellenobjekt und dem angegebenen Namen | |
| Lauf | public void run () | Die Methode run führt die Aktion für einen Thread aus. Ruft den Thread auf. |
| Start | public void start () | Wird verwendet, um die Ausführung des Threads zu starten. Intern ruft die JVM die run () -Methode für diesen Thread auf. |
| beitreten | public void join () | Warten Sie, bis der Faden stirbt |
| public void join (lange Millisekunden) | Warten Sie die angegebenen Millisekunden, bis der Thread abgestorben ist. | |
| getPriority | public int getPriority () | Geben Sie die Thread-Priorität zurück |
| Priorität setzen | public int setPriority (int priority) | Ändern Sie die Thread-Priorität in die angegebene Priorität |
| getName | public String getName () | Geben Sie den Namen des Threads zurück. |
| Name einsetzen | public void setName (String name) | Setzen Sie den Namen des Threads auf die angegebene Zeichenfolge |
| currentThread | öffentlicher Thread currentThread () | Gibt die Referenz des aktuell aktiven Threads zurück |
| getId | public int getId () | Thread-ID zurückgeben |
| getState () | public Thread.State getState () | Gibt den aktuellen Status des Threads zurück |
| ist am Leben | public boolean isAlive () | Überprüfen Sie, ob der Thread aktiv ist, und geben Sie true zurück, wenn ja. |
| Ausbeute | öffentlicher nichtiger Ertrag () | Hält den aktuellen Thread vorübergehend an und ermöglicht die Ausführung anderer Threads. |
| isDaemon | public boolean isDaemon () | Überprüfen Sie, ob der Thread ein Daemon-Thread ist. Geben Sie true zurück, wenn ja. |
| setDaemon | public void setDaemon (boolean b) | Legen Sie den Thread als Daemon-Thread fest, wenn b = true; sonst als Benutzer-Thread festgelegt. |
| unterbrechen | public void Interrupt () | Unterbrechen Sie den aktuellen Thread. |
| ist unterbrochen | public boolean isInterrupted () | Überprüfen Sie, ob der Thread unterbrochen ist. |
| unterbrochen | öffentlicher statischer Boolescher Wert unterbrochen () | Überprüfen Sie, ob der aktuelle Thread unterbrochen wurde. |
| dumpStack | Static void dumpStack () | Druckt eine Stapelverfolgung des aktuellen Threads in den Standardfehlerstrom. |
| aussetzen | public void suspend () | Hält alle Threads an. (** Methode ist in den neuesten Java-Versionen veraltet) |
| weitermachen | öffentlicher nichtiger Lebenslauf () | Setzen Sie den aufgehängten Faden fort. (** Methode ist in den neuesten Java-Versionen veraltet) |
| Stop | public void stop () | Stoppt den Thread. (** Methode ist in den neuesten Java-Versionen veraltet) |
Wir werden diese Thread-Methoden in unserem nächsten Tutorial zum Thema Multithreading näher erläutern.
Einen Thread starten
Die Methode start (), mit der der Thread gestartet wird, führt die folgenden Schritte aus:
- Startet eine neue Thread-Instanz mit einem neuen CallStack.
- Der Thread-Status wird von neu in lauffähig geändert.
- Wenn der Thread an der Reihe ist, führt er die run () -Methode aus.
Implementierung der 'Runnable' -Schnittstelle
Eine Thread-Instanz kann auch über die Runnable-Schnittstelle erstellt werden. Um eine Thread-Instanz zu erstellen, sollte die Klasse, deren Objekte von einem Thread ausgeführt werden sollen, die Runnable-Schnittstelle implementieren.
Die Runnable-Schnittstelle hat nur eine Methode:
public void run () => this method is used to execute the thread. Beispiel für eine Thread-Klasse
Lassen Sie uns nun den Thread in Java mithilfe der Thread-Klasse demonstrieren.
//class inherited from 'Thread' class ThreadClassDemo extends Thread { private int number; //class constructor public ThreadClassDemo(int number) { this.number = number; } //run method => execution code for thread public void run() { int counter = 0; int numInt = 0; //prints the number till specified number is reached, starting from 10 do { numInt = (int) (counter + 10); System.out.println(this.getName() + ' prints ' + numInt); counter++; } while(numInt != number); System.out.println('** Correct! ' + this.getName() + 'printed ' + counter + ' times.**'); } } public class Main { public static void main(String () args) { System.out.println('Starting thread_1...'); //create a thread class instance Thread thread_1 = new ThreadClassDemo(15); //start the thread thread_1 thread_1.start(); try { //wait for thread_1 to die thread_1.join(); } catch (InterruptedException e) { System.out.println('Thread interrupted.'); } System.out.println('Starting thread_2...'); Thread thread_2 = new ThreadClassDemo(20); //start thread_2 thread_2.start(); System.out.println('main() is ending...'); } } Ausgabe
Java-Thread mit ausführbarer Schnittstelle
Das folgende Beispiel zeigt die Verwendung der Runnable-Schnittstelle zum Erstellen einer Thread-Instanz.
//class implements Runnable interface class RunnableDemo implements Runnable { private String message; //class constructor public RunnableDemo(String message) { this.message = message; } //run method public void run() { while(true) { System.out.println(message); } } } public class Main { public static void main(String () args) { //create first thread instance hello Runnable hello = new RunnableDemo('Hello, Greetings!!!'); Thread thread1 = new Thread(hello); thread1.setDaemon(true); //set this thread as daemon thread1.setName('hello'); System.out.println('Starting First thread...'); //start the thread thread1.start(); //create second thread instance bye Runnable bye = new RunnableDemo('Bye for now!!'); Thread thread2 = new Thread(bye); thread2.setPriority(Thread.MIN_PRIORITY); //set priority to min thread2.setDaemon(true); //set as daemon thread System.out.println('Starting goodbye thread...'); //start the thread thread2.start(); System.out.println('main() is ending...'); } }Ausgabe
So stoppen Sie einen Thread in Java
Wir haben die Thread-Beispiele oben gesehen. Aus diesen Beispielen wissen wir, dass der Thread nach Abschluss der Ausführung der Ausführungsmethode oder aufgrund einiger Ausnahmen auch stoppt.
Frühere Versionen von Java hatten eine stop () -Methode in der Thread-Klasse, mit der der Thread direkt gestoppt werden konnte. Aber es wurde jetzt aus Sicherheitsgründen veraltet. Daher müssen wir die anderen Methoden verwenden, um den ausgeführten Thread zu stoppen.
Es gibt zwei Methoden, mit denen wir den Thread stoppen können.
- Verwenden einer flüchtigen booleschen Variablen
- Interrupts verwenden.
In diesem Abschnitt werden diese beiden Methoden zum Stoppen eines Threads erläutert.
in scrum, der dafür verantwortlich ist, dass komplexe Anforderungen nicht rechtzeitig erfüllt werden
Verwenden einer flüchtigen booleschen Variablen
Bei dieser Methode pflegen wir eine boolesche Variable say flag, um den Thread zu stoppen. Der Thread wird ausgeführt, solange die boolesche Variable auf true gesetzt ist. In dem Moment, in dem es falsch wird, wird der Thread gestoppt.
Das Besondere an dieser Methode ist, dass wir die boolesche Variable als „ flüchtig ”, Damit es immer aus dem Hauptspeicher gelesen wird und das Programm es nicht im CPU-Cache zwischenspeichern kann. Auf diese Weise gibt es keinen Unterschied zwischen den eingestellten und gelesenen Werten.
Die Implementierung des Stoppens eines Threads mithilfe einer flüchtigen booleschen Variablen ist unten dargestellt.
class StopThread extends Thread { private volatile boolean stop_flag = true; //initially set to true public void stopRunning() { stop_flag = false; //set stop_flag to false } @Override public void run() { while (stop_flag) { //keep checking value of stop_flag System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } //call stopRunning() method to stop the thread stop_thread.stopRunning(); } } Ausgabe
Hinweis: Hier haben wir nur einen Teil der Ausgabe gezeigt. Der Thread läuft möglicherweise einige Minuten, bevor er gestoppt wird. Damit können wir auf verschiedenen Systemen unterschiedliche Ergebnisse erzielen.
Interrupts verwenden
Hier wird der Thread mit der Interrupt () -Methode gestoppt, wie wir oben bereits in den Threadklassenmethoden erläutert haben. Die Interrupt () -Methode setzt den Status des Threads als unterbrochen. Dieser Status wird an die while-Schleife der run () -Methode übergeben. Wir können den unterbrochenen Status mit der unterbrochenen () Methode erhalten.
Das folgende Programm demonstriert die Verwendung der Interrupt () -Methode zum Stoppen des Threads.
class StopThread extends Thread { @Override public void run() { while (!Thread.interrupted()) { //check for interrupted status System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //interrupt the thread stop_thread.interrupt(); } } Ausgabe
Häufig gestellte Fragen
F # 1) Warum verwenden wir Multithreading in Java?
Antworten: Multithreading ermöglicht die gleichzeitige oder gleichzeitige Ausführung von zwei oder mehr Threads in einer Anwendung. Die gleichzeitige Ausführung maximiert den Durchsatz und nutzt die CPU maximal aus.
F # 2) Was ist Multithreading? Was sind ihre Typen?
Antworten: Multithreading bedeutet, dass mehr als ein Thread ausgeführt wird. Diese Ausführung kann gleichzeitig oder parallel erfolgen. Somit hat Multithreading zwei Typen, d. H. Gleichzeitig oder parallel.
F # 3) Was ist Multithreading im Vergleich zu Multiprocessing?
Antworten: Beim Multithreading gibt es mehrere Threads für denselben oder unterschiedliche Prozesse, und diese Threads werden gleichzeitig ausgeführt, um die Rechengeschwindigkeit eines Systems zu verbessern. Bei der Mehrfachverarbeitung hat ein System mehr als zwei CPUs und mehrere Prozesse werden gleichzeitig ausgeführt.
F # 4) Was sind die Vorteile von Multithreading in Java?
Antworten: Mit Multithreading können wir verschiedene Teile einer Anwendung gleichzeitig mithilfe von Threads ausführen. Multithreading erhöht den Systemdurchsatz. Multithreading maximiert auch die CPU-Auslastung, da verschiedene Threads die CPU kontinuierlich nutzen.
F # 5) Ist Multithreading gut für Spiele?
Antworten: Ja, besonders für moderne Spiele.
Fazit
Hier geht es um die Einführung von Multithreading. In diesem Tutorial haben wir die Parallelität und das Multithreading in Java erläutert. Wir haben die Erstellung eines Threads mit der Thread-Klasse sowie der Runnable-Schnittstelle erörtert und entsprechende Beispiele bereitgestellt.
Wir haben auch die Konzepte eines einzelnen Threads und seine Erstellung im Detail gelernt. Die Thread-Konzepte, einschließlich des Lebenszyklus eines Threads, Stoppen eines Threads, Thread-Typen usw., wurden in diesem Lernprogramm erläutert.
Wir haben auch ausführlich über Multithreading und Parallelität in Java gesprochen. Am Ende dieses Tutorials sollte der Leser in der Lage sein, die Konzepte von Parallelität und Multithreading sowie Threads in Java leicht zu verstehen.
=> Sehen Sie sich hier die einfache Java-Schulungsreihe an.
Literatur-Empfehlungen
- Multithreading in C ++ mit Beispielen
- Java-Threads mit Methoden und Lebenszyklus
- Thread.Sleep () - Thread Sleep () -Methode in Java mit Beispielen
- JAVA-Tutorial für Anfänger: Über 100 praktische Java-Video-Tutorials
- Java Reflection Tutorial mit Beispielen
- Java String enthält () Method Tutorial mit Beispielen
- Jagged Array In Java - Tutorial mit Beispielen
- Java Scanner Class Tutorial mit Beispielen