Detaillierte Einführung in den Lebenszyklus von Java -Threads und Beispielcode

Wenn ein Thread erstellt und gestartet wird, tritt er weder in den Ausführungszustand ein, sobald er gestartet wird, noch ist er immer im Ausführungszustand. Während seines Lebenszyklus muss es fünf Staaten durchlaufen: "neu", "runnierbar", "rennen", "blockiert" und "tot". Nachdem der Thread erstellt wurde, ist es unmöglich, die CPU zu besetzen und unabhängig zu laufen. Es muss zwischen mehreren Threads wechseln, sodass es die meiste Zeit zwischen dem Laufen und der Blockierung umgestellt hat.

1. Der Zustand des Fadens

Es gibt verschiedene Zustände der Existenz eines Threads wie folgt:

1. Neuer Status
2. Fertigstatus
3. Auslaufstatus
4. Toter Status
5. Nicht -Runnable -Status
   

1. neuer Status

Der neue Staat ist ein Staat, in dem der Thread erstellt wurde, aber nicht angefangen hat zu laufen. In diesem Zustand kann der Thread ausgeführt werden, indem die Start () -Methode des Threads aufgerufen wird.

2. Runnable Status

Der Runnable -Zustand kann als Vorbereitungsstatus oder die Warteschlange bezeichnet werden. In diesem Zustand kann der Thread ausgeführt werden, indem Sie die Start () -Methode des Threads aufrufen.
Der Thread -Scheduler bestimmt, welche Threads ausgeführt werden sollen und wie lange der Thread ausgeführt wird.

3. Auslaufstatus

Wenn ein Thread ausgeführt wird, befindet sich er im laufenden Status.

4. Tot Status

Sobald ein Faden in den toten Zustand eintritt, kann er nicht mehr laufen.

5. Nicht -Runnable -Status

1. Ein laufender Thread kann je nach laufender Situation in den nicht runnablen Zustand umgewandelt werden.
2. Ein Thread kann auch den nicht runnierbaren Zustand beibehalten, bis der zufriedene Zustand erscheint.
3. Ein Thread mit einem nicht runnablen Zustand kann nicht direkt in den Laufstatus springen, sondern zuerst in den laufbaren Zustand umgewandelt werden.
4. Schlafen: Die angegebene Zeit für den Fadenschlaf.
5. E/A -Blockierung: Der Faden wartet, bis der Blockierungsvorgang abgeschlossen ist.
6. Blockierung Join: Der Thread wartet, bis ein anderer Thread ausgeführt wird.
7. Warten auf Benachrichtigung: Der Thread wartet auf die Benachrichtigung aus einem anderen Thread.
8. Sperrmechanismus Blockierung: Der Gewinde wartet, bis das angegebene Schloss freigesetzt wird und das Schloss erhalten wird.

Die Java Virtual Machine JVM führt Threads nach Prioritäts- und Planungsprinzipien aus.

2. Thread Scheduler

In JVM basiert die Implementierung von Thread Scheduler normalerweise auf den folgenden zwei Strategien:

Präventive Planungsstrategie Zeitteilung Planungsstrategie oder Round-Robin-Planungsstrategie

Die Implementierung eines Thread-Schedulers ist plattformunabhängig, sodass die Planung von Threads unvorhersehbar ist.

3. Priorität von Threads

Der JVM weist jedem neu erstellten Thread eine Priorität zu.

Stufe 0: Dies ist die niedrigste Priorität
Stufe 5: Dies ist die normale Priorität
Stufe 10: Dies hat die höchste Priorität

Um diese Werte zu speichern, hat die Thread -Klasse drei entsprechende Variablen:

1. öffentliche statische endgültige int min_priorität
2. öffentliche statische endgültige int norm_priorität
3. öffentliche statische endgültige int max_priority

Ein Thread erbt zunächst die Priorität seines übergeordneten Threads. Die Standardpriorität jedes Threads beträgt Stufe 5 (normale Priorität), und die Standardpriorität des Haupt -Threads beträgt Level 5.

Die Priorität des Threads kann durch die Methode SetPriority (int Priority) eingestellt werden.

öffentliche endgültige Leere SetPriority (int Priorität)
öffentliche Leere getPriority ();

Ein benutzerdefinierter Thread verfügt über einen Standard-Thread-Thread-Thread-Thread-Numbernummer, und die Sequenznummer startet von 0, z. B. der erste Thread ist Thread0.
Der Threadname kann über die Methode SetName (String -Name) eingestellt werden, und der Threadname kann mit der Methode getName () erhalten werden.

öffentliche endgültige Void -SetName (String -Name)
öffentliche Finale String GetName ().

Beispiel

Lassen Sie uns unten ein Beispiel sehen:

 Paket Demo.ch; Public Class Userthread erweitert Thread {userThread () {Super (); } UserThread (String -Name) {Super (Name); } public void run () {System.out.println ("Thread begonnen."); } public static void main (String [] args) {userThread thread1 = new Userthead ("Thread1"); UserThread thread2 = new Userthead ("Thread2"); System.out.println ("Thread 1 Anfangsname und Priorität"); System.out.println ("Name:" + Thread1.getName ()); System.out.println ("Priorität:" + Thread1.getPriority ()); System.out.println ("Thread 2 anfänglicher Name und Priorität"); System.out.println ("Name:" + Thread2.getPriority ()); System.out.println ("Priorität:" + thread2.getPriority ()); System.out.println (""); Thread1.SetPriority (6); thread2.setPriority (9); System.out.println ("Thread 1 Anfangsname und Priorität"); System.out.println ("Name:" + Thread1.getName ()); System.out.println ("Priorität:" + Thread1.getPriority ()); System.out.println ("Thread 2 anfänglicher Name und Priorität"); System.out.println ("Name:" + Thread2.getName ()); System.out.println ("Priorität:" + thread2.getPriority ()); System.out.println (""); Thread1.Start (); thread2.Start (); für (int i = 0; i <5; i ++) system.out.println ("Hauptmethode i Wert:"+i); }}

Ausgangsergebnis:

 Thread 1 Name und Prioritätsname: Thread1Priority: 5Thread 2 Anfangsname und Priorität Name: Thread2Priority: 5Thread 1 Erstname und Prioritätsname: Thread1Priority: 6Thread -Name und Prioritätsname: Thread2Priority: 9Main -Methode I Value: 2Main -Value: 3Main -Laufen: 2 -Main -MAIN -Methode I Value: 2 -Main -Methode I Value: 2Main -Methode I Value I Value I Value I Value I Value I Value I Value I Value.

Danke fürs Lesen, ich hoffe, es kann Ihnen helfen. Vielen Dank für Ihre Unterstützung für diese Seite!