Ruby Academy · Aula

Ractors

Paralelismo verdadeiro.

Ractors é uma aula grátis de Ruby Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Ruby Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Ruby Academy inclui 4 aulas no total.

O que é um ator?

Um ator (ator Ruby) é uma primitiva de concorrência introduzida no Ruby 3 que oferece paralelismo real. Cada ator executa código Ruby de forma independente, portanto dois atores podem usar dois núcleos da CPU ao mesmo tempo.

Os atores não compartilham objetos mutáveis, contornando a limitação do GVL.
Eles se comunicam enviando mensagens.

Os atores ainda são experimentais, portanto o Ruby exibe um aviso quando você os utiliza.

Criando um ator

Crie um com Ractor.new e um bloco. O bloco é executado em paralelo. Use take para obter o valor final do bloco.

r = Ractor.new do
  2 + 3
end

puts r.take

Sem estado compartilhado

A regra principal é: os atores não podem compartilhar livremente objetos mutáveis. Um bloco de ator não captura variáveis locais externas da mesma forma que um bloco comum. Você deve passar os dados explicitamente.

Esse isolamento é o que torna a execução paralela segura sem bloqueios.

Passando argumentos para dentro

Os argumentos de Ractor.new são entregues aos parâmetros do bloco. Essa é a forma segura de enviar dados para um ator.

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

puts r.take

Enviando mensagens

Os atores têm uma caixa de entrada de mensagens. Envie com ractor.send(value) e receba dentro do bloco com Ractor.receive.

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

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

Envio vs. busca

Duas direções de comunicação:

Envio: use send para enviar a um ator e leia com Ractor.receive.
Busca: um ator devolve um valor com Ractor.yield, e o código externo o lê com take.

Juntos, esses mecanismos permitem que os atores formem cadeias de processamento.

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

puts r.take
puts r.take

Objetos congelados e compartilháveis

Alguns objetos são compartilháveis entre atores porque não podem ser alterados: true, false, nil, números, símbolos e objetos profundamente congelados.

Ractor.make_shareable congela um grafo de objetos para que ele possa ser compartilhado com segurança.

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

Copiar versus mover

Quando envia um objeto que não pode ser compartilhado, o Ractor faz uma cópia profunda dele por padrão, para que cada lado tenha sua própria cópia. Em vez disso, pode movê-lo com send(obj, move: true), o que transfere a propriedade e torna o original inutilizável.

Mover evita o custo da cópia para objetos grandes.

Trabalho paralelo

Divida o trabalho que exige muito da CPU entre Ractors e reúna os resultados. Como cada um é executado separadamente, isso pode utilizar vários 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 versus threads

Comparação:

Threads compartilham memória e precisam de bloqueios; Ractors são isolados e precisam de mensagens.
Threads não executam trabalho de CPU do Ruby em paralelo; Ractors executam.
Ractors são mais rigorosos, o que evita muitos erros de concorrência.

A desvantagem são regras mais rígidas para o compartilhamento de dados.

Quando usar Ractors

Escolha Ractors quando:

Houver trabalho limitado pela CPU e quiser utilizar vários núcleos em um único processo.
Quiser isolamento para evitar erros causados por estado compartilhado.

Lembre-se de que eles são experimentais; as APIs podem mudar, e muitas gemas ainda não são compatíveis com Ractor.

Verificação rápida

Teste sua compreensão sobre Ractors.

Recapitulação: Ractors

Você aprendeu a executar paralelismo dentro do processo com Ractors:

Ractor.new executa código em paralelo; take obtém o resultado.
Passe dados por argumentos ou por send; receba-os com Ractor.receive.
Os objetos são copiados ou movidos, não compartilhados livremente.
Ractor.make_shareable congela os dados para permitir um compartilhamento seguro.

Isso conclui o curso de Concorrência no Ruby: threads, o GVL, fibers e Ractors.

Perguntas Frequentes

A aula “Ractors” é grátis?

Sim — o texto completo de “Ractors” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Ruby Academy, atualize para CoddyKit PRO. O curso de Ruby Academy inclui 4 aulas no total.

O que vou aprender em “Ractors”?

Paralelismo verdadeiro. Você pratica Ruby Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Ruby Academy?

Nenhuma experiência prévia é necessária. Ruby Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Ractors”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Ruby Academy?

Sim. Cada aula de Ruby Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Ruby Academy