0Pricing
Lua Academy · Leçon

Construire une boucle d’événements simple

Implémentez un ordonnanceur de coroutines avec une file d’exécution et une boucle de reprise.

Construire une boucle d’événements simple est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Qu’est-ce qu’une boucle d’événements ?

Une boucle d’événements exécute un ordonnanceur qui relance les coroutines lorsque les événements qu’elles attendent sont prêts. Elle permet d’exécuter plusieurs tâches concurrentes sans threads OS.

La file d’exécution

Commencez par une file de coroutines prêtes. À chaque cycle, traitez toutes les coroutines prêtes une par une.

local queue = {}
local function spawn(fn)
  queue[#queue+1] = coroutine.create(fn)
end

Le cycle de la boucle

À chaque cycle, retirez de la file chaque coroutine prête, puis relancez-la avec resume. Les coroutines qui utilisent yield sont mises en pause jusqu’à leur réajout dans la file.

local function runLoop()
  while #queue > 0 do
    local current = queue
    queue = {}
    for _, co in ipairs(current) do
      local ok, err = coroutine.resume(co)
      if not ok then print("Error:", err) end
      if coroutine.status(co) ~= "dead" then
        queue[#queue+1] = co  -- re-queue if still alive
      end
    end
  end
end

Utiliser yield pour mettre en pause

Une coroutine utilise yield lorsqu’elle doit attendre. L’ordonnanceur la relance avec resume au cycle suivant.

spawn(function()
  print("Task A: step 1")
  coroutine.yield()  -- pause
  print("Task A: step 2")
end)
spawn(function()
  print("Task B: only step")
end)
runLoop()

Délais simulés

Implémentez une mise en veille en enregistrant le moment où une coroutine doit se réveiller.

local timers = {}
local function sleep(seconds)
  local wakeAt = os.clock() + seconds
  timers[coroutine.running()] = wakeAt
  coroutine.yield()
end

Boucle gérant les minuteries

À chaque cycle, vérifiez les minuteries et remettez dans la file les coroutines dont l’heure de réveil est passée.

local function timedLoop()
  while #queue > 0 or next(timers) do
    local now = os.clock()
    for co, wakeAt in pairs(timers) do
      if now >= wakeAt then
        timers[co] = nil
        queue[#queue+1] = co
      end
    end
    -- process queue...
  end
end

Intégration des E/S

Intégrez un mécanisme select/poll : suspendez avec yield les coroutines qui attendent des E/S, puis relancez-les avec resume lorsque leur descripteur de fichier est prêt.

Isolation des erreurs

Encapsulez chaque reprise de coroutine dans pcall ou vérifiez la valeur de retour ok. Une coroutine qui plante ne doit pas arrêter toute la boucle.

Ordonnancement coopératif

Les tâches doivent utiliser yield volontairement. Une coroutine qui s’exécute indéfiniment sans utiliser yield privera toutes les autres de temps d’exécution. Utilisez debug.sethook avec un compteur d’étapes comme garde de préemption pour le code non fiable.

Priorités des tâches

Implémentez plusieurs files (priorité haute/normale/basse) et videz d’abord les files de priorité supérieure à chaque cycle.

Solutions utilisées en pratique

Boucles d’événements utilisées en production : luv (liaisons libuv), copas (fondée sur les sockets), OpenResty (nginx + cosockets). Ne développez la vôtre que pour apprendre ou pour un usage embarqué.

Question sur les boucles d’événements

Pourquoi les coroutines d’une boucle d’événements coopérative doivent-elles utiliser yield volontairement ?

Récapitulatif : boucle d’événements simple

Une boucle d’événements utilise une file d’exécution de coroutines. À chaque cycle, elle relance les coroutines prêtes. Les tâches utilisent yield pour se mettre en pause, puis sont remises dans la file lorsque leur condition est remplie. Cela permet de gérer les E/S concurrentes et les minuteries dans Lua avec un seul fil d’exécution.

Questions Fréquemment Posées

La leçon « Construire une boucle d’événements simple » est-elle gratuite ?

Oui — le texte complet de « Construire une boucle d’événements simple » 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 Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Construire une boucle d’événements simple » ?

Implémentez un ordonnanceur de coroutines avec une file d’exécution et une boucle de reprise. Tu pratiques Lua 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 Lua Academy ?

Aucune expérience préalable n'est requise. Lua 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 1 sur 4.

Combien de temps prend la leçon « Construire une boucle d’événements simple » ?

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 Lua Academy ?

Oui. Chaque leçon Lua 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

  1. Construire une boucle d’événements simple
  2. Async/Await avec des coroutines
  3. Modèles semblables aux promesses
  4. E/S non bloquantes avec luasocket
← Retour à Lua Academy