Java Multi-Thread-Programmierung

Java Multi-Thread-Programmierung Unterstützung Built-in zur Verfügung zu stellen. Ein Multi-Thread-Programm enthält zwei oder mehrere Teile gleichzeitig ausgeführt werden können. Jeder Teil des Programms ist ein Thread genannt, und jeder Thread definiert einen separaten Pfad der Ausführung.

Multithreading ist eine spezielle Form von Multi-Tasking, Multi-Threading, aber verwenden Sie einen kleineren Ressourcenaufwand.

Ein anderer Begriff ist hier definiert, und in Bezug auf Threads - Prozess: ein Prozess, einschließlich des Betriebssystems Speicherplatz reserviert, die einen oder mehrere Threads enthält. Ein separater Thread kann nicht existieren, es ist Teil des Prozesses sein muss. Es wurde ein Verfahren bis zum Ende aller nicht-Warte läuft nach dem Ende des Fadens zu laufen.

Multithreading können Programmierer treffen effizientes Programm zu schreiben volle CPU-Auslastung Zwecke zu erreichen.

Ein Thread des Lebenszyklus

Faden durch alle Phasen des Lebenszyklus. Die folgende Abbildung zeigt den kompletten Lebenszyklus eines Fadens.

• Neuer Status:

  das neue Schlüsselwort und die Thread - Klasse oder Unterklasse ein Thread - Objekt zu erstellen Nach der Verwendung ist das Thread - Objekt in einen neuen Zustand. Es bleibt in diesem Zustand bis zum Programmstart () diesen Thread.

• Ready - Zustand:

  Wenn ein Thread-Objekt die Methode start () zu nennen, den Faden in den Bereitschaftszustand. Bereit Thread in der Bereitschaftswarteschlange, für die JVM Thread-Scheduler Scheduling zu warten.

• Betriebszustand:

  Wenn der Thread bereit Zustand der CPU - Ressourcen bekommt, können Sie run () durchführen, wird der Thread zu diesem Zeitpunkt ausgeführt werden. Führen Sie das komplexeste ausgeführt wird, kann es verstopft Zustand, Bereitschaftszustand, und der Zustand des Todes.

• Blockiert Zustand:

  Wenn ein Thread nach dem Schlaf (Schlaf) ausgeführt wird, aussetzen (Hang) und andere Methoden, den Verlust der belegten Ressourcen, tritt der Faden um den blockierten Zustand ausgeführt werden kann. Nach der Ruhezeit Ausrüstung oder Ressourcen zur Verfügung hat, kommen die Bereitschaftszustand erneut eingeben.

• DerTod Status:

  Wenn ein Thread Zustand der Aufgabe oder anderen Beendigungsbedingung läuft auftritt, wird der Faden zum Ende Zustand geschaltet.

Ein Thread Priorität

Jedes Java-Thread hat eine Priorität, die das Betriebssystem Thread-Scheduling Reihenfolge bestimmen können.

Java-Thread-Priorität ist eine ganze Zahl, die von 1 (Thread.MIN_PRIORITY) im Bereich - 10 (Thread.MAX_PRIORITY).

Standardmäßig wird jeder Thread eine Priorität NORM_PRIORITY (5) zugeordnet.

Gewinde mit einer höheren Priorität ist wichtiger, um das Programm und sollte Prozessorressourcen vor niedriger Priorität Threads zuzuweisen. Allerdings garantieren die Auftrags Thread Thread-Priorität der Ausführung nicht und ist sehr abhängig von der Internet.

Erstellen Sie einen Faden

Java bietet zwei Methoden, um einen Thread zu erstellen:

• Fahrbare durch die Schnittstelle implementiert;
• Durch Vererbung Thread-Klasse selbst.

einen Faden durch die Implementierung von Runnable Schnittstelle zu erstellen

Erstellen Sie einen Thread, ist der einfachste Weg, um eine Klasse zu erstellen, die die Runnable-Schnittstelle implementiert.

Um Runnable zu erreichen, muss eine Klasse nur einen Methodenaufruf run () ausführen, die folgende Erklärung ab:

public void run()

Sie können diese Methode überschreiben, ist es wichtig, die run () können auch andere Methoden aufrufen, die Verwendung anderer Klassen, und deklarieren Sie eine Variable, wie der Haupt-Thread zu verstehen.

Nach dem Erstellen einer Klasse Runnable-Schnittstelle implementiert, können Sie ein Objekt in der Klasse einen Thread instanziiert.

Thema definiert mehrere Konstrukteure werden im Anschluss an diese verwenden wir oft:

Thread(Runnable threadOb,String threadName);

Hier threadOb ist eine Instanz einer Klasse, die die Runnable-Schnittstelle implementiert, und threadName den neuen Namen des Threads angeben.

Nach dem neuen Thread erstellt wird, rufen Sie seine Methode start () wird es laufen.

void start();

Beispiele

Hier ist ein Beispiel davon ein Gewinde und starten Ausführung zu erstellen:

// 创建一个新的线程
class NewThread implements Runnable {
   Thread t;
   NewThread() {
      // 创建第二个新线程
      t = new Thread(this, "Demo Thread");
      System.out.println("Child thread: " + t);
      t.start(); // 开始线程
   }
  
   // 第二个线程入口
   public void run() {
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
            // 暂停线程
            Thread.sleep(50);
         }
     } catch (InterruptedException e) {
         System.out.println("Child interrupted.");
     }
     System.out.println("Exiting child thread.");
   }
}
 
public class ThreadDemo {
   public static void main(String args[]) {
      new NewThread(); // 创建一个新线程
      try {
         for(int i = 5; i > 0; i--) {
           System.out.println("Main Thread: " + i);
           Thread.sleep(100);
         }
      } catch (InterruptedException e) {
         System.out.println("Main thread interrupted.");
      }
      System.out.println("Main thread exiting.");
   }
}

Kompilieren Sie das obige Programm läuft wie folgt ab:

Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting.

Um einen Faden durch Vererbung Thema erstellen

Die zweite Möglichkeit, einen Thread zu erstellen, ist eine neue Klasse zu erstellen, die die Thread-Klasse erbt und dann eine Instanz einer Klasse erstellen.

Vererben Klasse muss die Methode run () außer Kraft setzen, die der Einstiegspunkt für den neuen Thread ist. Es muss auch die Startanzeige () -Methode aufrufen, auszuführen.

Beispiele

// 通过继承 Thread 创建线程
class NewThread extends Thread {
   NewThread() {
      // 创建第二个新线程
      super("Demo Thread");
      System.out.println("Child thread: " + this);
      start(); // 开始线程
   }
 
   // 第二个线程入口
   public void run() {
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Child Thread: " + i);
                            // 让线程休眠一会
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Child interrupted.");
      }
      System.out.println("Exiting child thread.");
   }
}
 
public class ExtendThread {
   public static void main(String args[]) {
      new NewThread(); // 创建一个新线程
      try {
         for(int i = 5; i > 0; i--) {
            System.out.println("Main Thread: " + i);
            Thread.sleep(100);
         }
      } catch (InterruptedException e) {
         System.out.println("Main thread interrupted.");
      }
      System.out.println("Main thread exiting.");
   }
}

Kompilieren Sie das obige Programm läuft wie folgt ab:

Child thread: Thread[Demo Thread,5,main]
Main Thread: 5
Child Thread: 5
Child Thread: 4
Main Thread: 4
Child Thread: 3
Child Thread: 2
Main Thread: 3
Child Thread: 1
Exiting child thread.
Main Thread: 2
Main Thread: 1
Main thread exiting.

Themen-Methoden

Die folgende Tabelle listet die Klasse Thread einige wichtige Möglichkeiten:

Prüft, ob dieser Thread aktiv ist. Das obige Verfahren ist Thread-Objekt aufgerufen. Die folgende Methode ist eine statische Methode der Thread-Klasse.

Beispiele

Das folgende Programm zeigt einige der Möglichkeiten ThreadClassDemo Thread-Klasse:

// 文件名 : DisplayMessage.java
// 通过实现 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);
      }
   }
}

// 文件名 : GuessANumber.java
// 通过继承 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.**");
   }
}

// 文件名 : 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...");
   }
}

Ergebnisse sind wie folgt, wobei die Ergebnisse jedes Durchlaufs nicht gleich sind.

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Hello
Thread-2 guesses 27
Hello
** Correct! Thread-2 in 102 guesses.**
Hello
Starting thread4...
Hello
Hello
..........remaining result produced.

Gewinde mehrere wichtige Konzepte:

Wenn die Programmierung multithreaded, müssen Sie die folgenden Konzepte zu verstehen:

• Themen-Synchronisation
• Die Kommunikation zwischen den Threads
• Thread-Deadlock
• Fadensteuer: Suspend, zu stoppen und wieder aufnehmen

Verwenden Sie mehrere Threads

Der Schlüssel zur effektiven Nutzung von Multi-Threaded-Programme sind die gleichzeitige Ausführung verstanden wird und nicht als serielle Ausführung. Zum Beispiel: Das Programm hat zwei Subsysteme müssen gleichzeitig auszuführen, diesmal Sie die Vorteile von Multi-Thread-Programmierung nehmen müssen.

Durch die Verwendung von mehreren Threads, können Sie ein sehr effizientes Programm schreiben. Beachten Sie jedoch, dass, wenn Sie zu viele Threads zu erstellen, wird die Effizienz der Programmausführung tatsächlich reduziert, anstatt verbessert.

Denken Sie daran, das Kontext-Switch-Overhead ist auch sehr wichtig, wenn Sie zu viele Threads erstellen, CPU-Zeit in Zusammenhang verbrachte Zeit der Ausführung des Programms Schalt wird mehr!