Ruby | Métodos de clase de subprocesos-clase pública

En Ruby, los subprocesos se utilizan para implementar el módulo de programación concurrente. Los programas que requerían múltiples subprocesos, usan la clase Thread para crear subprocesos. La clase Thread contiene una amplia gama de métodos que realizan algunas tareas específicas.

Métodos de clase pública

abort_on_exception : este método devuelve el estado de la condición global «abortar en caso de excepción». El valor predeterminado de este método es falso. Si el valor de este método se establece en verdadero, cancela todos los subprocesos en los que se genera una excepción.
```
Thread.abort_on_exception -> true or false
```

abort_on_exception= : este método devuelve el nuevo estado. Cuando el valor de este método se establece en verdadero, cancela los subprocesos en los que surge la excepción. El tipo de retorno de este método es booleano.

Thread.abort_on_exception= bool -> true or false

# Ruby program to illustrate 
# abort_on_exception Method
  
Thread.abort_on_exception = true
  
x = Thread.new do
  
puts "Welcome to new thread"
raise "Exception is raised in thread"
end
  
sleep(0.5)
puts "Not Found"

Producción:

Welcome to new thread
test.rb:9: Exception is raised in thread (RuntimeError)
        from test.rb:6:in `initialize'
        from test.rb:6:in `new'
        from test.rb:6

Critical : este método devuelve la condición global de «subproceso crítico».
```
Thread.critical -> true or false
```
Critical= : este método se utiliza para establecer el estado de «subproceso crítico» global y devolverlo. Cuando el valor de este método se establece en verdadero, entonces prohíbe la programación de cualquier subproceso existente y no bloquea la creación y ejecución del nuevo subproceso. Algunas operaciones de subprocesos, como matar o detener un subproceso, dormir en el subproceso actual o generar una excepción, pueden hacer que un subproceso se programe en una sección crítica. Este método admite principalmente a las personas que escriben bibliotecas de subprocesos. El tipo de retorno de este método es booleano.
```
Thread.critical= bool -> true or false
```
current : este método devuelve la ejecución actual del hilo.
```
Thread.current -> thread
```
exit : este método se utiliza para finalizar los subprocesos que se están ejecutando actualmente y programar la ejecución de otro subproceso. Si este subproceso está marcado para ser eliminado, entonces devuelve el subproceso y si este es el subproceso principal o el último subproceso, sale del proceso.
```
Thread.exit
```
bifurcación : este método es similar al método de inicio.
```
Thread.fork{block} -> thread
```

kill : este método se utiliza para salir del hilo.

Thread.kill(thread)

Ejemplo:

# Ruby program to illustrate 
# kill Method
  
counter = 0
  
# creating new thread
x = Thread.new { loop { counter += 1 } }
  
# using sleep method
sleep(0.4)           
  
# exits the thread using kill method
Thread.kill(x)    
  
# give it time to die!
sleep(0.5)
  
# return false
x.alive?       

Producción:

false

list: este método devuelve una array de objetos de subprocesos para todos los subprocesos ejecutables o detenidos.

Thread.list -> array

Ejemplo:

# Ruby program to illustrate 
# list Method
  
# first thread
Thread.new { sleep(100) }
  
# second thread
Thread.new { 10000.times {|z| z*z } }
  
# third thread
Thread.new { Thread.stop }
  
# using list method
Thread.list.each {|thr| p thr }

Producción:

#<Thread:0x8795838 sleep>
#<Thread:0x87958e0 run>
#<Thread:0x8795958 sleep>
#<Thread:0x87a4f10 run>

main : este método devuelve el hilo principal del proceso. El programa siempre devolverá identificaciones diferentes para cada ejecución.
```
Thread.main -> thread
```
# Ruby program to print the id

# of main thread

# using the main method

puts Thread.main

Producción:
```
#<Thread:0xbf04f18>
```
nuevo : este método se usa para crear y ejecutar un nuevo hilo para ejecutar la instrucción dada en el bloque. Cualquier argumento pasado a este método se pasa en el bloque.
```
Thread.new([arguments]*){|arguments|block} -> thread
```
pass : este método intenta pasar la ejecución a otro subproceso, pero el cambio de la ejecución depende del sistema operativo.
```
Thread.pass
```
start : Este método es similar al nuevo método. Si la clase Thread es una subclase, llamar a start from subclass no invocará el método de inicialización de la subclase.
```
Thread.start([arguments]*){|arguments|block} -> thread
```

stop : este método se utiliza para detener la ejecución del subproceso en ejecución actual al ponerlo en suspensión y programar la ejecución de otro subproceso, restablecer la condición crítica a falso.

Thread.stop

Ejemplo:

# Ruby program to illustrate 
# stop Method
  
x = Thread.new { print "geeks"; Thread.stop; print "geeksforgeeks" }
  
# using pass method
Thread.pass
  
print "geeksforgeeks"
  
x.run
x.join

Producción:

geeksgeeksforgeeksgeeksforgeeks

Referencia: https://ruby-doc.org/core-2.5.0/Thread.html#class

Publicación traducida automáticamente

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

Métodos de clase pública

Deja una respuesta Cancelar la respuesta