Escala | subprocesos múltiples

Un proceso en el que varios subprocesos se ejecutan simultáneamente que se denomina subprocesos múltiples . Le permite realizar múltiples tareas de forma independiente.

¿Qué son los hilos en Scala?

Los subprocesos son subprocesos ligeros que ocupan menos memoria. Un programa de subprocesos múltiples contiene dos o más subprocesos que pueden ejecutarse simultáneamente y cada subproceso puede manejar una tarea diferente al mismo tiempo, haciendo un uso óptimo de los recursos disponibles, especialmente cuando su sistema (computadora) tiene múltiples CPU. Multithreading se utiliza para desarrollar aplicaciones concurrentes en Scala.

Los subprocesos en Scala se pueden crear utilizando dos mecanismos:

1. Extendiendo la clase Thread
2. Ampliación de la interfaz ejecutable

• Creación de subprocesos mediante la ampliación de la clase Subproceso

  Creamos una clase que extiende la clase Thread . Esta clase anula el método run() disponible en la clase Thread. Un hilo comienza su vida dentro del método run(). Creamos un objeto de nuestra nueva clase y llamamos al método start() para iniciar la ejecución de un hilo. Start() invoca el método run() en el objeto Thread.

  // Scala code for thread creation by extending  // the Thread class  class MyThread extends Thread  {     override def run()     {         // Displaying the thread that is running          println("Thread " + Thread.currentThread().getName() +                                          " is running.")     } }     // Creating object object GFG {     // Main method     def main(args: Array[String])     {         for (x <- 1 to 5)          {             var th = new MyThread()                         th.setName(x.toString())                             th.start()         }     } }

  Producción :

  Thread 1 is running.
  Thread 2 is running.
  Thread 3 is running.
  Thread 4 is running.
  Thread 5 is running.
  

• Creación de subprocesos mediante la extensión de la interfaz ejecutable

  Creamos una nueva clase que amplía la interfaz Runnable y anula el método run(). Luego instanciamos un objeto Thread pasando la clase creada al constructor. Luego llamamos al método start() en este objeto.

  // Scala code for thread creation by implementing  // the Runnable Interface  class MyThread extends Runnable  {     override def run()     {         // Displaying the thread that is running          println("Thread " + Thread.currentThread().getName() +                                             " is running.")     } }     // Creating object object MainObject {     // Main method     def main(args: Array[String])     {         for (x <- 1 to 5)          {             var th = new Thread(new MyThread())                         th.setName(x.toString())                             th.start()         }     } }

  Producción :

  Thread 1 is running.
  Thread 3 is running.
  Thread 4 is running.
  Thread 2 is running.
  Thread 5 is running.
  

Nota: no es necesario que los subprocesos se ejecuten en ningún orden secuencial. Todos los subprocesos se ejecutan de forma simultánea e independiente entre sí.

Entre el período de creación y la finalización de un subproceso de Scala, el subproceso sufre varios cambios de estado. Estos constituyen el ciclo de vida de un subproceso de Scala. Tiene los cinco estados siguientes.

• Nuevo: este es el primer estado cuando se acaba de crear el subproceso.
• Ejecutable: este es el estado cuando se ha creado el subproceso, pero el subproceso no tiene la oportunidad de comenzar a ejecutarse.
• En ejecución: en este estado, el subproceso está realizando su tarea.
• Bloqueado (o en espera): este es el estado cuando el subproceso aún está vivo, pero actualmente no puede ejecutarse debido a la espera de entrada o recursos.
• Terminado: un subproceso está en estado inactivo cuando sale su método run().