Java Concurrency - Übersicht

Java ist eine Multithread-Programmiersprache, was bedeutet, dass wir Multithread-Programme mit Java 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 ausführen und die verfügbaren Ressourcen optimal nutzen, insbesondere wenn Ihr Computer über mehrere CPUs verfügt.

Multitasking ist per Definition, wenn mehrere Prozesse gemeinsame Verarbeitungsressourcen wie eine CPU gemeinsam nutzen. Multithreading erweitert die Idee des Multitasking auf Anwendungen, bei denen Sie bestimmte Vorgänge innerhalb einer einzelnen Anwendung in einzelne Threads unterteilen können. Jeder der Threads kann parallel ausgeführt werden. Das Betriebssystem teilt die Verarbeitungszeit nicht nur auf verschiedene Anwendungen auf, sondern auch auf jeden Thread innerhalb einer Anwendung.

Mit Multithreading können Sie so schreiben, dass mehrere Aktivitäten gleichzeitig im selben Programm ausgeführt werden können.

Lebenszyklus eines Threads

Ein Thread durchläuft verschiedene Phasen seines Lebenszyklus. Beispielsweise wird ein Thread geboren, gestartet, ausgeführt und stirbt dann. Das folgende Diagramm zeigt den gesamten Lebenszyklus eines Threads.

Es folgen die Phasen des Lebenszyklus -

  • New- Ein neuer Thread beginnt seinen Lebenszyklus im neuen Zustand. Es bleibt in diesem Zustand, bis das Programm den Thread startet. Es wird auch als bezeichnetborn thread.

  • Runnable- Nachdem ein neu geborener Thread gestartet wurde, kann der Thread ausgeführt werden. Ein Thread in diesem Status führt seine Aufgabe aus.

  • Waiting- Manchmal wechselt ein Thread in den Wartezustand, während der Thread darauf wartet, dass ein anderer Thread eine Aufgabe ausführt. Ein Thread wechselt erst dann in den ausführbaren Zustand zurück, wenn ein anderer Thread dem wartenden Thread signalisiert, die Ausführung fortzusetzen.

  • Timed Waiting- Ein ausführbarer Thread kann für ein bestimmtes Zeitintervall in den zeitgesteuerten Wartezustand wechseln. Ein Thread in diesem Zustand wechselt zurück in den ausführbaren Zustand, wenn dieses Zeitintervall abläuft oder wenn das Ereignis auftritt, auf das er wartet.

  • Terminated (Dead) - Ein ausführbarer Thread wechselt in den Status "Beendet", wenn er seine Aufgabe abgeschlossen oder auf andere Weise beendet hat.

Thread-Prioritäten

Jeder Java-Thread hat eine Priorität, mit deren Hilfe das Betriebssystem die Reihenfolge bestimmen kann, in der Threads geplant sind.

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 stark plattformabhängig.

Erstellen Sie einen Thread, indem Sie eine ausführbare Schnittstelle implementieren

Wenn Ihre Klasse als Thread ausgeführt werden soll, können Sie dies erreichen, indem Sie a implementieren RunnableSchnittstelle. Sie müssen drei grundlegende Schritte ausführen:

Schritt 1

Als ersten Schritt müssen Sie eine run () -Methode implementieren, die von a bereitgestellt wird RunnableSchnittstelle. 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

In einem zweiten Schritt instanziieren Sie a Thread Objekt mit dem folgenden Konstruktor -

Thread(Runnable threadObj, String threadName);

Wobei threadObj eine Instanz einer Klasse ist, die das implementiertRunnable Schnittstelle und threadName ist der Name des neuen Threads.

Schritt 3

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

void start();

Example

Hier ist ein Beispiel, das einen neuen Thread erstellt und ihn ausführt -

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 führt zu folgendem Ergebnis:

Output

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 Thread, indem Sie eine Thread-Klasse erweitern

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

Schritt 1

Sie müssen überschreiben run( )Methode in der Thread-Klasse verfügbar. 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 run () -Methode -

public void run( )

Schritt 2

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

void start( );

Example

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

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 führt zu folgendem Ergebnis:

Output

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.