Ruby | Ciclo de vida del hilo y sus estados

El ciclo de vida del subproceso proporciona una breve descripción del subproceso desde su nacimiento hasta su finalización. Se puede crear un hilo nuevo con la ayuda de los métodos Thread.new , Thread.start o Thread.fork . No es necesario iniciar un nuevo hilo después de crear. Un subproceso comienza a ejecutarse automáticamente cuando los recursos de la CPU están disponibles. El valor de Thread.new una cita es un objeto Thread. La clase Thread proporciona una variedad de métodos para consultar y manipular el hilo.
Un subproceso se encuentra con el bloque de código relacionado con la llamada a Thread.newy luego deja de correr. El valor de la última expresión en el bloque de subprocesos es el valor del subproceso y el valor se adquiere llamando al método de valor del objeto Subproceso. El método de valor devuelve valor solo si el subproceso se ha ejecutado por completo; de lo contrario, no devuelve valor al subproceso que se ejecuta por completo. Si se genera una excepción en el subproceso, finaliza el subproceso en ejecución. Esta condición funciona solo en aquellos subprocesos que no son el subproceso principal y solo terminan aquellos subprocesos que contienen una excepción.

Estados de subprocesos

En Ruby, hay cinco estados disponibles para hilos que muestran el estado del hilo. Puede verificar el estado de un hilo usando Alive? y métodos de estado .

1. Ejecutable: el subproceso que se está ejecutando actualmente o que está listo para tomar recursos de la CPU cuando estén disponibles.
2. Durmiendo: el subproceso que actualmente está durmiendo, o que está esperando IO, o que se detuvo.
3. Abortar: Es un estado intermedio. Un subproceso abortado en el que se ha eliminado, pero que aún no ha terminado.
4. Terminado con excepción: un subproceso contiene una excepción, o en otras palabras, un subproceso que finaliza debido al aumento de la excepción.
5. Terminado normalmente: el subproceso que termina normalmente, o que no contiene una excepción y completó su trabajo.

Ejemplo:

# Ruby program to illustrate  # check status of thread    counter = 0     # creating new thread x = Thread.new { loop { counter += 1 } }    # check thread alive or not puts x.alive?

Producción:

true

La siguiente tabla muestra el nombre de los estados y sus valores de retorno:

Hilo principal

En Ruby, el subproceso principal es una parte especial de subprocesos múltiples. Es el subproceso superior de un programa, todos los subprocesos se ejecutan bajo este subproceso o, en otras palabras, es el subproceso principal y otros subprocesos del mismo programa son el subproceso del subproceso principal. El hilo principal se crea con la ayuda del método principal . El intérprete de Ruby deja de ejecutarse cuando se completa el trabajo del subproceso principal, lo que significa que el subproceso principal y el subproceso secundario completan sus tareas. El método de clase Thread.maindevuelve el objeto Thread que representa el hilo principal. Si se genera una excepción en el hilo principal y no se maneja en ninguna parte, el intérprete de Ruby imprime un mensaje o sale. Y si se genera una excepción en el subproceso que no sea el subproceso principal, entonces el intérprete de Ruby termina el subproceso que contiene una excepción

Ejemplo:

# Ruby program to illustrate 
# main thread
  
# Create main thread
puts Thread.main  
puts ""  
  
# create new thread 
a1 = Thread.new {sleep 200}  
list_thread= Thread.list
list_thread.each {|t| p t }  
puts "Current thread = " + Thread.current.to_s  
  
 # create new thread
a2 = Thread.new {sleep 200}  
list_thread= Thread.list
list_thread.each {|t| p t }  
puts "Current thread=" + Thread.current.to_s   
  
 # kill thread a1
Thread.kill(a1) 
  
# pass execution to thread a2 
Thread.pass   
  
# kill thread a2                         
Thread.kill(a2)          
  
list_thread= Thread.list
list_thread.each {|t| p t }  
    
# exit main thread
Thread.exit  

Producción:

#<Subproceso:0x00000001afe1b8>

#<Subproceso:0x00000001afe1b8 ejecutar>
#<Subproceso:0x00000001d05c68@/var/www/service/usercode/1749234900/source.rb:9 sleep>
Subproceso actual = #<Subproceso:0x00000001afe1b8>
#<Subproceso:0x00000001afe1b8 ejecutar>
#<Subproceso :0x00000001d05c68@/var/www/service/usercode/1749234900/source.rb:9 sleep>
#<Subproceso:0x00000001c8bd50@/var/www/service/usercode/1749234900/source.rb:15 ejecutar> Subproceso
actual=#< Subproceso:0x00000001afe1b8>
#<Subproceso:0x00000001afe1b8 ejecutar>
#<Subproceso:0x00000001c8bd50@/var/www/service/usercode/1749234900/source.rb:15 dead>

Explicación: Este programa muestra cómo se ejecuta el subproceso principal. En primer lugar, creamos el subproceso principal y luego en este subproceso principal hay dos subprocesos, es decir, subprocesos a1 y a2 . Cuando el subproceso a1 se ejecuta por completo, elimine el subproceso a1 y pase la ejecución al subproceso a2 . Después de eso , elimine el subproceso a2 e imprima la lista de subprocesos presentes en el subproceso principal con su estado. Cuando todos los subprocesos presentes en el subproceso principal están muertos, entonces existe el subproceso principal.

Estados de subprocesos alternativos: Pausa, Despertar y Matar

Como sabemos, los subprocesos se crean en estado ejecutable y están listos para ejecutarse. Un subproceso se detiene entrando en un estado de suspensión, o llamando al método Thread.stop , o llamando a Kernel.sleep . Ningún subproceso puede hacer una pausa forzada por otro subproceso. Si un subproceso llama a Kernel.sleep sin argumento, entonces pausa el subproceso para siempre o hasta que se despierta y si un subproceso llama a Kernel.sleep con un argumento, entonces pone temporalmente el subproceso en estado de suspensión. El subproceso que está en un estado de suspensión temporal se activa automáticamente cuando expira el tiempo dado y vuelve a entrar en el estado ejecutable.

Una pausa de subproceso llamando a Thread.stop o llamando a kernel.sleep puede comenzar de nuevo llamando a métodos de instancia, es decir, despertar y ejecutar . Estos métodos cambian los estados de un subproceso de inactivo a ejecutable. El método de ejecución también llama a un programador de subprocesos. Debido a la llamada del programador de subprocesos, el subproceso recientemente despertado puede obtener recursos de CPU. El método de activación activa el subproceso específico sin llamar al programador de subprocesos.

Un subproceso puede forzar la terminación de otro subproceso llamando al método de instancia kill. El método de terminación y salida es similar al método de eliminación. Estos métodos colocan el método eliminado en el estado de terminación normal. Matar un subproceso es algo peligroso a menos que tenga una forma de saber que el subproceso no está en medio del estado de intercambio de archivos. Matando un hilo con ! El método es más dañino porque un subproceso cerrado puede dejar abiertos los sockets, los archivos y otros recursos.