Multithreading in Java Tutorial mit Programm &Beispielen

Thread-Lebenszyklus in Java

Es gibt verschiedene Stadien des Lebenszyklus von Garnen, wie im obigen Diagramm dargestellt:

1. Neu
2. Ausführbar
3. Laufen
4. Warten
5. Tot

1. Neu: In dieser Phase wird der Thread mit der Klasse „Thread-Klasse“ erstellt. Er bleibt in diesem Zustand, bis das Programm startet der Faden. Es wird auch als geborener Faden bezeichnet.
2. Ausführbar: Auf dieser Seite wird die Instanz des Threads mit einer Startmethode aufgerufen. Die Thread-Steuerung wird an den Scheduler übergeben, um die Ausführung zu beenden. Es hängt vom Scheduler ab, ob der Thread ausgeführt wird.
3. Läuft: Wenn der Thread mit der Ausführung beginnt, wird der Status in den Status „Running“ geändert. Der Planer wählt einen Thread aus dem Thread-Pool aus und beginnt mit der Ausführung in der Anwendung.
4. Warten: Dies ist der Zustand, in dem ein Thread warten muss. Da in der Anwendung mehrere Threads ausgeführt werden, ist eine Synchronisierung zwischen den Threads erforderlich. Daher muss ein Thread warten, bis der andere Thread ausgeführt wird. Daher wird dieser Zustand als Wartezustand bezeichnet.
5. Tot: Dies ist der Zustand, wenn der Thread beendet wird. Der Thread befindet sich im laufenden Zustand und sobald er die Verarbeitung abgeschlossen hat, befindet er sich im „toten Zustand“.

Einige der am häufigsten verwendeten Methoden für Threads sind:

Beispiel: In diesem Beispiel für ein Multithreading-Programm in Java werden wir einen Thread erstellen und integrierte Methoden untersuchen, die für Threads verfügbar sind.

package demotest;
public class thread_example1 implements Runnable {
    @Override
    public void run() {
    }
    public static void main(String[] args) {
        Thread guruthread1 = new Thread();
        guruthread1.start();
        try {
            guruthread1.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        guruthread1.setPriority(1);
        int gurupriority = guruthread1.getPriority();
        System.out.println(gurupriority);
        System.out.println("Thread Running");
  }
}

Erklärung des Codes:

• Codezeile 2: Wir erstellen eine Klasse „thread_Example1“, die das Runnable-Interface implementiert (es sollte von jeder Klasse implementiert werden, deren Instanzen vom Thread ausgeführt werden sollen.)
• Codezeile 4: Es überschreibt die run-Methode der ausführbaren Schnittstelle, da es zwingend erforderlich ist, diese Methode zu überschreiben
• Codezeile 6: Hier haben wir die Hauptmethode definiert, in der wir die Ausführung des Threads starten werden.
• Codezeile 7: Hier erstellen wir einen neuen Thread-Namen als „guruthread1“, indem wir eine neue Thread-Klasse instanziieren.
• Codezeile 8: Wir verwenden die „start“-Methode des Threads mit der „guruthread1“-Instanz. Hier wird der Thread ausgeführt.
• Codezeile 10: Hier verwenden wir die „sleep“-Methode des Threads mit der „guruthread1“-Instanz. Daher wird der Thread für 1000 Millisekunden schlafen.
• Code 9-14: Hier haben wir die Sleep-Methode in den Try-Catch-Block eingefügt, da eine geprüfte Ausnahme auftritt, d. h. eine unterbrochene Ausnahme.
• Codezeile 15: Hier setzen wir die Priorität des Threads unabhängig von der Priorität auf 1
• Codezeile 16: Hier erhalten wir die Priorität des Threads mit getPriority()
• Codezeile 17: Hier geben wir den von getPriority abgerufenen Wert
aus
• Codezeile 18: Hier schreiben wir einen Text, der Thread läuft.

Wenn Sie den obigen Code ausführen, erhalten Sie die folgende Ausgabe:

Ausgabe:

5 ist die Thread-Priorität und Thread Running ist der Text, der die Ausgabe unseres Codes ist.

Java-Thread-Synchronisierung

Beim Multithreading gibt es das asynchrone Verhalten der Programme. Wenn ein Thread einige Daten schreibt und ein anderer Thread gleichzeitig Daten liest, kann dies zu Inkonsistenzen in der Anwendung führen.

Wenn zwei oder mehr Threads auf die gemeinsam genutzten Ressourcen zugreifen müssen, wird ein Synchronisationsansatz verwendet.

Java hat synchronisierte Methoden bereitgestellt, um synchronisiertes Verhalten zu implementieren.

Sobald der Thread bei diesem Ansatz in den synchronisierten Block gelangt, kann kein anderer Thread diese Methode für dasselbe Objekt aufrufen. Alle Threads müssen warten, bis dieser Thread den synchronisierten Block beendet und daraus hervorgeht.

Auf diese Weise hilft die Synchronisation in einer Multithread-Anwendung. Ein Thread muss warten, bis der andere Thread seine Ausführung beendet hat, erst dann dürfen die anderen Threads ausgeführt werden.

Es kann in folgender Form geschrieben werden:

Synchronized(object)
{  
        //Block of statements to be synchronized
}

Java-Multithreading-Beispiel

In diesem Multithreading-Java-Beispiel nehmen wir zwei Threads und rufen die Namen der Threads ab.

Beispiel1:

GuruThread1.java
package demotest;
public class GuruThread1 implements Runnable{

    /**
     * @param args
     */
    public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
    }
}

Erklärung des Codes:

• Codezeile 3: Wir haben eine Klasse „GuruThread1“ genommen, die Runnable implementiert (sie sollte von jeder Klasse implementiert werden, deren Instanzen vom Thread ausgeführt werden sollen.)
• Codezeile 8: Dies ist die Hauptmethode der Klasse
• Codezeile 9: Hier instanziieren wir die Thread-Klasse und erstellen eine Instanz mit dem Namen „guruThread1“ und erstellen einen Thread.
• Codezeile 10: Hier instanziieren wir die Thread-Klasse und erstellen eine Instanz namens „guruThread2“ und erstellen einen Thread.
• Codezeile 11: Wir beginnen den Thread, d. h. guruThread1.
• Codezeile 12: Wir starten den Thread, d.h. guruThread2.
• Codezeile 13: Ausgabe des Textes als „Thread name are following:“
• Codezeile 14: Abrufen des Namens von Thread 1 mithilfe der Methode getName() der Thread-Klasse.
• Codezeile 15: Abrufen des Namens von Thread 2 mithilfe der Methode getName() der Thread-Klasse.

Wenn Sie den obigen Code ausführen, erhalten Sie die folgende Ausgabe:

Ausgabe:

Thread-Namen werden hier als

• Guru1
• Guru2

Beispiel 2:

In diesem Beispiel für Multithreading in Java lernen wir, wie die Methoden run() und start() einer ausführbaren Schnittstelle überschrieben werden, und erstellen zwei Threads dieser Klasse und führen sie entsprechend aus.

Außerdem belegen wir zwei Kurse,

• Eine, die die lauffähige Schnittstelle implementiert und
• Eine weitere, die die Hauptmethode enthält und entsprechend ausgeführt wird.

package demotest;
public class GuruThread2 {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  GuruThread3 threadguru1 = new GuruThread3("guru1");
  threadguru1.start();
  GuruThread3 threadguru2 = new GuruThread3("guru2");
  threadguru2.start();
 }
}
class GuruThread3 implements Runnable {
 Thread guruthread;
 private String guruname;
 GuruThread3(String name) {
  guruname = name;
 }
 @Override
 public void run() {
  System.out.println("Thread running" + guruname);
  for (int i = 0; i < 4; i++) {
   System.out.println(i);
   System.out.println(guruname);
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    System.out.println("Thread has been interrupted");
   }
  }
 }
 public void start() {
  System.out.println("Thread started");
  if (guruthread == null) {
   guruthread = new Thread(this, guruname);
   guruthread.start();
  }
 }
}

Erklärung des Codes:

• Codezeile 2: Hier nehmen wir eine Klasse „GuruThread2“, die die Hauptmethode enthält.
• Codezeile 4: Hier nehmen wir eine Hauptmethode der Klasse.
• Codezeile 6-7: Hier erstellen wir eine Instanz der Klasse GuruThread3 (die in den folgenden Codezeilen erstellt wird) als „threadguru1“ und starten den Thread.
• Codezeile 8-9: Hier erstellen wir eine weitere Instanz der Klasse GuruThread3 (die in den folgenden Codezeilen erstellt wird) als „threadguru2“ und starten den Thread.
• Codezeile 11: Hier erstellen wir eine Klasse „GuruThread3“, die die ausführbare Schnittstelle implementiert (sie sollte von jeder Klasse implementiert werden, deren Instanzen vom Thread ausgeführt werden sollen.)
• Codezeile 13-14: Wir nehmen zwei Klassenvariablen, von denen eine vom Typ Thread-Klasse und die andere vom Typ String-Klasse ist.
• Codezeile 15-18: wir überschreiben den GuruThread3-Konstruktor, der ein Argument als Zeichenfolgentyp (der Name des Threads) annimmt, das der Klassenvariablen guruname zugewiesen wird, und daher wird der Name des Threads gespeichert.
• Codezeile 20: Hier überschreiben wir die Methode run() der ausführbaren Schnittstelle.
• Codezeile 21: Wir geben den Thread-Namen mit der println-Anweisung aus.
• Codezeile 22-31: Hier verwenden wir eine for-Schleife mit einem auf 0 initialisierten Zähler, der nicht kleiner als 4 sein sollte (wir können eine beliebige Zahl nehmen, daher wird die Schleife hier viermal ausgeführt) und den Zähler inkrementieren. Wir geben den Thread-Namen aus und versetzen den Thread innerhalb eines Try-Catch-Blocks für 1000 Millisekunden in den Ruhezustand, da die Sleep-Methode eine überprüfte Ausnahme ausgelöst hat.
• Codezeile 33: Hier überschreiben wir die Startmethode der ausführbaren Schnittstelle.
• Codezeile 35: Wir geben den Text „Thread started“ aus.
• Codezeile 36-40: Hier verwenden wir eine if-Bedingung, um zu prüfen, ob die Klassenvariable guruthread einen Wert enthält oder nicht. Wenn es null ist, erstellen wir eine Instanz mit der Thread-Klasse, die den Namen als Parameter verwendet (der Wert wurde im Konstruktor zugewiesen). Danach wird der Thread mit der Methode start() gestartet.

Wenn Sie den obigen Code ausführen, erhalten Sie die folgende Ausgabe:

Ausgabe :

Es gibt zwei Threads, daher erhalten wir zweimal die Meldung „Thread started“.

Wir erhalten die Namen der Threads so, wie wir sie ausgegeben haben.

Es geht in die for-Schleife, wo wir den Zähler und Thread-Namen ausgeben und der Zähler mit 0 beginnt.

Die Schleife wird dreimal ausgeführt und dazwischen wird der Thread für 1000 Millisekunden in den Ruhezustand versetzt.

Daher erhalten wir zuerst guru1, dann guru2, dann wieder guru2, weil der Thread hier für 1000 Millisekunden schläft, und dann als nächstes guru1 und wieder guru1, Thread schläft für 1000 Millisekunden, also erhalten wir guru2 und dann guru1.

Zusammenfassung

In diesem Tutorial haben wir Multithreading-Anwendungen in Java gesehen und wie man Single- und Multithreading in Java verwendet.

• Erklären Sie Multithreading in Java:Beim Multithreading werden Benutzer nicht blockiert, da Threads unabhängig sind und mehrere Operationen gleichzeitig ausführen können
• Verschiedene Stadien des Lebenszyklus des Fadens sind,
  • Neu
  • Ausführbar
  • Laufen
  • Warten
  • Tot
• Wir haben auch etwas über die Synchronisierung zwischen Threads gelernt, die dazu beitragen, dass die Anwendung reibungslos läuft.
• Multithread-Programmierung in Java erleichtert viele weitere Anwendungsaufgaben.