Concesiones de hilo: rendimiento ()
El propósito de rendimiento () es ceder. Puede permitir que el hilo actual ingrese al "estado listo" desde el "estado en ejecución", para que otros hilos de espera con la misma prioridad puedan obtener los derechos de ejecución; Sin embargo, no puede garantizar que después de que el subproceso actual las llamadas al rendimiento (), otros hilos con la misma prioridad definitivamente obtengan los derechos de ejecución; ¡También puede ser que el hilo actual ingrese al "estado en ejecución" y continúe funcionando!
Ejemplo:
La clase Thinda extiende el hilo {publicada public (nombre de cadena) {super (nombre); } public sincronizado void run () {for (int i = 0; i <10; i ++) {system.out.printf ("%s [%d]:%d/n", this.getName (), this.getPriority (), i); // Cuando me dividen por 4, llame al rendimiento si (i%4 == 0) thread.yield (); }}} clase pública de rendimiento de la clase {public static void main (string [] args) {thinda t1 = new thinda ("t1"); Thinta t2 = new thinda ("t2"); t1.start (); t2.start (); }} (Una vez) Resultado de la operación:
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] [5]: 6T2 [5]: 7T2 [5]: 8T2 [5]: 9
Descripción de los resultados:
Cuando "Subpuste T1" puede ser entero por 4, no cambia a "Subprota T2". Esto muestra que aunque el rendimiento () puede permitir que los subprocesos ingresen al "estado listo" del "estado en ejecución", no necesariamente permite que otros subprocesos obtengan los derechos de ejecución de la CPU (es decir, otros hilos ingresan al "estado en ejecución"), incluso si este "otro hilo" tiene la misma prioridad que el hilo que actualmente llama rendimiento ().
Comparación de rendimiento () y Wait ()::
Sabemos que la función de Wait () es permitir que el hilo actual ingrese al estado "Wait (Bloqueo) desde el" Estado en ejecución "y también libere el bloqueo de sincronización. La función de rendimiento () es ceder, lo que también hará que el hilo actual deje el" estado en ejecución ". Sus diferencias son:
(1) Wait () es dejar que el hilo ingrese al "Estado de espera (bloqueo)" del "Estado en ejecución", aunque no el rendimiento () es dejar que el hilo ingrese al "estado listo" desde el "estado en ejecución".
(2) Wait () es un bloqueo de sincronización que en el rostro de la liberación del objeto que posee, mientras que el método de rendimiento () no liberará el bloqueo.
El siguiente ejemplo muestra que el rendimiento () no liberará el bloqueo:
clase pública DownlodlockTest {objeto estático privado obj = nuevo objeto (); public static void main (string [] args) {thinda t1 = new thinda ("t1"); Thinta t2 = new thinda ("t2"); t1.start (); t2.start (); } La clase Static Thinda extiende el hilo {publicada public (nombre de cadena) {super (nombre); } public void run () {// Get sincronizado (obj) {for (int i = 0; i <10; i ++) {System.out.printf ("%s [%d]:%d/n", this.getName (), this.getpriority (), i); // Cuando me dividen por 4, llame al rendimiento si (i%4 == 0) thread.yield (); }}}}}} (Una vez) resultado:
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] [5]: 6T2 [5]: 7T2 [5]: 8T2 [5]: 9
Descripción de los resultados:
Se inician dos hilos T1 y T2 en el hilo principal principal. T1 y T2 se referirán al bloqueo de sincronización del mismo objeto en run (), es decir, sincronizado (obj). Durante la operación T1, aunque llamará a Thread.yield (); T2 no obtendrá los derechos de ejecución de la CPU. ¡Porque T1 no libera el "bloqueo sincrónico en poder de OBJ"!
Sleep de hilo: dormir ()
Sleep () se define en Thread.java.
La función de Sleep () es dejar que el hilo actual duerma, es decir, el hilo actual entrará desde el "estado en ejecución" al "bloqueo (bloqueo)". Sleep () especificará el tiempo de sueño, y el tiempo de sueño del hilo será mayor que/igual al tiempo de sueño; Cuando el hilo se despierta nuevamente, cambiará de un "estado de bloqueo" a un "estado listo", esperando que la CPU sea programada para ejecutar.
Ejemplo:
La clase Thinda extiende el hilo {publicada public (nombre de cadena) {super (nombre); } public sincronizado void run () {try {for (int i = 0; i <10; i ++) {System.out.printf (" %s: %d/n", this.getName (), i); // Cuando pueda dividirme por 4, duerme por 100 ms si (i%4 == 0) hilo. Sleep (100); }} catch (InterruptedException e) {E.PrintStackTrace (); }}} public class SleepTest {public static void main (string [] args) {thinda t1 = new thinda ("t1"); t1.start (); }} Resultados de ejecución:
T1: 0T1: 1T1: 2T1: 3T1: 4T1: 5T1: 6T1: 7T1: 8T1: 9
Descripción de los resultados:
El programa es relativamente simple, inicie el hilo T1 en el hilo principal principal. Después de comenzar T1, cuando el cálculo I en T1 puede ser divisible por 4, T1 dormirá durante 100 milisegundos a través de hilos.
Comparación de Sleep () y Wait ():
Sabemos que la función de Wait () es permitir que el hilo actual ingrese al estado "Wait (Bloqueo) desde el" Estado en ejecución "y también libere el bloqueo de sincronización. La función de Sleep () es dejar que el hilo actual ingrese al" Estado de sueño (bloqueo) "del" Estado en ejecución ".
Sin embargo, Wait () libera el bloqueo de sincronización del objeto, mientras que Sleep () no libera el bloqueo.
El siguiente ejemplo muestra que Sleep () no liberará el bloqueo.
clase pública SleepLockTest {objeto estático privado obj = nuevo objeto (); public static void main (string [] args) {thinda t1 = new thinda ("t1"); Thinta t2 = new thinda ("t2"); t1.start (); t2.start (); } La clase Static Thinda extiende el hilo {publicada public (nombre de cadena) {super (nombre); } public void run () {// Obtenga el bloqueo de sincronización del objeto obj sincronizado (obj) {try {for (int i = 0; i <10; i ++) {system.out.printf (" %s: %d/n", this.getName (), i); // Cuando pueda dividirme por 4, duerme por 100 ms si (i%4 == 0) hilo. Sleep (100); }} catch (InterruptedException e) {E.PrintStackTrace (); }}}}}}}}} Resultados de ejecución:
T1: 0T1: 1T1: 2T1: 3T1: 4T1: 5T1: 6T1: 7T1: 8T1: 9T2: 0T2: 1T2: 2T2: 3T2: 4T2: 5T2: 6T2: 7T2: 8T2: 9: 9: 9:
Descripción de los resultados:
Se inician dos hilos T1 y T2 en el hilo principal principal. T1 y T2 se referirán al bloqueo de sincronización del mismo objeto en run (), es decir, sincronizado (obj). Durante la ejecución de T1, aunque llamará a Thread.Sleep (100); T2 no obtendrá los derechos de ejecución de la CPU. ¡Porque T1 no libera el "bloqueo sincrónico en poder de OBJ"!
Tenga en cuenta que si comentamos sincronizado (OBJ) y ejecutamos el programa nuevamente, T1 y T2 pueden cambiarse entre sí. El siguiente es el código fuente después de que la melodía de comentarios sincronizada (OBJ):
clase pública SleepLockTest {objeto estático privado obj = nuevo objeto (); public static void main (string [] args) {thinda t1 = new thinda ("t1"); Thinta t2 = new thinda ("t2"); t1.start (); t2.start (); } La clase Static Thinda extiende el hilo {publicada public (nombre de cadena) {super (nombre); } public void run () {// Obtenga el bloqueo de sincronización del objeto obj // sincronizado (obj) {try {for (int i = 0; i <10; i ++) {system.out.printf (" %s: %d/n", this.getName (), i); // Cuando pueda dividirme por 4, duerme por 100 ms si (i%4 == 0) hilo. Sleep (100); }} catch (InterruptedException e) {E.PrintStackTrace (); } //}}}}