Hilos verdes vs nativos y métodos obsoletos en Java

Un proceso de subprocesos múltiples, como todos sabemos, tiene varias secuencias de control, donde cada secuencia está gobernada por un subproceso y es capaz de realizar tareas independientes al mismo tiempo.

En Java, el concepto de subprocesos múltiples se implementa mediante el uso de los siguientes dos modelos.
1. Modelo de hilo verde
2. Modelo de hilo nativo

Modelo de hilo verde

• En este modelo, JVM administra completamente los subprocesos sin ningún tipo de soporte de sistema operativo subyacente.
• Estos subprocesos se implementan en el nivel de la aplicación y se administran en el espacio del usuario.
• También se denominan subprocesos cooperativos (a nivel de usuario).
• Solo se puede procesar un subproceso verde a la vez. Por lo tanto, este modelo se considera el modelo muchos a uno . Debido a esto, los subprocesos verdes pueden ejecutarse en procesadores de múltiples núcleos pero no pueden aprovechar los múltiples núcleos.
• La sincronización y el uso compartido de recursos son más fáciles para los subprocesos verdes y, por lo tanto, el tiempo de ejecución también es menor.
• Sun Solaris OS brinda soporte para el modelo Green Thread.

Modelo de hilo nativo

• Los subprocesos en este modelo son administrados por la JVM con la ayuda del soporte del sistema operativo subyacente.
• Estos subprocesos se implementan a nivel del sistema operativo (mediante el uso de la API de subprocesos múltiples del sistema operativo) y se administran en el espacio del kernel.
• También se denominan subprocesos no verdes (a nivel de kernel).
• Pueden coexistir varios subprocesos nativos. Por lo tanto, también se le llama modelo de muchos a muchos . Esta característica de este modelo le permite aprovechar al máximo los procesadores multinúcleo y ejecutar subprocesos en núcleos individuales separados al mismo tiempo.
• Dado que este modelo permite que se ejecuten múltiples subprocesos simultáneamente, la sincronización de subprocesos y el uso compartido de recursos se vuelven complicados. Esto aumenta el tiempo de ejecución de los hilos.
• Todos los sistemas operativos basados ​​en Windows brindan soporte para el modelo Native Thread.

Debido a sus limitaciones, el modelo Green Thread está obsoleto y ya no se usa. El modelo Native Thread ha reemplazado al modelo Green Thread y se usa ampliamente en la actualidad.

Aparte de esto, la clase Thread en Java tiene algunos métodos que están en desuso.

1. public void stop()
   Este método está en desuso porque su uso es intrínsecamente inseguro. Por ejemplo, suponga que un subproceso ha abierto un archivo y está escribiendo en él. De repente, si llamamos al método stop() en este subproceso, el subproceso terminará abruptamente y el archivo permanecerá abierto.
   Esto se considera potencialmente inseguro. Por lo tanto, usamos la comunicación entre subprocesos y el sistema de interrupción para indicar a un subproceso que detenga su ejecución durante algún tiempo en lugar de forzar al subproceso a detener su ejecución.
2. public void
   suspend() El método Thread.suspend() está en desuso porque es propenso a interbloqueos. Considere un ejemplo en el que un subproceso principal mantiene un bloqueo en un objeto y ese subproceso está suspendido. Ningún otro subproceso puede obtener ese bloqueo de nivel de objeto hasta que se reanude ese subproceso. Si un subproceso secundario intenta adquirir el bloqueo de ese objeto antes de que se reanude el subproceso principal, existe una situación de interbloqueo.
3. public void resume()
   Dado que el método suspend() está en desuso, el método resume() también está en desuso.

El siguiente ejemplo ilustra cómo el uso del método suspend() puede conducir a un punto muerto.

// Printer class
class Printer {
  
    // synchronized print() method
    public synchronized void print()
    {
        System.out.println(Thread.currentThread().getName() + 
                                           " wants to print");
  
        // making sure that primary thread is getting suspended
        if (Thread.currentThread().getName().equals("Primary Thread")) {
            System.out.println("Primary Thread has been suspended");
            Thread.currentThread().suspend();
            System.out.println("Primary Thread has been resumed");
        }
  
        System.out.println(Thread.currentThread().getName()
                           + " has finished printing");
    }
}
  
// Custom Thread class that extends Thread class
class CustomThread extends Thread {
    // string variable that will store name of the thread
    Printer obj;
  
    // constructor to initialize thread object
    CustomThread(String name, Printer p)
    {
        // calling Thread class constructor and naming
        // the thread
        super(name);
        obj = p;
    }
  
    // overridden run() method
    public void run()
    {
        // calling synchronized print() method
        obj.print();
  
        // printing a statement that confirms the 
        // end of execution of the thread
        System.out.println(this.getName() + 
                      " has finished its execution");
    }
}
  
// Driver class
class Deadlock {
    // Main method which thros InterruptedException 
    // that can be caused as we are calling sleep() method
    public static void main(String[] args) throws InterruptedException
    {
        // Creating Printer object in order to print
        Printer p = new Printer();
  
        // Creating primary thread and starting its execution
        CustomThread primary_thread = new CustomThread("Primary Thread", p);
        System.out.println("Primary Thread is starting its execution");
        primary_thread.start();
  
        // Making main thread to sleep for 1 second to make sure that
        // primary thread executes print() method and goes into suspend state
        Thread.sleep(2000);
  
        // Creating secondary thread and starting its execution
        CustomThread secondary_thread = new CustomThread("Secondary Thread", p);
        System.out.println("Secondary Thread is starting its execution");
        secondary_thread.start();
    }
}

Producción:

Primary Thread is starting its execution
Primary Thread wants to print
Primary Thread has been suspended
Secondary Thread is starting its execution

Explicación:
En el programa anterior, creamos dos subprocesos llamados subproceso primario y subproceso secundario e iniciamos ambos subprocesos en el orden respectivo después de un intervalo de tiempo de 2 segundos.

El subproceso principal se ejecuta primero y se suspende mientras se ejecuta el método print(). Posee el bloqueo del objeto de la clase Impresora mientras permanece en estado suspendido. Después de eso, el hilo secundario intenta ejecutar el método print(). Pero no puede ejecutarlo porque el bloqueo del objeto Printer está con el método principal.

En esta etapa, ambos subprocesos entran en estado de interbloqueo y la ejecución del programa nunca terminará. Podemos ver que solo se imprimen 4 declaraciones en la salida y el resto de las declaraciones no se imprimen porque la ejecución del programa entra en estado de punto muerto.

Referencias:

1. Modelos de subprocesos múltiples – Oracle Docs
2. Métodos de subprocesos en desuso – Oracle Docs