Ruby Academy · Leçon

Ractors

Parallélisme réel

Ractors est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Ruby Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Ruby Academy comprend 4 leçons au total.

Qu’est-ce qu’un acteur ?

Un acteur (acteur Ruby) est une primitive de concurrence introduite dans Ruby 3 qui fournit un véritable parallélisme. Chaque acteur exécute son propre code Ruby ; deux acteurs peuvent donc utiliser deux cœurs du CPU au même instant.

Les acteurs ne partagent pas d’objets modifiables, ce qui permet de contourner la limitation du GVL.
Ils communiquent en s’envoyant des messages.

Les acteurs sont encore expérimentaux ; Ruby affiche donc un avertissement lorsque vous les utilisez.

Créer un acteur

Créez-en un avec Ractor.new et un bloc. Le bloc s’exécute en parallèle. Utilisez take pour obtenir la valeur finale de son bloc.

r = Ractor.new do
  2 + 3
end

puts r.take

Aucun état partagé

La règle fondamentale est la suivante : les acteurs ne peuvent pas partager librement des objets modifiables. Un bloc d’acteur ne capture pas les variables locales externes comme le ferait un bloc ordinaire. Vous devez transmettre explicitement les données.

C’est cet isolement qui rend l’exécution parallèle sûre sans verrous.

Transmettre des arguments

Les arguments de Ractor.new sont transmis aux paramètres du bloc. C’est la manière sûre d’envoyer des données à un acteur.

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

puts r.take

Envoyer des messages

Les acteurs disposent d’une boîte de réception de messages. Envoyez un message avec ractor.send(value) et recevez-le à l’intérieur du bloc avec Ractor.receive.

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

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

Envoi et récupération

Deux directions de communication :

Envoi : envoyez des données dans un acteur avec send, puis lisez-les avec Ractor.receive.
Récupération : un acteur cède une valeur avec Ractor.yield, puis l’extérieur la lit avec take.

Ensemble, ces mécanismes permettent aux acteurs de former des chaînes de traitement.

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

puts r.take
puts r.take

Objets gelés et partageables

Certains objets sont partageables entre les acteurs, car ils ne peuvent pas être modifiés : true, false, nil, les nombres, les symboles et les objets gelés en profondeur.

Ractor.make_shareable gèle un graphe d’objets afin qu’il puisse être partagé en toute sécurité.

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

Copie ou déplacement

Lorsque vous envoyez un objet non partageable, Ractor en crée par défaut une copie en profondeur, afin que chaque partie dispose de sa propre copie. Vous pouvez plutôt le déplacer avec send(obj, move: true), ce qui transfère sa propriété et rend l’original inutilisable.

Le déplacement évite le coût de la copie pour les objets volumineux.

Travail en parallèle

Répartissez les travaux très sollicitants pour le CPU entre plusieurs Ractors et rassemblez les résultats. Comme chacun s’exécute de son côté, cela peut utiliser plusieurs cœurs.

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

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

Ractors et fils d’exécution

Comparaison :

Les fils d’exécution partagent la mémoire et nécessitent des verrous ; les Ractors sont isolés et nécessitent des messages.
Les fils d’exécution ne parallélisent pas les calculs Ruby sur le CPU ; les Ractors le font.
Les Ractors sont plus stricts, ce qui évite de nombreux bogues de concurrence.

En contrepartie, les règles de partage des données sont plus rigides.

Quand utiliser les Ractors

Choisissez les Ractors lorsque :

Vous avez un travail limité par le CPU et souhaitez utiliser plusieurs cœurs dans un même processus.
Vous voulez une isolation pour éviter les bogues liés à l’état partagé.

N’oubliez pas qu’ils sont expérimentaux : leurs interfaces peuvent changer et de nombreuses gemmes ne sont pas encore compatibles avec les Ractors.

Vérification rapide

Vérifiez votre compréhension des Ractors.

Récapitulatif : Ractors

Vous avez découvert le parallélisme au sein d’un processus avec les Ractors :

Ractor.new exécute du code en parallèle ; take en récupère le résultat.
Transmettez les données via des arguments ou send ; recevez-les avec Ractor.receive.
Les objets sont copiés ou déplacés, et non partagés librement.
Ractor.make_shareable fige les données afin de permettre leur partage en toute sécurité.

Vous avez ainsi terminé le cours sur la concurrence en Ruby : fils d’exécution, GVL, fibres et Ractors.

Questions Fréquemment Posées

La leçon « Ractors » est-elle gratuite ?

Oui — le texte complet de « Ractors » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Ruby Academy, passe à CoddyKit PRO. Le cours Ruby Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Ractors » ?

Parallélisme réel Tu pratiques Ruby Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Ruby Academy ?

Aucune expérience préalable n'est requise. Ruby Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Ractors » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Ruby Academy ?

Oui. Chaque leçon Ruby Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Ruby Academy