Java - Multithreading

Java ist eine Multithread-Programmiersprache Das bedeutet, dass wir mit Java Multithread-Programme entwickeln können. Ein Multithread-Programm enthält zwei oder mehr Teile, die gleichzeitig ausgeführt werden können, und jeder Teil kann gleichzeitig eine andere Aufgabe erledigen, wodurch die verfügbaren Ressourcen optimal genutzt werden, insbesondere wenn Ihr Computer über mehrere CPUs verfügt.

Per Definition ist Multitasking, wenn sich mehrere Prozesse gemeinsame Verarbeitungsressourcen wie eine CPU teilen. Multi-Threading erweitert die Idee des Multitaskings auf Anwendungen, bei denen Sie bestimmte Operationen innerhalb einer einzelnen Anwendung in einzelne Threads unterteilen können. Jeder der Threads kann parallel laufen. Das Betriebssystem verteilt die Verarbeitungszeit nicht nur auf verschiedene Anwendungen, sondern auch auf jeden Thread innerhalb einer Anwendung.

Multi-Threading ermöglicht es Ihnen, so zu schreiben, dass mehrere Aktivitäten gleichzeitig im selben Programm ablaufen können.

Lebenszyklus eines Threads

Ein Faden durchläuft in seinem Lebenszyklus verschiedene Stadien. Beispielsweise wird ein Thread geboren, gestartet, ausgeführt und stirbt dann. Das folgende Diagramm zeigt den kompletten Lebenszyklus eines Threads.

Es folgen die Phasen des Lebenszyklus −

• Neu − Ein neuer Faden beginnt seinen Lebenszyklus im neuen Zustand. Es bleibt in diesem Zustand, bis das Programm den Thread startet. Er wird auch als geborener Faden bezeichnet .

• Ausführbar − Nachdem ein neu geborener Thread gestartet wurde, wird der Thread lauffähig. Es wird davon ausgegangen, dass ein Thread in diesem Zustand seine Aufgabe ausführt.

• Warten − Manchmal geht ein Thread in den Wartezustand über, während der Thread darauf wartet, dass ein anderer Thread eine Aufgabe ausführt. Ein Thread geht nur dann in den lauffähigen Zustand zurück, wenn ein anderer Thread dem wartenden Thread signalisiert, die Ausführung fortzusetzen.

• Zeitgesteuertes Warten − Ein lauffähiger Thread kann für ein bestimmtes Zeitintervall in den zeitgesteuerten Wartezustand wechseln. Ein Thread in diesem Zustand geht zurück in den ausführbaren Zustand, wenn dieses Zeitintervall abläuft oder wenn das Ereignis eintritt, auf das er wartet.

• Beendet (Tot) − Ein lauffähiger Thread tritt in den beendeten Zustand ein, wenn er seine Aufgabe abschließt oder anderweitig beendet wird.

Thread-Prioritäten

Jeder Java-Thread hat eine Priorität, die dem Betriebssystem hilft, die Reihenfolge zu bestimmen, in der Threads geplant werden.

Java-Thread-Prioritäten liegen im Bereich zwischen MIN_PRIORITY (eine Konstante von 1) und MAX_PRIORITY (eine Konstante von 10). Standardmäßig erhält jeder Thread die Priorität NORM_PRIORITY (eine Konstante von 5).

Threads mit höherer Priorität sind für ein Programm wichtiger und sollten vor Threads mit niedrigerer Priorität Prozessorzeit zugewiesen bekommen. Thread-Prioritäten können jedoch nicht die Reihenfolge garantieren, in der Threads ausgeführt werden, und sind sehr stark plattformabhängig.

Erstellen Sie einen Thread durch Implementieren einer ausführbaren Schnittstelle

Wenn Ihre Klasse als Thread ausgeführt werden soll, können Sie dies erreichen, indem Sie ein Runnable implementieren Schnittstelle. Sie müssen drei grundlegende Schritte befolgen −

Schritt 1

Als ersten Schritt müssen Sie eine run()-Methode implementieren, die von einem Runnable bereitgestellt wird Schnittstelle. Diese Methode bietet einen Einstiegspunkt für den Thread, und Sie werden Ihre vollständige Geschäftslogik in diese Methode einfügen. Es folgt eine einfache Syntax der Methode run() −

public void run( )

Schritt 2

Als zweiten Schritt instanziieren Sie einen Thread Objekt mit dem folgenden Konstruktor −

Thread(Runnable threadObj, String threadName);

Wo, threadObj ist eine Instanz einer Klasse, die das Runnable implementiert Schnittstelle und threadName ist der Name des neuen Threads.

Schritt 3

Sobald ein Thread-Objekt erstellt wurde, können Sie es starten, indem Sie start() aufrufen -Methode, die einen Aufruf der Methode run( ) ausführt. Es folgt eine einfache Syntax der Methode start() −

void start();

Beispiel

Hier ist ein Beispiel, das einen neuen Thread erstellt und startet −

Live-Demo

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

Dies wird das folgende Ergebnis erzeugen −

Ausgabe

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Erstellen Sie einen Faden durch Erweitern einer Fadenklasse

Die zweite Möglichkeit, einen Thread zu erstellen, besteht darin, eine neue Klasse zu erstellen, die Thread erweitert Klasse mit den folgenden zwei einfachen Schritten. Dieser Ansatz bietet mehr Flexibilität bei der Handhabung mehrerer Threads, die mit verfügbaren Methoden in der Thread-Klasse erstellt wurden.

Schritt 1

Sie müssen run() überschreiben Methode, die in der Thread-Klasse verfügbar ist. Diese Methode bietet einen Einstiegspunkt für den Thread, und Sie werden Ihre vollständige Geschäftslogik in diese Methode einfügen. Es folgt eine einfache Syntax der Methode run() −

public void run( )

Schritt 2

Sobald das Thread-Objekt erstellt ist, können Sie es starten, indem Sie start() aufrufen -Methode, die einen Aufruf der Methode run( ) ausführt. Es folgt eine einfache Syntax der Methode start() −

void start( );

Beispiel

Hier ist das vorhergehende Programm umgeschrieben, um den Thread zu erweitern −

Live-Demo

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

Dies wird das folgende Ergebnis erzeugen −

Ausgabe

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

Thread-Methoden

Es folgt die Liste wichtiger Methoden, die in der Thread-Klasse verfügbar sind.

Sr.No.	Methode &Beschreibung
1	public void start() Startet den Thread in einem separaten Ausführungspfad und ruft dann die run()-Methode für dieses Thread-Objekt auf.
2	Public void run() Wenn dieses Thread-Objekt mit einem separaten Runnable-Ziel instanziiert wurde, wird die run()-Methode für dieses Runnable-Objekt aufgerufen.
3	public final void setName(String name) Ändert den Namen des Thread-Objekts. Es gibt auch eine Methode getName() zum Abrufen des Namens.
4	public final void setPriority(int priority) Legt die Priorität dieses Thread-Objekts fest. Die möglichen Werte liegen zwischen 1 und 10.
5	public final void setDaemon(boolean on) Ein Parameter von true kennzeichnet diesen Thread als Daemon-Thread.
6	public final void join (lange Millisekunde) Der aktuelle Thread ruft diese Methode für einen zweiten Thread auf, wodurch der aktuelle Thread blockiert wird, bis der zweite Thread beendet wird oder die angegebene Anzahl von Millisekunden verstrichen ist.
7	public void interrupt() Unterbricht diesen Thread, wodurch die Ausführung fortgesetzt wird, wenn er aus irgendeinem Grund blockiert wurde.
8	public final boolean isAlive() Gibt „true“ zurück, wenn der Thread aktiv ist, also zu einem beliebigen Zeitpunkt, nachdem der Thread gestartet wurde, aber bevor er vollständig ausgeführt wird.

Die vorherigen Methoden werden für ein bestimmtes Thread-Objekt aufgerufen. Die folgenden Methoden in der Thread-Klasse sind statisch. Das Aufrufen einer der statischen Methoden führt die Operation auf dem aktuell laufenden Thread aus.

Sr.No.	Methode &Beschreibung
1	öffentliche statische Leerausbeute() Bewirkt, dass der aktuell laufende Thread allen anderen Threads mit derselben Priorität, die darauf warten, geplant zu werden, nachgibt.
2	öffentlicher statischer Ruhezustand (lange Millisekunde) Bewirkt, dass der aktuell laufende Thread für mindestens die angegebene Anzahl von Millisekunden blockiert wird.
3	öffentlicher statischer boolescher Wert holdsLock(Object x) Gibt wahr zurück, wenn der aktuelle Thread die Sperre für das angegebene Objekt hält.
4	öffentlicher statischer Thread currentThread() Gibt eine Referenz auf den aktuell laufenden Thread zurück, der diese Methode aufruft.
5	öffentlicher statischer void dumpStack() Druckt den Stack-Trace für den aktuell ausgeführten Thread, was beim Debuggen einer Multithread-Anwendung hilfreich ist.

Beispiel

Das folgende ThreadClassDemo-Programm demonstriert einige dieser Methoden der Thread-Klasse. Stellen Sie sich eine Klasse DisplayMessage vor die Runnable implementiert −

// File Name : DisplayMessage.java
// Create a thread to implement Runnable

public class DisplayMessage implements Runnable {
   private String message;
   
   public DisplayMessage(String message) {
      this.message = message;
   }
   
   public void run() {
      while(true) {
         System.out.println(message);
      }
   }
}

Es folgt eine weitere Klasse, die die Thread-Klasse erweitert −

// File Name : GuessANumber.java
// Create a thread to extentd Thread

public class GuessANumber extends Thread {
   private int number;
   public GuessANumber(int number) {
      this.number = number;
   }
   
   public void run() {
      int counter = 0;
      int guess = 0;
      do {
         guess = (int) (Math.random() * 100 + 1);
         System.out.println(this.getName() + " guesses " + guess);
         counter++;
      } while(guess != number);
      System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
   }
}

Es folgt das Hauptprogramm, das die oben definierten Klassen verwendet −

// File Name : ThreadClassDemo.java
public class ThreadClassDemo {

   public static void main(String [] args) {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
      
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();

      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try {
         thread3.join();
      } catch (InterruptedException e) {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
      
      thread4.start();
      System.out.println("main() is ending...");
   }
}

Dies führt zu folgendem Ergebnis. Sie können dieses Beispiel immer wieder ausprobieren und erhalten jedes Mal ein anderes Ergebnis.

Ausgabe

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

Wichtige Java-Multithreading-Konzepte

Bei der Multithreading-Programmierung in Java müssen Sie die folgenden Konzepte sehr praktisch haben −

• Was ist Thread-Synchronisation?

• Handhabung der Interthread-Kommunikation

• Umgang mit Thread-Deadlock

• Wichtige Thread-Operationen