Ruby Academy · Leçon

Fibres

Concurrence coopérative

Fibres est une leçon Ruby Academy gratuite sur CoddyKit. Ceci est la leçon 3 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’une fibre ?

Une fibre est une unité d’exécution légère que vous contrôlez manuellement. Contrairement aux fils d’exécution, une fibre ne s’exécute jamais seule : vous lui cédez explicitement le contrôle, puis elle vous le rend.

On parle de concurrence coopérative.
Les fibres sont peu coûteuses à créer et à mettre en pause.
Elles sont à la base des générateurs et des E/S asynchrones en Ruby.

Créer et reprendre

Créez une fibre avec Fiber.new, puis démarrez-la ou poursuivez-la avec resume. Le bloc s’exécute jusqu’à sa fin ou jusqu’à sa mise en pause.

fiber = Fiber.new do
  puts "Inside the fiber"
end

fiber.resume
puts "Back in main"

Mettre en pause avec la cession

Fiber.yield met la fibre en pause et rend le contrôle à la personne qui a appelé resume. Le resume suivant reprend l’exécution juste après la cession.

fiber = Fiber.new do
  puts "Step 1"
  Fiber.yield
  puts "Step 2"
end

fiber.resume
puts "Main between steps"
fiber.resume

Transmettre des valeurs vers l’extérieur

L’argument de Fiber.yield devient la valeur renvoyée par resume. Une fibre peut ainsi produire une suite de valeurs à la demande.

fiber = Fiber.new do
  Fiber.yield 10
  Fiber.yield 20
  30
end

puts fiber.resume
puts fiber.resume
puts fiber.resume

Transmettre des valeurs vers l’intérieur

L’argument de resume devient la valeur renvoyée par Fiber.yield à l’intérieur de la fibre. La communication circule dans les deux sens.

fiber = Fiber.new do
  got = Fiber.yield "ready"
  puts "Fiber received: " + got
end

puts fiber.resume
fiber.resume("hello")

Un compteur infini

Comme une fibre se met en pause puis reprend son exécution, elle peut représenter une séquence paresseuse infinie sans jamais tout calculer.

counter = Fiber.new do
  n = 1
  loop do
    Fiber.yield n
    n += 1
  end
end

3.times { puts counter.resume }

Vérifier si elle est active

Fiber#alive? vous indique si la fibre peut encore être reprise. Reprendre une fibre inactive déclenche une FiberError.

fiber = Fiber.new { puts "done" }
puts "Alive before: " + fiber.alive?.to_s
fiber.resume
puts "Alive after: " + fiber.alive?.to_s

Fibres et fils d’exécution

Différences essentielles :

Les fils d’exécution sont planifiés par l’environnement d’exécution ; les fibres sont planifiées par vous.
Les fils d’exécution peuvent être interrompus à tout moment ; les fibres ne basculent qu’avec yield ou resume.
Les fibres évitent les conditions de concurrence, car une seule s’exécute à la fois et les points de basculement sont explicites.

Les énumérateurs utilisent des fibres

Les énumérateurs paresseux de Ruby reposent sur les fibres. Un itérateur externe se met en pause entre deux valeurs, comme une fibre qui cède le contrôle.

enum = Enumerator.new do |y|
  y << 1
  y << 2
  y << 3
end

puts enum.next
puts enum.next

Fibres et E/S asynchrones

Ruby moderne inclut un mécanisme d’extension appelé ordonnanceur de fibres. Des bibliothèques comme la gemme async l’utilisent : lorsqu’une fibre attend des E/S, l’ordonnanceur reprend automatiquement une autre fibre.

Vous obtenez ainsi des E/S fortement concurrentes avec du code qui ressemble à du code séquentiel ordinaire.

Quand utiliser les fibres

Utilisez les fibres lorsque vous avez besoin de :

Générateurs paresseux qui produisent des valeurs à la demande.
Flux de contrôle de type coroutine.
Basculements fins et déterministes, sans verrous.

Pour la plupart des besoins courants en concurrence, les fils d’exécution ou la gemme async (qui utilise des fibres en interne) sont plus simples.

Vérification rapide

Testez votre compréhension des fibres.

Récapitulatif : fibres

Vous avez appris la concurrence coopérative avec les fibres :

Fiber.new associé à resume exécute une fibre et en poursuit l’exécution.
Fiber.yield met la fibre en pause et rend le contrôle.
Les valeurs circulent dans les deux sens grâce aux arguments de yield et de resume.
Les fibres alimentent les énumérateurs et les ordonnanceurs d’E/S asynchrones.

Ensuite : les acteurs, qui vous offrent enfin un véritable parallélisme.

Questions Fréquemment Posées

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

Oui — le texte complet de « Fibres » 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 « Fibres » ?

Concurrence coopérative 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 3 sur 4.

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

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