Dieser Artikel folgt dem vorherigen Artikel "Detaillierte Erläuterung von Beispielen für Java multithreading (i)".
4. Der Blockierungszustand und die Fadensteuerung von Java -Multithreads
Oben wurden mehrere spezifische Arten von Java -Blockierungen erwähnt. Schauen wir uns die Hauptmethoden an, die eine Java -Fadenblockade verursachen.
1.Join ()
Join - Lassen Sie einen Thread warten, bis ein anderer Thread abgeschlossen ist, bevor Sie die Ausführung fortsetzen. Wenn Thread A in der Thread B -Methode von Thread B in der Thread -Ausführungskörper aufgerufen wird, wird Thread A blockiert und erst nach dem Abschluss von Thread B von Thread B kann A weiterhin ausgeführt werden.
public class threadtest {public static void main (String [] args) {Myrunnable Myrunnable = new Myrunnable (); Thread = neuer Thread (myrunnable); für (int i = 0; i <100; i ++) {System.out.println (thread.currentThread (). getName () + "" + i); if (i == 30) {thread.start (); try {thread.join (); // Haupt Thread muss warten, bis der Thread -Thread ausgeführt wird, bevor er weiter ausführt} catch (InterruptedException e) {e.printstacktrace (); }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} ·2.Sleep ()
Schlaf - Lassen Sie den aktuell ausführenden Thread die angegebene Zeit pausieren und in einen Blockierungszustand eingeben. Während des Zeitraums, in dem es schläft, hat der Thread keine Gelegenheit zum Ausführen, da er nicht im bereiten Zustand steht. Auch wenn es zu diesem Zeitpunkt keine anderen ausführbaren Threads im System enthalten, werden die Threads in Sleep () nicht ausgeführt. Daher wird die Sleep () -Methode häufig verwendet, um die Fadenausführung zu pausieren.
Wie bereits erwähnt, gelangt der Thread, wenn die Methode start () des neu erstellten Threads aufgerufen wird, in den Bereitschaftszustand und kann die CPU -Zeitscheibe zu einem bestimmten Zeitpunkt zum Ausführen erhalten. Wenn der neue Thread sofort mit einer bestimmten Notwendigkeit ausgeführt wird, rufen Sie einfach den Schlaf (1) des ursprünglichen Threads direkt auf.
public class threadtest {public static void main (String [] args) {Myrunnable Myrunnable = new Myrunnable (); Thread = neuer Thread (myrunnable); für (int i = 0; i <100; i ++) {System.out.println (thread.currentThread (). getName () + "" + i); if (i == 30) {thread.start (); try {thread.sleep (1); // Thread sofort ausgeführt werden} catch (InterruptedException e) {e.printstacktrace (); }}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}} ·Hinweis: Das Schlafen für eine Millisekunde reicht aus, da die CPU nicht im Leerlauf ist und zum neu erstellten Thread wechselt.
3. Hintergrund -Thread (Daemon -Thread)
Konzept/Zweck: Hintergrund -Threads bieten hauptsächlich Dienste für andere Threads (relativ bezeichnete Vordergrund -Threads) oder "Daemon -Threads". Wie der Garbage Collection -Faden in der JVM.
Lebenszyklus: Der Lebenszyklus eines Hintergrundfadens hängt mit dem Lebenszyklus des Vordergrunds zusammen. Es spiegelt sich hauptsächlich in: Wenn alle Vordergrund -Fäden in den toten Zustand eintreten, stirbt der Hintergrund -Thread automatisch (tatsächlich ist dies leicht zu verstehen, da der Zweck des Hintergrund -Fadens darin besteht, den Vordergrund -Thread zu dienen. Da alle Vordergrundfäden gestorben sind, wie hält es immer noch ... groß!).
Hintergrund -Thread einstellen: Wenn Sie die Methode SetDaemon (True) des Thread -Objekts aufrufen, können Sie den angegebenen Thread als Hintergrund -Thread festlegen.
public class threadTest {public static void main (String [] args) {Thread mythread = new mythead (); für (int i = 0; i <100; i ++) {System.out.println ("Hauptsthread i ="+i); if (i == 20) {myThread.setdaemon (true); mythead.start (); }}}}} Klasse myThread erweitert Thread {public void run () {für (int i = 0; i <100; i ++) {System.out.println ("i ="+i); try {thread.sleep (1); } catch (InterruptedException e) {// Todo automatisch generierter Catch-Block e.printstacktrace (); }}}}Bestimmen Sie, ob der Thread ein Hintergrund -Thread ist: Rufen Sie die Isdeamon () -Methode des Thread -Objekts auf.
HINWEIS: Der Hauptfaden ist standardmäßig der Vordergrund -Thread, der untergeordnete Thread, der in der Erstellung des Vordergrunds erstellt wurde, standardmäßig der Vordergrund -Thread und der im Hintergrund -Thread erstellte Thread ist standardmäßig der Hintergrund -Thread. Wenn Sie die Methode SetDeamon (TRUE) aufrufen, um den Vordergrund -Thread als Hintergrund -Thread festzulegen, muss sie vor dem Aufrufen der Start () aufgerufen werden. Nachdem die Fäden am Tag vor gestern gestorben sind, benachrichtigt die JVM den Hintergrund -Thread zu sterben, aber es dauert eine gewisse Zeit, wenn die Anweisungen zur Beantwortung erhalten werden.
4. Ändern Sie die Priorität von Threads/SetPriority ():
Jeder Thread hat eine gewisse Priorität bei der Ausführung, und Threads mit hoher Priorität haben mehr Ausführungsmöglichkeiten. Jeder Thread hat die gleiche Priorität wie der Thread, der ihn erstellt hat. Der Haupt -Thread hat standardmäßig eine normale Priorität.
Setzen Sie Thread -Priorität: SetPriority (int PriorityLevel). Der Parameter PriorityLevel-Bereich liegt zwischen 1-10 und die häufig verwendeten drei statischen Konstantenwerte sind wie folgt:
Max_priority: 10
Min_priority: 1
Norm_priorität: 5
Priorität erhalten: getPriority ().
Hinweis: Ein Thread -Objekt mit höherer Thread -Priorität bedeutet nur, dass dieser Thread mehr Ausführungsmöglichkeiten als vor Prioritätsausführung hat.
public class threadTest {public static void main (String [] args) {Thread mythread = new myThread (); für (int i = 0; i <100; i ++) {System.out.println ("Hauptsthread i ="+i); if (i == 20) {myThread.setPriority (thread.max_priority); mythead.start (); }}}}} Klasse myThread erweitert Thread {public void run () {für (int i = 0; i <100; i ++) {System.out.println ("i ="+i); }}}5. Thread -Zugeständnisse: Ausbeute ()
Die grundlegende Rolle von Rendite () wurde im vorherigen Blog -Beitrag diskutiert. Gleichzeitig hängt die Rendite () -Methode auch mit der Priorität der Threads zusammen. Wenn ein Thread die EILED () -Methode aufruft, um vom laufenden Status in den Ready -Status zu wechseln, wählt die CPU nur Threads mit der gleichen Priorität oder einer höheren Priorität wie der Thread aus der Fertigungswarteschlange zur Ausführung von Ready State Thread aus.
public class threadtest {public static void main (String [] args) {Thread mythread1 = new MyThread1 (); Thread mythread2 = neu mythread2 (); mythread1.setPriority (thread.max_priority); MyThread2.setPriority (Thread.min_Priority); für (int i = 0; i <100; i ++) {System.out.println ("Hauptsthread i ="+i); if (i == 20) {myThread1.start (); MyThread2.Start (); Thread.yield (); }}}}} class myThread1 erweitert Thread {public void run () {für (int i = 0; i <100; i ++) {System.out.println ("MyThread 1 - i ="+i); }}} class myThread2 erweitert Thread {public void run () {für (int i = 0; i <100; i ++) {System.out.println ("MyThead 2 - i ="+i); }}}Artikelserie:
Erläuterung von Java-Multi-Thread-Instanzen (i)
Detaillierte Erklärung von Java-Multi-Thread-Instanzen (ii)
Detaillierte Erklärung von Java-Multi-Threade-Instanzen (III)