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:

Extendiendo la clase Thread
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í.

Ciclo de vida del subproceso Scala

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().

Publicación traducida automáticamente

Artículo escrito por Kaustav kumar Chanda y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta