home Tecnología de fabricación Equipo de fabricación
Manufactura industrial
Internet industrial de las cosas | Materiales industriales | Mantenimiento y reparación de equipos | Programación industrial |
home  MfgRobots >> Manufactura industrial >  >> Industrial programming >> Java

Tutorial de subprocesos múltiples en Java con programa y ejemplos


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

En este tutorial de subprocesos múltiples en Java, aprenderemos:

¿Qué es un hilo único?

Un solo hilo en Java es básicamente una unidad de procesamiento ligera y la más pequeña. Java utiliza subprocesos mediante el uso de una "Clase de subproceso".

Hay dos tipos de subprocesos:subprocesos de usuario y subprocesos de daemon. (Los subprocesos daemon se usan cuando queremos limpiar la aplicación y se usan en segundo plano).

Cuando una aplicación comienza por primera vez, se crea un subproceso de usuario. Publica eso, podemos crear muchos subprocesos de usuario y subprocesos de daemon.

Ejemplo de hilo único: 

package demotest;

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

Ventajas del hilo único:

¿Qué es multiproceso en Java?

Multiproceso en Java es un proceso de ejecución de dos o más subprocesos simultáneamente para la máxima utilización de la CPU. Las aplicaciones de subprocesos múltiples ejecutan dos o más subprocesos al mismo tiempo. Por lo tanto, también se conoce como Concurrencia en Java. Cada hilo corre paralelo entre sí. Múltiples subprocesos no asignan áreas de memoria separadas, por lo tanto, ahorran memoria. Además, el cambio de contexto entre subprocesos lleva menos tiempo.

Ejemplo de subprocesos múltiples: 

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 de multihilo:

Ciclo de vida del subproceso en Java

El ciclo de vida de un hilo:

Ciclo de vida del hilo en Java

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

  1. Nuevo
  2. Ejecutable
  3. Correr
  4. Esperando
  5. Muerto
  1. Nuevo: En esta fase, el subproceso se crea utilizando la clase "Clase de subproceso". Permanece en este estado hasta que el programa inicia. la amenaza. También se conoce como hilo nacido.
  2. Ejecutable: En esta página, la instancia del subproceso se invoca con un método de inicio. El control del subproceso se otorga al planificador para finalizar la ejecución. Depende del programador, si ejecutar el hilo.
  3. En ejecución: Cuando el subproceso comienza a ejecutarse, el estado cambia al estado "en ejecución". El planificador selecciona un subproceso del grupo de subprocesos y comienza a ejecutarse en la aplicación.
  4. Esperando: Este es el estado cuando un hilo tiene que esperar. Como hay múltiples subprocesos ejecutándose en la aplicación, existe la necesidad de sincronización entre subprocesos. Por lo tanto, un subproceso tiene que esperar hasta que se ejecute el otro subproceso. Por lo tanto, este estado se conoce como estado de espera.
  5. Muerto: Este es el estado cuando se termina el subproceso. El subproceso se encuentra en estado de ejecución y, tan pronto como completó el procesamiento, se encuentra en "estado muerto".


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


Método

Descripción
inicio() 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 duerma, por lo que la ejecución del subproceso se detendrá durante los milisegundos proporcionados y, después de eso, nuevamente el subproceso comenzará a ejecutarse. Esta ayuda en la sincronización de los hilos.
getNombre() Devuelve el nombre del hilo.
establecerPrioridad(int nuevaprioridad) Cambia la prioridad del hilo.
rendimiento () Hace que el subproceso actual se detenga y otros subprocesos se ejecuten.

Ejemplo: En este programa de subprocesos múltiples en el ejemplo de Java, vamos a crear un subproceso y explorar los métodos integrados disponibles para los subprocesos.

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:

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

Salida:

5 es la prioridad del subproceso y Thread Running es el texto que es la salida de nuestro código.

Sincronización de subprocesos de Java

En multithreading, existe el comportamiento asíncrono de los programas. Si un subproceso está escribiendo algunos datos y otro subproceso está leyendo datos al mismo tiempo, podría crear inconsistencias en la aplicación.

Cuando existe la necesidad de acceder a los recursos compartidos por dos o más subprocesos, se utiliza el enfoque de sincronización.

Java ha proporcionado métodos sincronizados para implementar el comportamiento sincronizado.

En este enfoque, una vez que el subproceso alcanza el 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 termine el bloque sincronizado y salga de él.

De esta forma, la sincronización ayuda en una aplicación multiproceso. Un subproceso tiene que esperar hasta que otro subproceso termine su ejecución, solo entonces se permite la ejecución de los otros subprocesos.

Se puede escribir de la siguiente forma:

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

Ejemplo de subprocesamiento múltiple de Java

En este ejemplo de subprocesos múltiples de Java, tomaremos dos subprocesos y buscaremos los nombres del subproceso.

Ejemplo 1: 

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:

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

Salida:

Los nombres de los hilos se muestran aquí como

Ejemplo 2:

En este ejemplo de subprocesos múltiples en Java, aprenderemos a 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,

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:

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

Salida :

Hay dos subprocesos, por lo tanto, recibimos dos veces el mensaje "Subproceso iniciado".

Obtenemos los nombres de los subprocesos tal como los hemos generado.

Entra en el ciclo for donde estamos imprimiendo el contador y el nombre del hilo y el contador comienza con 0.

El bucle se ejecuta tres veces y, en el medio, el subproceso se duerme durante 1000 milisegundos.

Por lo tanto, primero, obtenemos guru1, luego guru2 y luego nuevamente guru2 porque el subproceso duerme aquí durante 1000 milisegundos y luego luego guru1 y nuevamente guru1, el subproceso duerme durante 1000 milisegundos, por lo que obtenemos guru2 y luego guru1.

Resumen

En este tutorial, vimos aplicaciones de subprocesos múltiples en Java y cómo usar subprocesos únicos y múltiples en Java.


Java

  • Lenguaje C
  • VHDL
  • Verilog
  • MATLAB
  • python
  • Java

    1. Programa Java Hola Mundo
    2. Funciones de C++ con ejemplos de programas
    3. Tutorial de colecciones de C# con ejemplos
    4. Método Java String indexOf() con subcadena y ejemplos
    5. Método Java String charAt() con ejemplo
    6. Método Java String compareTo():​​cómo usarlo con ejemplos
    7. Sobrecarga de constructores en Java:qué es y ejemplos de programas
    8. Programa Java para comprobar el número primo
    9. Algoritmo de ordenación por inserción en Java con ejemplo de programa
    10. Clasificación de selección en el programa Java con ejemplo
    11. Multihilo C++