Dieser Artikel ist eine Zusammenfassung der Grundnutzung von Java Multithreading.
In diesem Artikel wird die grundlegende Verwendung von Java Multithreading aus den folgenden Aspekten erläutert:
So verwenden Sie Multithreading
Zwei Möglichkeiten, einen Thread zu starten
Java bietet zwei Möglichkeiten zur Verwendung von Multi-Threading. Einer besteht darin, eine Klasse zu schreiben, um Thread zu erben, dann die Auslaufmethode zu überschreiben und dann die Startmethode aufzurufen, um den Thread zu starten. Zu diesem Zeitpunkt wird in dieser Klasse den Code in der Run -Methode in der Art und Weise ausgeführt, wie ein anderer Thread. Eine andere Möglichkeit besteht darin, eine Klasse zu schreiben, um die Runnable -Schnittstelle zu implementieren, dann den Schnittstellenmethodenlauf zu implementieren und dann ein Thread -Objekt zu erstellen, die Klasse zu verwenden, die die Runnable -Schnittstelle als Konstruktionsparameter implementiert, sie in das Thread -Objekt übergeben und schließlich die Thread -Objekt auf die Startmethode aufruft.
Die Startmethode hier ist eine Methode mit Start -up -Funktion, die die Auslaufmethode intern aufruft. Daher wird die Auslaufmethode nur dann direkt aufgerufen, wenn die Startmethode aufgerufen wird.
Darüber hinaus gibt die Startmethode der virtuellen Maschine nur mit, dass der Thread gestartet werden kann. Dies bedeutet, dass sich der Thread im fertigen Zustand befindet. Dies bedeutet jedoch nicht, dass der Startaufruf sofort ausgeführt wird. Dies erfordert das Warten auf die JVM, um zu entscheiden, wann der Thread ausgeführt werden soll. Mit anderen Worten, wenn es zwei Threads A und B gibt, werden ein Anruf zuerst beginnen und B -Anrufe später beginnen, dies bedeutet nicht, dass Thread A zuerst ausgeführt wird und Thread B später ausgeführt wird. Dies wird durch das JVM bestimmt und kann als zufälliges Startup angesehen werden.
Im Folgenden verwenden wir den tatsächlichen Code, um zwei Möglichkeiten zum Starten von Threads zu veranschaulichen:
Der erste Typ ist der Thread erbt
public class examplethead erweitert Thread {@Override public void run () {super.run (); System.out.println ("Dies ist ein von Thread geerbter Beispiele -Beispiel"); }}Der Testcode befindet sich in der ExampraTheadTest -Klasse im Testverzeichnis
Eine andere Möglichkeit implementiert die runnable Schnittstelle
public class examPleringable implements runnable {public void run () {System.out.println ("Dies ist die Klasse, die die Runnable -Schnittstelle implementiert"); }}Für den Testcode können Sie die ExamPerunabletest -Klasse im Testverzeichnis sehen.
So erhalten Sie einige Informationen über Multithreading
Nach dem Start von Multi-Threading hoffen wir, einige Informationen über den gestarteten Thread durch einige APIs zu erhalten. JDK bietet uns eine Thread -Klassenmethode, um einige Informationen über den Thread zu erhalten.
Holen Sie sich den Namen des Threads
Diese Methoden sind interne Methoden des Threads, sodass wir diese Methoden auf zwei Arten aufrufen können. Eine davon ist, dass wir dies verwenden können, um ihn zu nennen, wenn unsere Klasse Thread erbt. Eine andere Möglichkeit besteht darin, diese Methoden über Thread.CurrentThread () aufzurufen. Diese beiden Methoden unterscheiden sich jedoch in unterschiedlichen Nutzungsszenarien.
Schauen wir uns kurz die Verwendung von zwei Methoden an.
Der erste Thread.CurrentThread () wird verwendet, der Code ist wie folgt:
public class exampecurrentThread erweitert Thread {public exampecurrentThread () {System.out.println ("Druck der Konstruktormethode:" + thread.currentThread (). getName ()); } @Override public void run () {super.run (); System.out.println ("Drucken der Auslaufmethode:" + thread.currentThread (). GetName ()); }}Der Testcode lautet wie folgt:
public class exampecurrent threadest erweitert testCase {public void testinit () löst Ausnahme aus {expheadPecurrent thread thread = new ExphectPecurrentThread (); } public void testrun () löst Ausnahme aus {explodplecurrent thread thread = new evercyPecurrentThread (); Thread.Start (); Thread.sleep (1000); }}Die Ergebnisse sind wie folgt:
Druck der Konstruktormethode: Druck der Hauptmethode: Druck der Thread-0-Konstruktionsmethode: Haupt
Warum verwenden wir Thread.currentThread () in exchitleCurrentThread, um anzuzeigen, dass die Konstruktionsmethode als Hauptdrucken gedruckt wird. Es ist offensichtlich, dass die Konstruktionsmethode vom Haupt -Thread ausgeführt wird und die Run -Methode von dem von uns selbst begonnenen Thread ausgeführt wird. Da es nicht benannt ist, ist es Standard-Thread-0.
Als nächstes werfen wir einen Blick auf die Erben von Thread und rufen ihn damit an.
public class ComplexCurrentThread erweitert Thread {public complexCurrentThread () {System.out.println ("begin ================="); System.out.println ("thread.currentThread (). GetName =" + thread.currentThread (). GetName ()); System.out.println ("this.getName () =" + this.getName ()); System.out.println ("end ================================================================================================================================================================================================================================== =} @Override public void run () {Super.run (); System.out.println ("Thread.CurrentThread (). GetName =" + Thread.CurrentThread ().Der Testcode lautet wie folgt:
public class complexCurrentThreadtest erweitert testCase {public void testrun () löst Ausnahme aus {ComplexCurrentThread Thread = new ComplexCurrentThread (); thread.setName ("byhieg"); Thread.Start (); Thread.sleep (3000); }}Die Ergebnisse sind wie folgt:
begin===========Thread.currentThread().getName=mainthis.getName()=Thread-0end===================== Run begin========Thread.currentThread().getName=byhiegthis.getName()=byhiegrun end===========
Beim Erstellen des Objekts wird der Konstruktor zunächst vom Haupt -Thread ausgeführt, sodass Thread.currentThread () den Namen des Haupt -Threads erhält. Diese Methode bezieht sich jedoch auf das Objekt, das die Methode, dh die Threadinformationen von ComplexCurrentThread, aufruft. Es gibt noch keinen SetName, also ist es der Standardname. Dann ist die Run -Methode entweder Thread.currentThread () oder dies gibt Threadinformationen mit dem Byhieg -Namenssatz zurück.
So thread.currentThread bezieht sich auf die Threadinformationen, die diesen Codeblock spezifisch ausführen. Der Konstruktor wird von Main ausgeführt, und die Run -Methode ist, welcher Thread startet und welcher Thread ausgeführt wird. Aus dieser Sicht sind die Informationen, die dies erhalten kann, ungenau, da wir, wenn wir dies ausführen. GETNAME (), aber die Run -Methode wird von einem anderen Thread gestartet, können wir die Informationen der neuen Stadt mit der Run -Methode über diesen. Und nur Klassen, die Thread erben können, können Methoden wie GetName haben, was eine Katastrophe für Javas Feature -Sprachen ist, die nicht mehrere Erbschaften haben. Für alle Informationen zu den Threads, die wir danach erhalten möchten, verwenden wir Thread.currentThread (), um die API aufzurufen.
Holen Sie sich die ID des Threads
Rufen Sie Getid an, um die eindeutige Identifizierung des Threads zu erhalten. Dies ist das gleiche wie die Verwendung von GetName oben. Es gibt nichts zu sagen. Sie können sich exitleidThread und seine Testklassen -Beispielidthreadest direkt ansehen.
Bestimmen Sie, ob der Faden überlebt
Die Funktion der Methode iSalive () besteht darin, zu testen, ob der Thread aktiv ist. Der sogenannte aktive Zustand bedeutet, dass der Thread begonnen wurde, aber nicht beendet wurde. Das heißt, nachdem der Thread begonnen hat, wird es als lebendig angesehen.
Schauen wir uns spezifische Beispiele an:
öffentliche Klasse AlivetHhread erweitert Thread {@Override public void run () {Super.run (); System.out.println ("Ist es in der Run -Methode lebendig" + "" + thread.currentThread (). ISalive ()); }}Die Testmethode lautet wie folgt:
öffentliche Klasse AlivetheadTest erweitert testCase {public void testrun () löst eine Ausnahme aus {AlivetHhread Thread = new Alivethead (); System.out.println ("begin ==" + thread.isalive ()); Thread.Start (); Thread.sleep (1000); System.out.println ("End ==" + Thread.isalive ()); Thread.sleep (3000); }}Die Ergebnisse sind wie folgt:
begin == ob trueend in der falschen Methode == false
Wir können feststellen, dass der Thread vor dem Start als nicht überrascht angesehen wird, und wenn er dann läuft, lebt er. Wenn die Run -Methode ausgeführt wird, wird sie als nicht überrascht angesehen.
Wie man einen Thread anhält
Bestimmen Sie, ob der Thread beendet ist
JDK stellt einige Methoden zur Verfügung, um festzustellen, ob der Thread beendet wird - ist unterbrochen () und unterbrochen ()
Wie man Fäden stoppt
Dies ist eine wichtigere Methode beim Erhalten von Threadinformationen, da sie sich auf die Methode des Abschlusses von Threads bezieht. Lassen Sie mich zunächst über verschiedene Möglichkeiten sprechen, um Themen zu beenden:
Ich werde nicht über die erste sprechen, die zweite Stop () -Methode wurde aufgegeben, da die folgenden Gründe auftreten können:
Zu bestimmten Beispielen können Sie StoppLockThread und seine Testklasse StoppLockThreadtest sehen
Der dritte Typ ist die derzeit empfohlene Beendigung, die Interrupt aufruft und dann feststellt, ob die Run -Methode beendet werden soll. Es gibt zwei Möglichkeiten, die Kündigung zu beurteilen. Eine ist die statische Methode unterbrochen () der Thread -Klasse, und die andere ist die Thread -Element -Methode, die () unterbrochen wird. Es gibt einen Unterschied zwischen diesen beiden Methoden. Die erste Methode setzt den Status automatisch zurück. Wenn unterbrochen () zweimal hintereinander aufgerufen wird, muss es beim ersten Mal, wenn es beim ersten Mal falsch ist, wahr sein. Und ist interruptd () nicht.
Beispiele sind wie folgt:
public class BeispielinterruptThread erweitert Thread {@Override public void run () {super.run (); Versuchen Sie {für (int i = 0; i <50000000; i ++) {if (interrupted ()) {System.out.println ("Es ist bereits ein Stoppstatus, ich möchte beenden"); Neue InterruptedException werfen ("Stop ......"); } System.out.println ("i =" + (i + 1)); }} catch (InterruptedException e) {System.out.println ("Smoothly"); }}}Der Testcode lautet wie folgt:
public class BeispielinterruptThreadTest erweitert testCase {public void testrun () löst eine Ausnahme aus {BeispielinterruptThread thread = new BeispielinterruptThread (); Thread.Start (); Thread.sleep (1000); thread.interrupt (); }}Die vierte Methode ist die gleiche wie die dritte. Der einzige Unterschied besteht darin, die geworfene Ausnahme im obigen Code durch Rückgabe zu ersetzen. Ich mag es immer noch, Ausnahmen zu werfen. Hier gibt es viele Formen der Verarbeitung, z. B. das Druck von Informationen, das Schließen oder Erfassen der Ressource und das dann wieder in die obere Schicht.
Beachten Sie, dass die Ausnahme, die wir überlegen haben, eine InterruptedException ist. Hier sprechen wir kurz über die Gründe, warum diese Ausnahme generiert werden kann. Rufen Sie im Falle des ursprünglichen Fadenschlafes unterrupt auf, um den Faden zu beenden, oder lassen Sie den Faden zuerst und lassen Sie dann den Fadenschlafen.
Wie man thread innehält
Die folgenden zwei Methoden sind im JDK zur Überhauberung von Threads und zur Wiederherstellung von Threads bereitgestellt.
Diese beiden Methoden sind aufgegebene Methoden wie die Stop -Methode, und ihre Verwendung ist die gleiche wie Stop, brutal suspendiert und fäden restauriert. Die Hauptgründe, warum diese beiden Methoden aufgegeben werden, sind:
Einige andere Verwendungen von Threads
Einige andere grundlegende Verwendungen von Threads sind wie folgt:
Gewinne
JDK liefert die Rendite () -Methode damit, dass der Thread die aktuelle CPU -Ressource aufgibt und ihn anderen Aufgaben zur Neigung von CPU -Zeit erteilt, aber dies ist auch eine zufällige Sache. Es ist möglich, dass es die Zeit in Anspruch nehmen wird, nachdem die Ressourcen aufgegeben werden.
Weitere Beispiele finden Sie in Exampleyieldthread und seiner Testklasse Exampleyieldthreadtest
Stellen Sie die Priorität von Threads fest
Wir können die Priorität von Threads festlegen, damit die CPU so viel wie möglich so weit wie möglich an Threads mit höherer Priorität gesendet werden kann. Java legt 1-10 10 Prioritätsniveaus fest, und es gibt drei statische Variablen, um drei Prioritätsniveaus bereitzustellen:
/*** Die minimale Priorität, die ein Thread haben kann. */ Public Final static int min_priority = 1; /*** Die Standardpriorität, die einem Thread zugeordnet ist. */ Public Final static int norm_priority = 5; /*** Die maximale Priorität, die ein Thread haben kann. */ Public Final static int max_priority = 10;
Wir können die Priorität des Threads durch SetPriority festlegen und drei statische Variablen direkt übergeben oder direkt in den Zahlen 1-10 übergeben. Nach der Einstellung hat der Thread unterschiedliche Prioritäten. Was passiert, wenn wir keine Priorität festlegen?
Die Priorität von Threads wird vererbt. Wenn wir Thread B in Thread A starten, hat AB die gleiche Priorität. Wenn wir einen Thread im Hauptfaden starten, haben wir im Allgemeinen eine konsistente Priorität mit dem Hauptfaden. Die Priorität des Haupt -Threads ist standardmäßig 5.
Hier sind einige Regeln für die Priorität:
Fadenschutz
Der JDK bietet eine SetDaemon -Methode, um einen Thread so einzustellen, dass ein Daemon -Thread wird. Das Merkmal von Daemon-Threads besteht darin, dass die Daemon-Threads automatisch zerstört werden, nachdem andere nicht-daemon-Threads ausgeführt wurden. Ein typisches Beispiel ist der GC -Recycler.
Weitere Informationen finden Sie unter BeispielePleDaemonThread und Beispiele für Beispiele.
Zusammenfassen
Dieser Artikel fasst hauptsächlich einige grundlegende Verwendungen von Java -Threads zusammen und ist im zweiten Artikel über die Sicherheit und die Synchronisation von Thread enthalten.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, dass der Inhalt dieses Artikels für das Studium oder die Arbeit eines jeden hilfreich sein wird. Ich hoffe auch, Wulin.com mehr zu unterstützen!