subprocesos múltiples en Java

Cualquier aplicación puede tener múltiples procesos (instancias). Cada uno de estos procesos puede asignarse como un único subproceso o como varios subprocesos. En este tutorial veremos cómo realizar múltiples tareas al mismo tiempo y también aprenderemos más sobre subprocesos y sincronización entre subprocesos.

¿Qué es un hilo único?

Un solo hilo en Java Es básicamente una unidad de procesamiento liviana y la más pequeña. Java utiliza subprocesos mediante una “Clase de subproceso”. Hay dos tipos de subprocesos: hilo de usuario y hilo de demonio (Los subprocesos de demonio se utilizan cuando queremos limpiar la aplicación y se utilizan en segundo plano). Cuando se inicia una aplicación por primera vez, se crea un subproceso de usuario. Después de eso, podemos crear muchos subprocesos de usuario y subprocesos de demonio.

Ejemplo de hilo único:

package demotest;

public class GuruThread
{
       public static void main(String[] args) {
              System.out.println("Single Thread");
       }
}

Ventajas del hilo único:

• Reduce la sobrecarga en la aplicación ya que se ejecuta un solo subproceso en el sistema.
• Además, reduce el coste de mantenimiento de la aplicación.

Ejemplo de hilo múltiple:

package demotest;
public class GuruThread1 implements Runnable
{
       public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
    }
}

Ventajas del multiproceso:

• Los usuarios no están bloqueados porque los hilos son independientes y podemos realizar múltiples operaciones a la vez.
• Como tal, los subprocesos son independientes, los otros subprocesos no se verán afectados si un subproceso cumple con una excepción.

Ciclo de vida del hilo en Java

El ciclo de vida de un hilo:

Hay varias etapas del ciclo de vida del hilo, como se muestra en el diagrama anterior:

1. New
2. Ejecutable
3. Correr
4. Esperando
5. Muertos

1. Nuevo: En esta fase, el hilo se crea utilizando la clase "Clase de hilo". Permanece en este estado hasta que el programa comienza la amenaza. También se le conoce como hilo nacido.
2. Ejecutable: En esta página, la instancia del hilo se invoca con un método de inicio. El control del hilo se le da al programador para finalizar la ejecución. Depende del programador si se debe ejecutar el hilo.
3. Corriendo: Cuando el hilo comienza a ejecutarse, el estado cambia al estado "en ejecución". El programador selecciona un subproceso del grupo de subprocesos y comienza a ejecutarse en la aplicación.
4. Esperando: Este es el estado en el que un subproceso debe esperar. Como hay varios subprocesos ejecutándose en la aplicación, es necesario que haya sincronización entre ellos. Por lo tanto, un subproceso debe esperar hasta que se ejecute el otro. Por lo tanto, este estado se denomina estado de espera.
5. Muerto: Este es el estado en el que finaliza el hilo. El hilo está en estado de ejecución y tan pronto como completa el procesamiento, está en "estado muerto".

Métodos de multiprocesamiento en Java

Algunos de los métodos comúnmente utilizados para subprocesos son:

Método	Mareas Ideales para Lecciones
comienzo()	Este método inicia la ejecución del hilo y JVM llama al método run() en el hilo.
Dormir (int milisegundos)	Este método hace que el subproceso se suspenda, por lo que su ejecución se pausará durante los milisegundos que se indiquen y, luego, el subproceso comenzará a ejecutarse nuevamente. Esto ayuda a sincronizar los subprocesos.
getName ()	Devuelve el nombre del hilo.
establecerPrioridad(int nuevaprioridad)	Cambia la prioridad del hilo.
producir ()	Hace que el hilo actual se detenga y se ejecuten otros hilos.

Ejemplo: En este programa multiproceso en Java Por ejemplo, vamos a crear un hilo y explorar los métodos integrados disponibles para los hilos.

package demotest;
public class thread_example1 implements Runnable {
    @Override
    public void run() {
    }
    public static void main(String[] args) {
        Thread guruthread1 = new Thread();
        guruthread1.start();
        try {
            guruthread1.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        guruthread1.setPriority(1);
        int gurupriority = guruthread1.getPriority();
        System.out.println(gurupriority);
        System.out.println("Thread Running");
  }
}

Explicación del código:

• Code Línea 2: Estamos creando una clase "thread_Example1" que implementa la interfaz Runnable (debe ser implementada por cualquier clase cuyas instancias estén destinadas a ser ejecutadas por el hilo).
• Code Línea 4: Anula el método de ejecución de la interfaz ejecutable, ya que es obligatorio anular ese método.
• Code Línea 6: Aquí hemos definido el método principal en el que iniciaremos la ejecución del hilo.
• Code Línea 7: Aquí estamos creando un nuevo nombre de hilo como "guruthread1" al crear una instancia de una nueva clase de hilo.
• Code Línea 8: Usaremos el método "inicio" del hilo usando la instancia "guruthread1". Aquí el hilo comenzará a ejecutarse.
• Code Línea 10: Aquí estamos usando el método "dormir" del hilo usando la instancia "guruthread1". Por lo tanto, el hilo dormirá durante 1000 milisegundos.
• Code 9-14: Aquí hemos puesto el método de suspensión en el bloque try catch ya que se produce una excepción marcada, es decir, una excepción interrumpida.
• Code Línea 15: Aquí estamos configurando la prioridad del hilo en 1, cualquiera que sea la prioridad que tuviera.
• Code Línea 16: Aquí obtenemos la prioridad del hilo usando getPriority()
• Code Línea 17: Aquí estamos imprimiendo el valor obtenido de getPriority
• Code Línea 18: Aquí estamos escribiendo un texto que el hilo se está ejecutando.

Cuando ejecuta el código anterior, obtiene el siguiente resultado:

Salida:

5 es la prioridad del subproceso y el subproceso en ejecución es el texto que es el resultado de nuestro código.

Java Hilo Synchronización

En el subprocesamiento múltiple, existe un comportamiento asincrónico de los programas. Si un subproceso escribe datos y otro subproceso los lee al mismo tiempo, puede generarse una inconsistencia en la aplicación. Cuando es necesario que dos o más subprocesos accedan a los recursos compartidos, se utiliza el enfoque de sincronización. Java ha proporcionado métodos sincronizados para implementar un comportamiento sincronizado.

En este enfoque, una vez que el subproceso llega al interior del bloque sincronizado, ningún otro subproceso puede llamar a ese método en el mismo objeto. Todos los subprocesos tienen que esperar hasta que ese subproceso finalice el bloque sincronizado y salga de él. De esta manera, la sincronización ayuda en una aplicación multiproceso. Un subproceso tiene que esperar hasta que otro subproceso finalice su ejecución y luego se permite la ejecución de los demás subprocesos.

Se puede escribir de la siguiente forma:

Synchronized(object)
{  
        //Block of statements to be synchronized
}

subprocesos múltiples en Java Programas de ejemplo

En este multihilo Java Por ejemplo, tomaremos dos hilos y buscaremos los nombres de los hilos.

Example1:

GuruThread1.java
package demotest;
public class GuruThread1 implements Runnable{

    /**
     * @param args
     */
    public static void main(String[] args) {
        Thread guruThread1 = new Thread("Guru1");
        Thread guruThread2 = new Thread("Guru2");
        guruThread1.start();
        guruThread2.start();
        System.out.println("Thread names are following:");
        System.out.println(guruThread1.getName());
        System.out.println(guruThread2.getName());
    }
    @Override
    public void run() {
    }
}

Explicación del código:

• Code Línea 3: Hemos tomado una clase “GuruThread1”, que implementa Runnable (debería ser implementada por cualquier clase cuyas instancias estén destinadas a ser ejecutadas por el hilo).
• Code Línea 8: Este es el método principal de la clase.
• Code Línea 9: Aquí estamos creando una instancia de la clase Thread y creando una instancia denominada "guruThread1" y creando un hilo.
• Code Línea 10: Aquí estamos creando una instancia de la clase Thread y creando una instancia llamada "guruThread2" y creando un hilo.
• Code Línea 11: Estamos iniciando el hilo, es decir, guruThread1.
• Code Línea 12: Estamos iniciando el hilo, es decir, guruThread2.
• Code Línea 13: Mostrar el texto como “Los nombres de los hilos son los siguientes:”
• Code Línea 14: Obtener el nombre del hilo 1 usando el método getName() de la clase de hilo.
• Code Línea 15: Obtener el nombre del hilo 2 usando el método getName() de la clase de hilo.

Cuando ejecuta el código anterior, obtiene el siguiente resultado:

Salida:

Los nombres de los hilos se muestran aquí como

• Guru1
• Guru2

Ejemplo 2:

En este subproceso múltiple en Java Por ejemplo, aprenderemos cómo anular los métodos run() y start() de una interfaz ejecutable y crearemos dos subprocesos de esa clase y los ejecutaremos en consecuencia.

Además, estamos tomando dos clases,

• Uno que implementará la interfaz ejecutable y
• Otro que tendrá el método principal y se ejecutará en consecuencia.

package demotest;
public class GuruThread2 {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  GuruThread3 threadguru1 = new GuruThread3("guru1");
  threadguru1.start();
  GuruThread3 threadguru2 = new GuruThread3("guru2");
  threadguru2.start();
 }
}
class GuruThread3 implements Runnable {
 Thread guruthread;
 private String guruname;
 GuruThread3(String name) {
  guruname = name;
 }
 @Override
 public void run() {
  System.out.println("Thread running" + guruname);
  for (int i = 0; i < 4; i++) {
   System.out.println(i);
   System.out.println(guruname);
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    System.out.println("Thread has been interrupted");
   }
  }
 }
 public void start() {
  System.out.println("Thread started");
  if (guruthread == null) {
   guruthread = new Thread(this, guruname);
   guruthread.start();
  }
 }
}

Explicación del código:

• Code Línea 2: Aquí estamos tomando una clase “GuruThread2”, que contendrá el método principal.
• Code Línea 4: Aquí estamos tomando un método principal de la clase.
• Code Línea 6-7: Aquí estamos creando una instancia de la clase GuruThread3 (que se crea en las siguientes líneas de código) como “threadguru1” y estamos iniciando el hilo.
• Code Línea 8-9: Aquí estamos creando otra instancia de la clase GuruThread3 (que se crea en las siguientes líneas de código) como “threadguru2” y estamos iniciando el hilo.
• Code Línea 11: Aquí estamos creando una clase “GuruThread3”, que implementa la interfaz ejecutable (debería ser implementada por cualquier clase cuyas instancias estén destinadas a ser ejecutadas por el hilo).
• Code Línea 13-14: Estamos tomando dos variables de clase de las cuales una es del tipo clase hilo y otra de clase cadena.
• Code Línea 15-18: estamos anulando el GuruEl constructor Thread3 toma un argumento de tipo cadena (que es el nombre del hilo) que se asigna a la variable de clase guruname y, por lo tanto, se almacena el nombre del hilo.
• Code Línea 20: Aquí estamos anulando el método run() de la interfaz ejecutable.
• Code Línea 21: Estamos generando el nombre del hilo usando la declaración println.
• Code Línea 22-31: Aquí estamos usando un bucle for con el contador inicializado a 0, y no debe ser menor que 4 (podemos tomar cualquier número, por lo tanto, aquí el bucle se ejecutará 4 veces) e incrementamos el contador. Estamos imprimiendo el nombre del hilo y también haciendo que el hilo entre en suspensión durante 1000 milisegundos dentro de un bloque try-catch ya que el método de suspensión generó una excepción marcada.
• Code Línea 33: Aquí anulamos el método de inicio de la interfaz ejecutable.
• Code Línea 35: Estamos generando el texto "Hilo iniciado".
• Code Línea 36-40: Aquí estamos tomando una condición if para verificar si la variable de clase guruthread tiene valor o no. Si es nulo, entonces estamos creando una instancia usando una clase de subproceso que toma el nombre como parámetro (el valor se asignó en el constructor). Después de lo cual el hilo se inicia utilizando el método start().

Cuando ejecuta el código anterior, obtiene el siguiente resultado:

Resultado:

Hay dos hilos, por lo tanto, recibimos dos veces el mensaje "Hilo iniciado".

Obtenemos los nombres del hilo tal como los hemos generado.

Entra en el bucle for donde imprimimos el contador y el nombre del hilo y el contador comienza con 0.

El bucle se ejecuta tres veces y entre ellas el hilo permanece inactivo durante 1000 milisegundos.

Por lo tanto, primero obtenemos guru1, luego guru2 y luego nuevamente guru2 porque el hilo duerme aquí durante 1000 milisegundos y luego, a continuación, guru1 y nuevamente guru1, el hilo duerme durante 1000 milisegundos, por lo que obtenemos guru2 y luego guru1.

Resumen

En este tutorial, vimos aplicaciones multiproceso en Java y cómo utilizar hilos simples y múltiples en Java.

• Explicar el multihilo en Java:En el subprocesamiento múltiple, los usuarios no están bloqueados ya que los subprocesos son independientes y pueden realizar múltiples operaciones a la vez.
• Varias etapas del ciclo de vida del hilo son,
  • New
  • Ejecutable
  • Correr
  • Esperando
  • Muertos
• También aprendimos sobre sincronización entre subprocesos, lo que ayuda a que la aplicación se ejecute sin problemas.
• Programación multiproceso en Java facilita muchas más tareas de aplicación.