Thread -Zugeständnisse: Ausbeute ()
Der Zweck von Rendite () besteht darin, nachzugeben. Es kann dem aktuellen Thread den "Ready State" aus dem "Laufstatus" eingeben, damit andere Wartefäden mit derselben Priorität die Ausführungsrechte erhalten können. Es kann jedoch nicht garantieren, dass andere Threads mit derselben Priorität definitiv Ausführungsrechte erhalten, nachdem der aktuelle Thread -Aufruf Rendite () () () () befreit wird. Es kann auch sein, dass der aktuelle Thread in den "Laufstatus" eintritt und weiter läuft!
Beispiel:
Klasse Threada erweitert Thread {public threada (String name) {Super (name); } public synchronisierte void run () {für (int i = 0; i <10; i ++) {System.out.printf ("%s [%d]:%d/n", this.getName (), this.getPriority (), i); // Wenn ich durch 4 geteilt wird, rufen Sie Rendite an, wenn (i%4 == 0) Thread.yield (); }}} public class renditetest {public static void main (String [] args) {threada t1 = new threada ("t1"); Threada t2 = new threada ("t2"); t1.start (); t2.Start (); }} (Einmal) Betriebsergebnis:
t1 [5]:0t2 [5]:0t1 [5]:1t1 [5]:2t1 [5]:3t1 [5]:4t1 [5]:5t1 [5]:6t1 [5]:7t1 [5]:8t1 [5]:9t2 [5]:1t2 [5]:2t2 [5]:3t2 [5]:4t2 [5]:5t2 [5]: 6t2 [5]: 7t2 [5]: 8t2 [5]: 9
Ergebnisse Beschreibung:
Wenn "Thread T1" von 4 integriert werden kann, wechselt es nicht auf "Thread T2". Dies zeigt, dass, obwohl Rendite () die Threads ermöglichen kann, den "Ready -Status" aus "laufenden Zustand" einzugeben, aber nicht unbedingt es anderen Threads erlaubt, CPU -Ausführungsrechte zu erhalten (d. H. Andere Threads geben den "laufenden Zustand" ein, auch wenn dieser "andere Thread" die gleiche Priorität hat wie der Thread, der derzeit Rendite rufte ().
Vergleich von Ertrag () und Wait ():
Wir wissen, dass die Funktion von Wait () darin besteht, den aktuellen Thread den "Waiting (Blocking) aus dem" Laufstatus "einzugeben und auch die Synchronisationsschloss freizusetzen. Die Funktion von Rendite () besteht darin, nachzugeben, wodurch der aktuelle Thread auch den" Laufstatus "verlässt. Ihre Unterschiede sind: ihre Unterschiede sind:
(1) Wait () soll den Thread den "Wartenwart (blockieren) Status" aus dem "Laufstatus" eingeben lassen, während nicht Rendite () den Thread den "Ready State" aus dem "Laufstatus" eingeben lässt.
(2) Wait () ist eine Synchronisationsschloss, die das von ihm gehaltene Objekt freisetzt, während die Methode rief () die Sperre nicht freigibt.
Das folgende Beispiel zeigt, dass Rendite () das Schloss nicht freigibt:
public class renditeLockTest {private statische Objekt obj = new Object (); public static void main (String [] args) {threada t1 = new threada ("t1"); Threada t2 = new threada ("t2"); t1.start (); t2.Start (); } statische Klasse Threada erweitert Thread {public threada (String name) {super (name); } public void run () {// synchronisiert (obj) {für (int i = 0; i <10; i ++) {System.out.printf ("%s [%d]:%d/n", this.getName (), this.getPriority (), i); // Wenn ich durch 4 geteilt wird, rufen Sie Rendite an, wenn (i%4 == 0) Thread.yield (); }}}}}} (Einmal) Ergebnis:
t1 [5]:0t1 [5]:1t1 [5]:2t1 [5]:3t1 [5]:4t1 [5]:5t1 [5]:6t1 [5]:7t1 [5]:8t1 [5]:9t2 [5]:0t2 [5]:1t2 [5]:2t2 [5]:3t2 [5]:4t2 [5]:5t2 [5]: 6t2 [5]: 7t2 [5]: 8t2 [5]: 9
Ergebnisse Beschreibung:
Zwei Threads T1 und T2 werden in der Hauptfaden -Haupthauptung gestartet. T1 und T2 beziehen sich auf die Synchronisationsschloss desselben Objekts in Run (), dh synchronisiert (OBJ). Während der T1 -Operation ruft es Thread.yield () an; T2 erhält keine CPU -Ausführungsrechte. Weil T1 das "Synchronous Lock von Obj gehalten" nicht freigibt!
Fadenschlaf: Schlaf ()
Sleep () ist in Thread.java definiert.
Die Funktion von Sleep () besteht darin, den aktuellen Fadenschlafen zu lassen, dh der aktuelle Thread wird vom "Laufstatus" zum "Schlaf (Blockierung)" eingebracht. Sleep () gibt die Schlafzeit an, und die Schlafzeit der Fäden ist größer als/gleich der Schlafzeit. Wenn der Thread erneut geweckt wird, wechselt er von einem "Blockierstatus" in einen "readigen Zustand" und wartet darauf, dass die CPU ausgeführt wird.
Beispiel:
Klasse Threada erweitert Thread {public threada (String name) {Super (name); } public synchronisierte void run () {try {for (int i = 0; i <10; i ++) {System.out.printf (" %s: %d/n", this.getName (), i); // Wenn ich durch 4 geteilt werden kann, schlafen Sie für 100 ms, wenn (i%4 == 0) Thread.Sleep (100); }} catch (interruptedException e) {e.printstacktrace (); }}} public class sleepest {public static void main (String [] args) {threada t1 = new threada ("t1"); t1.start (); }} Auslaufergebnisse:
T1: 0T1: 1T1: 2T1: 3T1: 4T1: 5T1: 6T1: 7T1: 8T1: 9
Ergebnisse Beschreibung:
Das Programm ist relativ einfach, starten Sie Thread T1 in der Hauptfaden -Haupthaupt. Nach dem Beginn von T1, wenn die Berechnung I in T1 durch 4 teilbar sein kann, schläft T1 100 Millisekunden durch Thread. Sleep (100).
Vergleich von Sleep () und Wait ():
Wir wissen, dass die Funktion von Wait () darin besteht, dass der aktuelle Thread den "Waiting (Blocking) aus dem" Laufstatus "eingeben und auch die Synchronisationsschloss freigeben kann. Die Funktion von Sleep () besteht darin, den aktuellen Thread in den" Schlafstatus "(Blocking) aus dem" Laufstatus "einzugeben.
Wait () veröffentlicht jedoch die Synchronisationsschloss des Objekts, während der Schlaf () das Schloss nicht freigibt.
Das folgende Beispiel zeigt, dass Sleep () das Schloss nicht freigeben wird.
öffentliche Klasse SleeplockTest {private static Object obj = new Object (); public static void main (String [] args) {threada t1 = new threada ("t1"); Threada t2 = new threada ("t2"); t1.start (); t2.Start (); } statische Klasse Threada erweitert Thread {public threada (String name) {super (name); } public void run () {// Die Synchronisationsschloss des Objekts Objekt synchronisiert (obj) {try {for (int i = 0; i <10; i ++) {System.out.printf (" %s: %d/n", this.getName (), i); // Wenn ich durch 4 geteilt werden kann, schlafen Sie für 100 ms, wenn (i%4 == 0) Thread.Sleep (100); }} catch (interruptedException e) {e.printstacktrace (); }}}}}}}}}} Auslaufergebnisse:
T1: 0T1: 1T1: 2T1: 3T1: 4T1: 5T1: 6T1: 7T1: 8T1: 9T2: 0T2: 1T2: 2T2: 3T2: 4T2: 5T2: 6T2: 7T2: 8T2: 9
Ergebnisse Beschreibung:
Zwei Threads T1 und T2 werden in der Hauptfaden -Haupthauptung gestartet. T1 und T2 beziehen sich auf die Synchronisationsschloss desselben Objekts in Run (), dh synchronisiert (OBJ). Während des T1 -Laufens, obwohl es Thread.Sleep (100) nennt; T2 erhält keine CPU -Ausführungsrechte. Weil T1 das "Synchronous Lock von Obj gehalten" nicht freigibt!
Beachten Sie, dass T1 und T2, wenn wir Synchronized (OBJ) ausgeben und das Programm erneut ausführen, zueinander umgestellt werden können. Das Folgende ist der Quellcode nach der Synchronisierung der Kommentarstunde (OBJ):
öffentliche Klasse SleeplockTest {private static Object obj = new Object (); public static void main (String [] args) {threada t1 = new threada ("t1"); Threada t2 = new threada ("t2"); t1.start (); t2.Start (); } statische Klasse Threada erweitert Thread {public threada (String name) {super (name); } public void run () {// Die Synchronisationsschloss des OBJ -Objekts erhalten // synchronisiert (obj) {try {for (int i = 0; i <10; i ++) {System.out.printf (" %s: %d/n", thet.getName (), i); // Wenn ich durch 4 geteilt werden kann, schlafen Sie für 100 ms, wenn (i%4 == 0) Thread.Sleep (100); }} catch (interruptedException e) {e.printstacktrace (); } //}}}}