¿Ruby tiene multihilo real?

Ruby 1.8 solo tiene subprocesos verdes, no hay forma de crear un subproceso real "a nivel del sistema operativo". Pero, ruby 1.9 tendrá una nueva característica llamada fibras, que le permitirá crear subprocesos reales a nivel del sistema operativo. Desafortunadamente, Ruby 1.9 todavía está en beta, está programado para ser estable en un par de meses.

Otra alternativa es usar JRuby. JRuby implementa los hilos como teads a nivel del sistema operativo, no hay" hilos verdes " en él. La última versión de JRuby es 1.1.4 y es equivalente a Ruby 1.8

Depende de la implementación:

• RMI no tiene, YARV está más cerca.
JRuby y MacRuby lo han hecho.

Ruby tiene cierres como Blocks, lambdas y Procs. Para aprovechar al máximo los cierres y múltiples núcleos en JRuby, los ejecutores de Java son útiles; para MacRuby me gustan las colas de GCD.

Tenga en cuenta que, ser capaz de crear hilos reales "a nivel del sistema operativo" no implica que puede utilizar varios núcleos de cpu para el procesamiento en paralelo. Mira los ejemplos a continuación.

Esta es la salida de un simple programa Ruby que usa 3 hilos usando Ruby 2.1.0:

(jalcazar@mac ~)$ ps -M 69877
USER     PID   TT   %CPU STAT PRI     STIME     UTIME COMMAND
jalcazar 69877 s002    0.0 S    31T   0:00.01   0:00.04 /Users/jalcazar/.rvm/rubies/ruby-2.1.0/bin/ruby threads.rb
   69877         0.0 S    31T   0:00.01   0:00.00 
   69877        33.4 S    31T   0:00.01   0:08.73 
   69877        43.1 S    31T   0:00.01   0:08.73 
   69877        22.8 R    31T   0:00.01   0:08.65 

Como puede ver aquí, hay cuatro subprocesos del sistema operativo, sin embargo, solo se está ejecutando el que tiene el estado R. Esto se debe a una limitación en cómo se implementan los subprocesos de Ruby.

El mismo programa, ahora con JRuby. Puedes ver tres hilos con state R, lo que significa que son corriendo en paralelo.

(jalcazar@mac ~)$ ps -M 72286
USER     PID   TT   %CPU STAT PRI     STIME     UTIME COMMAND
jalcazar 72286 s002    0.0 S    31T   0:00.01   0:00.01 /Library/Java/JavaVirtualMachines/jdk1.7.0_25.jdk/Contents/Home/bin/java -Djdk.home= -Djruby.home=/Users/jalcazar/.rvm/rubies/jruby-1.7.10 -Djruby.script=jruby -Djruby.shell=/bin/sh -Djffi.boot.library.path=/Users/jalcazar/.rvm/rubies/jruby-1.7.10/lib/jni:/Users/jalcazar/.rvm/rubies/jruby-1.7.10/lib/jni/Darwin -Xss2048k -Dsun.java.command=org.jruby.Main -cp  -Xbootclasspath/a:/Users/jalcazar/.rvm/rubies/jruby-1.7.10/lib/jruby.jar -Xmx1924M -XX:PermSize=992m -Dfile.encoding=UTF-8 org/jruby/Main threads.rb
   72286         0.0 S    31T   0:00.00   0:00.00 
   72286         0.0 S    33T   0:00.00   0:00.00 
   72286         0.0 S    31T   0:00.09   0:02.34 
   72286         7.9 S    31T   0:00.15   0:04.63 
   72286         0.0 S    31T   0:00.00   0:00.00 
   72286         0.0 S    31T   0:00.00   0:00.00 
   72286         0.0 S    31T   0:00.00   0:00.00 
   72286         0.0 S    31T   0:00.04   0:01.68 
   72286         0.0 S    31T   0:00.03   0:01.54 
   72286         0.0 S    31T   0:00.00   0:00.00 
   72286         0.0 S    31T   0:00.01   0:00.01 
   72286         0.0 S    31T   0:00.00   0:00.01 
   72286         0.0 S    31T   0:00.00   0:00.03 
   72286        74.2 R    31T   0:09.21   0:37.73 
   72286        72.4 R    31T   0:09.24   0:37.71 
   72286        74.7 R    31T   0:09.24   0:37.80 

El mismo programa, ahora con MacRuby. También hay tres hilos que se ejecutan en paralelo. Esto se debe a que los hilos MacRuby son hilos POSIX (subprocesos reales "a nivel del sistema operativo" ) y no hay GVL

(jalcazar@mac ~)$ ps -M 38293
USER     PID   TT   %CPU STAT PRI     STIME     UTIME COMMAND
jalcazar 38293 s002    0.0 R     0T   0:00.02   0:00.10 /Users/jalcazar/.rvm/rubies/macruby-0.12/usr/bin/macruby threads.rb
   38293         0.0 S    33T   0:00.00   0:00.00 
   38293       100.0 R    31T   0:00.04   0:21.92 
   38293       100.0 R    31T   0:00.04   0:21.95 
   38293       100.0 R    31T   0:00.04   0:21.99 

Una vez más, el mismo programa, pero ahora con el buen viejo RMI. Debido al hecho de que esta implementación utiliza hilos verdes, solo aparece un hilo

(jalcazar@mac ~)$ ps -M 70032
USER     PID   TT   %CPU STAT PRI     STIME     UTIME COMMAND
jalcazar 70032 s002  100.0 R    31T   0:00.08   0:26.62 /Users/jalcazar/.rvm/rubies/ruby-1.8.7-p374/bin/ruby threads.rb

Si usted es interesado en Ruby multi-threading puede encontrar mi informe Depuración de programas paralelos utilizando controladores de horquilla interesante.
Para una visión más general de los internos de Ruby Rubí Bajo un Microscopio es una buena lectura.
Además, los subprocesos Ruby y el Bloqueo del Intérprete Global en C en Omniref explican en el código fuente por qué los subprocesos Ruby no se ejecutan en paralelo.

¿Qué tal usar drb? No es real multi-threading pero la comunicación entre varios procesos, pero se puede utilizar ahora en 1.8 y es bastante baja fricción.

Dejaré que el "Monitor del Sistema" responda esta pregunta. Estoy ejecutando el mismo código (abajo, que calcula números primos) con 8 subprocesos Ruby corriendo en una máquina i7 (4 hyperthreaded-core) en ambos casos... la primera ejecución es con:

Jruby 1.5.6 (ruby 1.8.7 patchlevel 249) (2014-02-03 6586) (OpenJDK 64-Bit Server VM 1.7.0_75) [amd64-java]

El segundo es con:

Ruby 2.1. 2p95 (2014-05-08) [x86_64-linux-gnu]

Curiosamente, la CPU es mayor para JRuby subprocesos, pero el tiempo de finalización es ligeramente más corto para el Ruby interpretado. Es un poco difícil de decir desde el gráfico, pero la segunda ejecución (interpretado Ruby) utiliza alrededor de 1/2 de las CPU (sin hyperthreading?)

def eratosthenes(n)
  nums = [nil, nil, *2..n]
  (2..Math.sqrt(n)).each do |i|
    (i**2..n).step(i){|m| nums[m] = nil}  if nums[i]
  end
  nums.compact
end

MAX_PRIME=10000000
THREADS=8
threads = []

1.upto(THREADS) do |num|
  puts "Starting thread #{num}"
  threads[num]=Thread.new { eratosthenes MAX_PRIME }
end

1.upto(THREADS) do |num|
    threads[num].join
end

Si está utilizando MRI, entonces puede escribir el código enhebrado en C ya sea como una extensión o utilizando la gema ruby-inline.

Si realmente necesita paralelismo en Ruby para un sistema de nivel de Producción (donde no puede emplear una versión beta) los procesos son probablemente una mejor alternativa.
Pero, definitivamente vale la pena probar hilos bajo JRuby primero.

También si usted está interesado en el futuro de threading bajo Ruby, usted puede encontrar este artículo útil.

Aquí hay algo de información sobre Rinda, que es la implementación de Ruby de Linda (parallel processing and distributed computing paradigm) http://charmalloc.blogspot.com/2009/12/linda-tuples-rinda-drb-parallel.html

Porque no se pudo editar esa respuesta, así que agrega una nueva respuesta aquí.

Actualizar(2017-05-08)

Este artículo es muy antiguo, y la información no es seguir actual (2017) tread, lo que sigue es algún suplemento:

1. Opal es un compilador de Ruby a JavaScript de fuente a fuente. También tiene una implementación del Ruby corelib, actualmente es un desarrollador muy activo, y existe una gran cantidad de framework (frontend) trabajado en él. y producción lista. Porque basado en javascript, no soporta hilos paralelos.

2. Truffleruby es una implementación de alto rendimiento del lenguaje de programación Ruby. Construido sobre el GraalVM por Oracle Labs, TruffleRuby es una bifurcación de JRuby, combinándolo con código del proyecto Rubinius, y también conteniendo código de la implementación estándar de Ruby, MRI, todavía en desarrollo vivo, no listo para producción. Esta versión ruby parece haber nacido para el rendimiento, no se si soporta hilos paralelos, pero creo que debería.