Diferencia entre el método de suspensión y rendimiento en Java

En java, si un subproceso no desea realizar ninguna operación durante un período de tiempo determinado, debemos utilizar el método sleep(), que hace que el subproceso que se está ejecutando se detenga durante el número especificado de milisegundos.

Sintaxis:

public static native void sleep( long ms) throws InterruptedException ;
// The above method put the thread in sleep for a specified number of millisecond

public static void sleep(long ms , int ns) throws InterruptedException
// The above method also put the thread in sleep for a specified number of milliseconds
// plus specified number of nanoseconds

Método 1: método sleep()

Cada método sleep() en Java lanza una InterruptedException que es una excepción verificada, por lo tanto, siempre que estemos usando el método de suspensión obligatorio, debemos manejarlo mediante try-catch o mediante la palabra clave throws; de lo contrario, obtendremos un error de tiempo de compilación.

Implementación: aquí, ponemos el hilo principal en suspensión durante 5 segundos después de la declaración » println «. Entonces, cada diapositiva tarda 5 segundos en imprimirse.

Ejemplo

// Java Program to illustrate sleep method
 
// Importing all input output classes
import java.io.*;
// Importing all utility classes from
// java.util package
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // Iterating using simple for loops
        for (int i = 0; i <= 10; i++) {
 
            // Printing the current thread slide
            System.out.println("slide-" + i);
 
            // Putting the main thread to sleep for 5 second
            Thread.sleep(5000);
        }
 
        // Here after every  5 seconds a slide will be
        // printed
    }
}

Producción:

Nota: Aquí, la diapositiva 1 se imprimirá después de la diapositiva 0 después de 5000 nanosegundos, así que aplique para el resto de todas las diapositivas. Por lo tanto, esta salida se mostrará tardando un cierto tiempo en ejecutarse en el estado de tiempo de ejecución.

Método 2: método de rendimiento  ()

Hace que se detenga el subproceso que se está ejecutando actualmente para dar la oportunidad a un subproceso en espera de la misma prioridad. Si no hay subprocesos en espera o todos los subprocesos en espera tienen baja prioridad, el mismo subproceso puede continuar con su ejecución. Si varios subprocesos están esperando con la misma prioridad, entonces qué subproceso en espera tendrá la oportunidad, no podemos decir que depende del programador de subprocesos. El subproceso que se produce cuando tendrá la oportunidad una vez más también depende del programador de subprocesos. 

Sintaxis:

public static native void yield( );

Implementación:

Ejemplo

// Java Program to illustrate yield() method
 
// Importing input output classes
import java.io.*;
// Importing all utility classes
import java.util.*;
 
// Class 1
// Helper class extending Thread class
 
// Creating a thread in our myThread class
// by extending the Thread class
 
class myThread extends Thread {
 
    // Method in helper class
    // Declaring run method
    public void run()
    {
 
        // Displaying the message
        System.out.println("Child Thread");
 
        // Calling yield() method
        Thread.yield();
    }
}
 
// Class 2
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
        throws InterruptedException
    {
 
        // Creating a thread object in the main() method
        // of our helper class above
        myThread t = new myThread();
 
        // Starting the above thread created
        // using the start() method
        t.start();
 
        // Iterating using for loop
        // over custom taken size equals 5
        for (int i = 0; i < 5; i++) {
            // Display message
            System.out.println("Main Thread");
        }
    }
}

 Explicación de salida:

En el programa anterior, si estamos comentando la línea Thread.yield(), ambos subprocesos se ejecutarán simultáneamente, y no podemos esperar qué subproceso se completará primero. Si no estamos comentando el método Thread.yield() , entonces debido a que el hilo principal tendrá una oportunidad más veces y la posibilidad de completar el hilo principal primero es alta.

Así que finalmente hemos terminado con ambos métodos, finalmente concluyamos las diferencias entre ellos.