Der Zustand des Fadens
Thread -Statusdiagramm:
veranschaulichen:
Themen enthalten die folgenden 5 Zustände.
1. New State : Nachdem das Thread -Objekt erstellt wurde, tritt er in den neuen Zustand ein. Zum Beispiel thread Thread = neuer Thread ().
2. Runnable: Auch als "ausführbarer Zustand" bekannt. Nachdem das Thread -Objekt erstellt wurde, rufen andere Threads die Start () -Methode des Objekts auf, um den Thread zu starten. Zum Beispiel thread.start (). Ein Thread in einem fertigen Zustand kann jederzeit von der CPU ausgeführt werden.
3. Auslaufstatus: Der Thread erhält CPU -Berechtigungen für die Ausführung. Es ist zu beachten, dass Threads nur den laufenden Status aus dem Ready State eingeben können.
4. Blockierter Zustand: Blockierter Zustand bedeutet, dass der Thread die CPU -Nutzungsrechte aus irgendeinem Grund aufgibt und vorübergehend nicht mehr läuft. Erst wenn der Thread in den bereiten Zustand eingeht, hat er die Chance, in den Laufstatus zu gehen. Es gibt drei Arten von Blockaden:
.
(2) Synchronisierte Blockierung-Ein Thread erfasst das synchronisierte Synchronisationsschloss (da das Schloss von anderen Threads besetzt ist), er wird in einen synchronisierten Blockierungszustand eingetragen.
(3) Andere Blockierungen-Der Thread tritt in einen Blockierungszustand ein, indem Sie Schlaf () oder Join () des Threads anrufen oder eine E/A-Anfrage ausstellen. Wenn der Sleep () -State zeitlich abgestimmt war, Join () darauf wartete, dass der Faden endet oder zeitlich abgestimmt hat oder die E/A-Verarbeitung abgeschlossen wurde, wurde der Thread wieder in den bereiten Zustand eingegeben.
5. Dead State: Der Thread hat die Ausführung der Run () -Methode aufgrund einer Ausnahme beendet oder beendet, und der Thread beendet seinen Lebenszyklus.
Die in diesen 5 Zuständen beteiligten Inhalte umfassen die Objektklasse, den Thread und die synchronisierten Schlüsselwörter. Wir werden diese Inhalte einzeln in den folgenden Kapiteln lernen.
Objektklasse definiert Schlaf-/Weckfunktionen wie Wait (), benachrichtigen (), NotifyAll (), usw.
Die Thread -Klasse definiert einige Spalten -Thread -Betriebsfunktionen. Zum Beispiel die Schlaffunktion von Sleep (), Interrupt () Interrupt -Funktion, getName () Get Thread Name usw.
Synchronisiert ist ein Schlüsselwort; Es zeichnet sich durch synchronisierte Codeblöcke und synchronisierte Methoden aus. Die Funktion von synchronisiert besteht darin, die Synchronisationsschloss des Objekts zu erfassen.
Wenn wir später Wait (), Notify () und andere Methoden einführen, werden wir analysieren, warum "Wait (), Benachrichtigung () und andere Methoden in der Objektklasse definiert werden sollten, nicht in der Thread -Klasse".
Zwei Möglichkeiten zur Implementierung von Multi-Threading: Thread und Runnable
Runnable ist eine Schnittstelle, die nur eine Run () -Methode enthält. Seine Definition ist wie folgt:
öffentliche Schnittstelle Runnable {public abstract void run ();} Die Rolle von Runnable implementiert Multi-Threading. Wir können eine Klasse A definieren, um die Runnable -Schnittstelle zu implementieren. Erstellen Sie dann einen neuen Thread durch einen neuen Thread (neu A ()) und andere Methoden.
Thread ist eine Klasse. Thread selbst implementiert die runnable Schnittstelle. Seine Aussage lautet wie folgt:
öffentliche Klasse -Thread implementiert runnable {}
Die Rolle des Threads besteht darin, Multi-Threading zu realisieren.
Ähnlichkeiten und Unterschiede zwischen Thread und Runnable:
Die Ähnlichkeit zwischen Thread und Runnable: Beide sind „Multi-Thread-Implementierungsmethoden“.
Die Unterschiede zwischen Thread und Runnable:
Thread ist eine Klasse, und runnable ist eine Schnittstelle; Thread selbst ist eine Klasse, die die Runnable -Schnittstelle implementiert. Wir wissen, dass "eine Klasse nur eine übergeordnete Klasse haben kann, aber mehrere Schnittstellen implementieren kann", so dass Runnable eine bessere Skalierbarkeit hat.
Darüber hinaus kann Runnable auch zum "Austausch von Ressourcen" verwendet werden. Das heißt, mehrere Threads werden basierend auf einem bestimmten Runnable -Objekt erstellt, und sie teilen Ressourcen für das Runnable -Objekt.
Im Allgemeinen wird empfohlen, Multi-Threading durch "Runnable" zu implementieren!
Multithreading -Beispiele für Thread und Runnable
1. Multithreading Beispiel für Thread
Im Folgenden können wir den Thread besser verstehen und anhand von Beispielen auf ein Beispiel online ziehen, das überzeugender ist. // ThreadTest.java Quellcode
Klasse myThread erweitert Thread {private int Ticket = 10; public void run () {für (int i = 0; i <20; i ++) {if (this.ticket> 0) {System.out.println (this.getName ()+"Tickets: Ticket"+this.ticket--); }}}}}}; public class threadtest {public static void main (String [] args) {// starten 3 Threads T1, T2, T3; Jeder Thread verkauft 10 Tickets! MyThread t1 = new MyThread (); MyThread t2 = new MyThread (); MyThread t3 = new MyThread (); t1.start (); t2.Start (); t3.Start (); }} Auslaufergebnisse:
Thread-0 Ticket Selling: ticket10Thread-1 Ticket Selling: ticket10Thread-2 Ticket Selling: ticket10Thread-1 Ticket Selling: ticket9Thread-0 Ticket Selling: ticket9Thread-1 Ticket Selling: ticket8Thread-2 Ticket Selling: ticket9Thread-1 Ticket Selling: ticket7Thread-0 Ticket Selling: ticket8Thread-1 Ticket Selling: ticket6Thread-2 Ticket Selling: ticket8Thread-1 Ticket Selling: ticket5Thread-0 Ticket Selling: ticket7Thread-1 Ticket Selling: ticket4Thread-2 Ticket Selling: ticket7Thread-1 Ticket Selling: ticket3Thread-0 Tickets: ticket6Thread-1 Tickets: ticket2Thread-2 Tickets: ticket6Thread-2 Tickets: ticket5Thread-2 Tickets: ticket4Thread-1 Tickets: ticket1Thread-0 Tickets: ticket5Thread-2 Tickets: ticket3Thread-0 Tickets: ticket4Thread-2 Tickets: ticket2Thread-0 Tickets: ticket3Thread-0 Tickets: ticket1Thread-0 Tickets: Ticket2Thread-0 Tickets: Ticket1Thread-0 Tickets: Ticket2Thread-0 Tickets: Ticket11
Ergebnisse Beschreibung:
(1) MyThread erbt vom Thread, einem benutzerdefinierten Thread. Jedes MyThread verkauft 10 Tickets.
(2) Das Hauptfaden -Haupthaupt erstellt und startet 3 MyThread Child -Threads. Jeder Kinderfaden verkauft 10 Tickets.
2. Multithread -Beispiel von Runnable
Als nächstes ändern wir das obige Programm. Implementieren Sie eine Schnittstelle über Runnable, wodurch Multi-Threading implementiert wird.
// runnabletest.java Quellcodeklasse MyThread implementiert runnable {private int ticket = 10; public void run () {für (int i = 0; i <20; i ++) {if (this.ticket> 0) {System.out.println (Thread.CurrentThread (). getName ()+"Ticketverkauf: Ticket"+this.ticket-); }}}}}; public class Runnabletest {public static void main (String [] args) {MyThread mt = new MyThread (); // 3 Threads T1, T2, T3 starten (sie teilen ein runnierbares Objekt), und diese 3 Threads verkaufen insgesamt 10 Tickets! Thread T1 = neuer Thread (MT); Thread T2 = neuer Thread (MT); Thread T3 = neuer Thread (MT); t1.start (); t2.Start (); t3.Start (); }} Auslaufergebnisse:
Thread-0-Ticket Verkauf: Ticket10Thread-2 Ticket Verkauf: Ticket8Thread-1-Ticket Verkauf: Ticket9Thread-2 Ticket Verkauf: Ticket6Thread-0 Ticket Verkauf: Ticket7Thread-2 Ticket Verkauf: Ticket4Thread-Verkauf: Ticket5Thread-2 Ticketverkauf: Ticket2Thread-0 Ticketverkauf: Ticket3Thread-1 Ticketverkauf
Ergebnisse Beschreibung:
(1) Im Gegensatz zum oben genannten "MyThread erbt er erbt vom Thread"; Hier implementiert MyThread die Thread -Schnittstelle.
. Das Ergebnis der Operation ist, dass diese 3 Kinderfäden insgesamt 10 Tickets verkauften. Dies bedeutet, dass sie die MyThread -Schnittstelle teilen.