Qu'est-ce que Fiber en Ruby?

Fiber en Ruby est un léger fil d’exécution (coroutine) qui permet de créer plusieurs fils d’exécution parallèles au sein d’un seul processus/fil du système d’exploitation. Cela permet de gérer l’ordre d’exécution du code, en alternant entre les Fiber sans impliquer le planificateur du système d’exploitation.

Caractéristiques principales de Fiber :

• Planification coopérative : Les Fiber ne sont pas préemptés par le noyau du système d’exploitation. La commutation entre eux se fait explicitement via les méthodes resume et yield.
• Un seul fil : Tous les Fiber dans un même fil s’exécutent séquentiellement, mais la commutation crée une illusion de parallélisme pour le code à l’intérieur du fil.
• Préservation de l’état : Fiber se souvient de son état (variables locales, point d’exécution) lors de l’appel à yield et le reprend lors de l’appel à resume.

Applications de Fiber :

• Implémentation de code asynchrone : Modéliser des opérations non bloquantes sans utiliser de callbacks ou de constructions complexes.
• Itérateurs et générateurs : Créer des itérateurs complexes qui génèrent des valeurs à la demande.
• Gestion des automates finis : Modéliser explicitement les états et transitions.

Exemple d’utilisation :

# Création d’un Fiber
fiber = Fiber.new do
  puts "Bonjour depuis Fiber 1"
  value1 = Fiber.yield(1) # Pause l’exécution, retourne 1
  puts "Reçu Fiber 1 : #{value1}"

  puts "Bonjour depuis Fiber 2"
  value2 = Fiber.yield(2) # Pause l’exécution, retourne 2
  puts "Reçu Fiber 2 : #{value2}"

  puts "Bonjour depuis Fiber 3"
  3 # Fin du Fiber, retourne 3
end

puts "Main : Avant le premier resume"
result1 = fiber.resume # Reprend l’exécution du Fiber
puts "Main : Reçu du Fiber : #{result1}"

puts "Main : Avant le deuxième resume"
result2 = fiber.resume("de Main 1") # Reprend et passe une valeur
puts "Main : Reçu du Fiber : #{result2}"

puts "Main : Avant le troisième resume"
result3 = fiber.resume("de Main 2") # Reprend et passe une valeur
puts "Main : Reçu du Fiber : #{result3}"

Méthodes principales :

• Fiber.new { ... } : Crée un nouveau Fiber. Le bloc de code s’exécute lors du premier appel à resume.
• fiber.resume(*args) : Reprend l’exécution du Fiber. Les arguments passés à resume deviennent la valeur retournée par Fiber.yield ou les arguments du bloc qui l’a lancé.
• Fiber.yield(*args) : Pause l’exécution du Fiber courant et retourne le contrôle au code qui l’a lancé (resume). Les arguments passés à yield deviennent la valeur retournée par resume.
• Fiber.current : Retourne le Fiber courant.

Différences entre Fiber et Thread :

Caractéristique	Fiber	Thread
Planification	Coopérative (changement explicite)	Préemptive (par le système d’exploitation)
Ressources	Légers (moins de ressources)	Plus lourds (plus de ressources)
Parallélisme	Faux parallélisme dans un seul fil	Vrai parallélisme (utilise les cœurs CPU)
Communication	Via yield et resume	Via mémoire partagée, messages, etc.
Débogage	Relativement plus simple (flux linéaire)	Plus complexe (conditions de course, blocages)

Les Fiber offrent un mécanisme de gestion de l’exécution de niveau inférieur par rapport aux Thread, nécessitant une gestion explicite des changements de contexte.