Detaillierte Erläuterung von Java -Threads und den Unterschied zwischen Threads und Prozessen
1. Verfahren und Fäden
Jeder Prozess verfügt über einen eindeutigen Speicherplatz, und eine Anwendung kann gleichzeitig mehrere Prozesse starten. Zum Beispiel ist im IE -Browser das Öffnen eines IE -Browsers gleichbedeutend mit dem Starten eines Prozesses.
Ein Thread bezieht sich auf einen Ausführungsprozess in einem Prozess, und ein Prozess kann mehrere Threads enthalten.
Jeder Prozess benötigt das Betriebssystem, um den unabhängigen Speicherplatz zuzuordnen, und mehrere Threads im selben Prozess teilen diesen Speicherplatz, dh gemeinsamer Speicher und andere Ressourcen.
Jedes Mal, wenn Java.exe aufgerufen wird, startet das Betriebssystem einen Prozess der virtuellen Java -Maschine. Wenn der Prozess der virtuellen Maschine von Java gestartet wird, erstellt die Java Virtual Machine einen Hauptfaden, mit dem die Hauptmethode der Programmeingang aus ausgeführt wird.
Jedes Mal, wenn ein Java -Virtual Machine einen Thread startet, wird dem Thread einen Thread -Methode -Stapel zugewiesen, um relevante Informationen (z. B. lokale Variablen usw.) zu speichern, und der Thread wird auf diesem Stapel ausgeführt. Daher sind lokale Variablen in Java-Objekten thread-sicher, Instanzvariablen und Klassenvariablen werden jedoch nicht im Stapel gespeichert, sodass sie nicht mit Thread-Safe sind.
Es gibt drei Zustände des Prozesses: Bereit, Ausführung und Blockierung.
2. Methode der Fadenerstellung
Runnable -Methode: (Diese Methode ist flexibel, empfohlen)
public class thread02 implementiert runnable {public static void main (String [] args) {runnable r = new <strong> thread02 </strong> (); Thread t1 = neuer Thread (<strong> r </strong>, "t1"); /*** Thread Quellcode* public Thread (Runnable Ziel, Zeichenfolge Name) {init (null, target, name, 0); } */ Thread t2 = neuer Thread (r, "t2"); t1.start (); // Thread T1 starten, in Ready State, wartet auf CPU t2.Start (); // Thread T2 starten, in readatischer Zustand, wartet auf cpu t1.run (); // Der Haupt -Thread -Main nennt die Auslaufmethode von Object t1} public void run () {System.out.println ("Threads Name ist" + Thread.currentThread (). GetName ()); }}Das Ergebnis der Operation kann sein:
Der Name des Threads ist der Name von T1Thread lautet Maintheads Name T2
Der Kopf
public class Thread03 erweitert Thread {public static void main (String [] args) {Thread03 t1 = new <strong> Thread03 </strong> (); // Schreiben Sie es als Thread t1 = neuer Thread () Hinweis: Thread03 ist zu diesem Zeitpunkt ein Thread t1.start (); } public void run () {System.out.println ("Thread's Name ist" + Thread.currentThread (). getName ()); }}Auslaufergebnis: Der Name des Threads ist Thread-0
Hinweis: Zusätzlich zu den angepassten Threads gibt es jedes Mal, wenn das Programm ausgeführt wird, ein Haupt -Thread.
umfassend:
public class thread01 {public static void main (String [] args) {Thread = new Thread (); thread.start (); // Was wirklich funktioniert, ist run ()/** und läuft in Thread* public void run () {if (target! = null) {target.run (); }} Also muss der Thread, den Sie selbst erstellt haben, die Run -Methode neu schreiben und den Inhalt in run () einsetzen. Sie müssen also die Schnittstelle oder die Vererbung implementieren und dann Unterklassen erstellen (InterruptedException e) {e.printstacktrace (); } //Thread.currentThread () erhält das aktuelle Thread System.out.println ("Thread 1 is"+thread.currentThread (). GetName ()); }}}}; // thread1.start (); // Nicht in der Lage, ohne den Thread zu schreiben // Erstellen von Thread 2 Runnable -Methode (Implementierung) Es wird empfohlen, Thread 2 = neuer Thread (neu Runnable () {public void run () {while (true) {try {thread.sleep (300);} catch (InterruptedException E) {e.printStacktrace (). "+Thread.currentThread (). GetName ());}}}); // thread2.start (); // Thread New Thread ausführen (neuer Runnable () {public void run () {System.out.println ("Runnable"+Thread.CurrentThread (). getName ());}}) {public void run () {// Die Run -Methode in der Subklasse übersteht die Laufmethode. "+Thread.currentThread (). GetName ()); } }.Start(); } /****Die Ausführung von Multithreading in einer einzelnen CPU reduziert sehr wahrscheinlich die Ausführungseffizienz, anstatt eine Person zu verbessern, die das Gleiche an verschiedenen Orten tut* /}Danke fürs Lesen, ich hoffe, es kann Ihnen helfen. Vielen Dank für Ihre Unterstützung für diese Seite!