Ruby Academy · Lección

Ractors

Paralelismo real

Ractors es una lección gratuita de Ruby Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Ruby Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Ruby Academy incluye 4 lecciones en total.

¿Qué es un Ractor?

Un Ractor (Ruby Actor) es una primitiva de concurrencia introducida en Ruby 3 que proporciona paralelismo real. Cada Ractor ejecuta el código Ruby por separado, por lo que dos Ractors pueden utilizar dos núcleos de CPU al mismo tiempo.

Los Ractors no comparten objetos mutables, lo que evita la limitación del GVL.
Se comunican mediante el envío de mensajes.

Los Ractors aún son experimentales, por lo que Ruby muestra una advertencia cuando los utiliza.

Crear un Ractor

Cree uno con Ractor.new y un bloque. El bloque se ejecuta en paralelo. Use take para obtener el valor final del bloque.

r = Ractor.new do
  2 + 3
end

puts r.take

Sin estado compartido

La regla principal es la siguiente: los Ractors no pueden compartir libremente objetos mutables. Un bloque de Ractor no captura las variables locales externas como lo hace un bloque normal. Debe pasar los datos explícitamente.

Este aislamiento es lo que hace segura la ejecución en paralelo sin bloqueos.

Pasar argumentos al interior

Los argumentos de Ractor.new se entregan a los parámetros del bloque. Esta es la forma segura de enviar datos a un Ractor.

r = Ractor.new(10) do |x|
  x * x
end

puts r.take

Enviar mensajes

Los Ractors tienen una bandeja de entrada de mensajes. Envíe mensajes con ractor.send(value) y recíbalos dentro del bloque con Ractor.receive.

r = Ractor.new do
  msg = Ractor.receive
  "got: " + msg
end

r.send("hello")
puts r.take

Push frente a Pull

Hay dos direcciones de comunicación:

Push: envíe datos a un Ractor con send y léalos con Ractor.receive.
Pull: un Ractor produce datos con Ractor.yield y el exterior los lee con take.

Juntos, estos mecanismos permiten formar canalizaciones con Ractors.

r = Ractor.new do
  Ractor.yield 1
  Ractor.yield 2
end

puts r.take
puts r.take

Objetos congelados y compartibles

Algunos objetos se pueden compartir entre Ractors porque no se pueden modificar: true, false, nil, números, símbolos y objetos congelados por completo.

Ractor.make_shareable congela un grafo de objetos para que se pueda compartir de forma segura.

data = Ractor.make_shareable([1, 2, 3])
puts "Frozen? " + data.frozen?.to_s

Copiar frente a mover

Cuando envía un objeto que no se puede compartir, Ractor hace una copia profunda de forma predeterminada para que cada lado tenga su propia copia. En su lugar, puede moverlo con send(obj, move: true), lo que transfiere la propiedad y hace que el original deje de poder usarse.

Mover evita el costo de copiar objetos grandes.

Trabajo en paralelo

Divida el trabajo que consume mucha CPU entre varios Ractors y recopile los resultados. Como cada uno se ejecuta por su cuenta, esto puede utilizar varios núcleos.

ractors = (1..3).map do |n|
  Ractor.new(n) do |x|
    x * 100
  end
end

results = ractors.map(&:take)
puts "Results: " + results.join(", ")

Ractors frente a hilos

Comparación:

Los hilos comparten memoria y necesitan bloqueos; los Ractors están aislados y necesitan mensajes.
Los hilos no paralelizan el trabajo de CPU de Ruby; los Ractors sí.
Los Ractors son más estrictos, lo que evita muchos errores de concurrencia.

La contrapartida son unas reglas más rígidas para compartir datos.

Cuándo usar Ractors

Elija Ractors cuando:

Tenga trabajo limitado por la CPU y quiera utilizar varios núcleos en un solo proceso.
Quiera aislamiento para evitar errores causados por el estado compartido.

Recuerde que son experimentales: las API pueden cambiar y muchas gemas todavía no son compatibles con Ractor.

Comprobación rápida

Compruebe su comprensión de los Ractors.

Resumen: Ractors

Ha aprendido sobre el paralelismo dentro del proceso con Ractors:

Ractor.new ejecuta código en paralelo; take obtiene su resultado.
Pase datos mediante argumentos o send; recíbalos con Ractor.receive.
Los objetos se copian o se mueven; no se comparten libremente.
Ractor.make_shareable congela los datos para compartirlos de forma segura.

Esto completa el curso de concurrencia en Ruby: hilos, el GVL, fibers y Ractors.

Preguntas frecuentes

¿La lección «Ractors» es gratis?

Sí — el texto completo de «Ractors» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Ruby Academy, actualiza a CoddyKit PRO. El curso de Ruby Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Ractors»?

Paralelismo real Practicas Ruby Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Ruby Academy?

No se requiere experiencia previa. Ruby Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Ractors»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Ruby Academy?

Sí. Cada lección de Ruby Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Ruby Academy