Subprocesos de Java

Por lo general, podemos definir subprocesos como un subproceso con peso ligero con la unidad de procesos más pequeña y también tiene rutas de ejecución separadas. Estos subprocesos usan memoria compartida pero actúan de forma independiente, por lo tanto, si hay una excepción en los subprocesos que no afectan el funcionamiento de otros subprocesos a pesar de que comparten la misma memoria. 

Subprocesos en un entorno de memoria compartida en el sistema operativo

Como podemos observar en el diagrama anterior, un subproceso se ejecuta dentro del proceso y habrá un cambio entre subprocesos basado en el contexto; puede haber múltiples procesos ejecutándose en el sistema operativo, y cada proceso nuevamente puede tener múltiples subprocesos ejecutándose simultáneamente. El concepto de subprocesos múltiples se aplica popularmente en juegos, animación, etc.

El concepto de multitarea

Para ayudar a los usuarios, el sistema operativo les da a los usuarios el privilegio de realizar múltiples tareas, donde los usuarios pueden realizar múltiples acciones simultáneamente en la máquina. Esta multitarea se puede habilitar de dos formas: 

1. Multitarea basada en procesos 
2. Multitarea basada en subprocesos 

1. Multitarea basada en procesos (multiprocesamiento)

En este tipo de multitarea, los procesos son pesados ​​y cada proceso fue asignado por un área de memoria separada. Y como el proceso es de gran peso el costo de comunicación entre procesos es alto y toma mucho tiempo cambiar entre procesos ya que involucra acciones como cargar, guardar en registros, actualizar mapas, listas, etc. 

2. Multitarea basada en subprocesos 

Como discutimos anteriormente, los subprocesos se proporcionan con una naturaleza liviana y comparten el mismo espacio de direcciones, y el costo de comunicación entre subprocesos también es bajo. 

¿Por qué se utilizan hilos? 

Ahora, podemos entender por qué se utilizan subprocesos, ya que tenían la ventaja de ser livianos y pueden proporcionar comunicación entre múltiples subprocesos a un bajo costo, lo que contribuye a la realización de múltiples tareas en un entorno de memoria compartida. 

Ciclo de vida del hilo

Hay diferentes estados a los que se transfiere el subproceso durante su vida útil, infórmenos sobre esos estados en las siguientes líneas: en su vida útil, un hilo pasa por los siguientes estados, a saber: 

1. nuevo estado
2. Estado activo
3. Estado de espera/bloqueado
4. Estado de espera temporizado
5. Estado Terminado

Podemos ver el funcionamiento de diferentes estados en un subproceso en el diagrama anterior, háganos saber en detalle todos y cada uno de los estados: 

1. Nuevo Estado 

De forma predeterminada, un subproceso estará en un nuevo estado, en este estado, el código aún no se ha ejecutado y el proceso de ejecución aún no se ha iniciado. 

2. Estado activo

Un subproceso que es un estado nuevo por defecto se transfiere al estado activo cuando invoca el método start(), su estado activo contiene dos subestados, a saber:

• Estado ejecutable: en este estado, el subproceso está listo para ejecutarse en cualquier momento y es el trabajo del programador de subprocesos proporcionar el tiempo de subproceso para los subprocesos conservados en estado ejecutable. Un programa que ha obtenido Multithreading comparte porciones de intervalos de tiempo que se comparten entre subprocesos, por lo tanto, estos subprocesos se ejecutan durante un breve período de tiempo y esperan en el estado ejecutable para obtener sus horarios por porción de un intervalo de tiempo.
• Estado de ejecución: cuando el subproceso recibe la CPU asignada por el Programador de subprocesos, se transfiere del estado «Ejecutable» al estado «En ejecución». y después de la expiración de su sesión de intervalo de tiempo dado, vuelve a moverse al estado «Ejecutable» y espera su próximo intervalo de tiempo.

3. Estado de espera/bloqueado 

Si un subproceso está inactivo pero en un tiempo temporal, entonces está en estado de espera o bloqueado, por ejemplo, si hay dos subprocesos, T1 y T2 donde T1 necesita comunicarse con la cámara y otro subproceso T2 ya está usando una cámara para escanee, luego T1 espera hasta que T2 Thread complete su trabajo, en este estado, T1 está estacionado esperando el estado, y en otro escenario, el usuario llamó a dos Threads T2 y T3 con la misma funcionalidad y ambos tenían el mismo intervalo de tiempo dado por Thread Scheduler entonces ambos subprocesos T1, T2 están en un estado bloqueado. Cuando hay varios subprocesos estacionados en estado Bloqueado/En espera, el programador de subprocesos borra la cola al rechazar los subprocesos no deseados y asignar la CPU según la prioridad. 

4. Estado de espera temporizado

A veces, la mayor duración de la espera de subprocesos provoca inanición, si tomamos un ejemplo como si hubiera dos subprocesos T1, T2 esperando CPU y T1 está experimentando una operación de codificación crítica y si no sale de la CPU hasta que se ejecuta su operación, entonces T2 será expuesto a una espera más larga con certeza indeterminada. Para evitar esta situación de inanición, tuvimos una espera temporizada para el estado para evitar ese tipo de escenario como en la espera temporizada, cada subproceso tiene un período de tiempo durante el cual se invoca el método sleep() y después el tiempo expira, los subprocesos comienzan a ejecutar su tarea. 

5. Estado rescindido

Un subproceso estará en estado Terminado, debido a las siguientes razones: 

• La terminación la logra un Thread cuando termina su tarea normalmente.
• A veces, los subprocesos pueden terminar debido a eventos inusuales como fallas de segmentación, excepciones, etc. y tal tipo de Terminación puede denominarse Terminación Anormal.
• Un subproceso terminado significa que está muerto y ya no está disponible.

¿Qué es el hilo principal? 

Como estamos familiarizados, creamos el método principal en todos y cada uno de los programas Java, que actúa como un punto de entrada para que JVM ejecute el código. De manera similar, en este concepto de subprocesos múltiples, cada programa tiene un subproceso principal que fue proporcionado por defecto por JVM, por lo tanto, cada vez que se crea un programa en Java, JVM proporciona el subproceso principal para su ejecución. 

¿Cómo crear subprocesos utilizando el lenguaje de programación Java? 

Podemos crear subprocesos en Java de dos maneras, a saber: 

1. Extendiendo Thread Class
2. Mediante la implementación de una interfaz ejecutable

1. Al extender la clase de subprocesos 

Podemos ejecutar Threads en Java utilizando Thread Class, que proporciona constructores y métodos para crear y realizar operaciones en un Thread, que amplía una clase Thread que puede implementar Runnable Interface. Usamos los siguientes constructores para crear el hilo: 

• Hilo
• Subproceso (ejecutable r)
• Subproceso (nombre de la string)
• Subproceso (nombre de string, Runnable r)

Ejemplo de código para crear subprocesos mediante la extensión de la clase de subprocesos: 

import java.io.*;
import java.util.*;
 
public class GFG extends Thread {
      // initiated run method for Thread
    public void run()
    {
        System.out.println("Thread Started Running...");
    }
    public static void main(String[] args)
    {
        GFG g1 = new GFG();
          // invoking Thread
        g1.run();
    }
}

Thread Started Running...

 Ejemplo de código para crear un subproceso mediante el uso de la interfaz ejecutable:  

import java.io.*;
import java.util.*;
 
public class GFG implements Runnable {
      // method to start Thread
    public void run()
    {
        System.out.println(
            "Thread is Running Successfully");
    }
 
    public static void main(String[] args)
    {
        GFG g1 = new GFG();
        // initializing Thread Object
        Thread t1
            = new Thread(g1);
        t1.run();
    }
}

Thread is Running Successfully

 Código de muestra para crear Thread en Java usando Thread (String name): 

import java.io.*;
import java.util.*;
 
public class GFG {
    public static void main(String args[])
    {
        // Thread object created
          // and initiated with data
        Thread t = new Thread("Hello Geeks!");
 
        // Thread gets started
        t.start();
 
        // getting data of
          // Thread through String
        String s = t.getName();
        System.out.println(s);
    }
}

Hello Geeks!

 Ejemplo de código Java que crea un objeto Thread mediante el uso de Thread (Runnable r, String name): 

import java.io.*;
import java.util.*;
 
public class GFG implements Runnable {
    public void run()
    {
        System.out.println(
            "Thread is created and running successfully...");
    }
    public static void main(String[] args)
    {
        // aligning GFG Class with
          // Runnable interface
        Runnable r1 = new GFG();
        Thread t1 = new Thread(r1, "My Thread");
        // Thread object started
        t1.run();
        // getting the Thread
          // with String Method
        String str = t1.getName();
        System.out.println(str);
    }
}

My Thread
Thread is created and running successfully...

Programa Java para explorar diferentes estados de subprocesos: 

Veamos el funcionamiento de los estados de subprocesos al implementarlos en los subprocesos t1 y t2. 

Producción:

import java.io.*;
import java.util.*;
 
class GFG implements Runnable {
    public void run()
    {
        // implementing try-catch Block to set sleep state
        // for inactive thread
        try {
            Thread.sleep(102);
        }
        catch (InterruptedException i1) {
            i1.printStackTrace();
        }
        System.out.println(
            "The state for t1 after it invoked join method() on thread t2"
            + " " + ThreadState.t1.getState());
 
        // implementing try-catch block
        try {
            Thread.sleep(202);
        }
        catch (InterruptedException i2) {
            i2.printStackTrace();
        }
    }
}
 
// creation of ThreadState class
// to implement Runnable interface
public class ThreadState implements Runnable {
    public static Thread t1;
    public static ThreadState o1;
    public static void main(String args[])
    {
        o1 = new ThreadState();
        t1 = new Thread(o1);
        System.out.println("post-spanning, state of t1 is"
                           + " " + t1.getState());
        // lets invoke start() method on t1
        t1.run();
        // Now,Thread t1 is moved to runnable state
        System.out.println(
            "post invoking of start() method, state of t1 is"
            + " " + t1.getState());
    }
    public void run()
    {
        GFG g1 = new GFG();
        Thread t2 = new Thread(g1);
        // Thread is created and its in new state.
        t2.run();
        // Now t2 is moved to runnable state
        System.out.println(
            "state of t2 Thread, post-calling of start() method is"
            + " " + t2.getState());
        // create a try-catch block to set t1 in waiting
        // state
        try {
            Thread.sleep(202);
        }
        catch (InterruptedException i2) {
            i2.printStackTrace();
        }
        System.out.println(
            "State of Thread t2 after invoking to method sleep() is"
            + " " + t2.getState());
        try {
            t2.join();
        }
        catch (InterruptedException i3) {
            i3.printStackTrace();
        }
        System.out.println(
            "state of Thread t2 after completing the execution is"
            + " " + t1.getState());
    }
}

post-spanning, state of t1 is NEW
The state for t1 after it invoked join method() on thread t2 NEW
state of t2 Thread, post-calling of start() method is NEW
State of Thread t2 after invoking to method sleep() is NEW
state of Thread t2 after completing the execution is NEW
post invoking of start() method, state of t1 is NEW