Lua Academy · Lektion

Eine einfache Ereignisschleife erstellen

Implementieren Sie einen Coroutine-Scheduler mit Ausführungswarteschlange und Resume-Schleife

Eine einfache Ereignisschleife erstellen ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist eine Event-Loop?

Eine Event-Loop führt einen Scheduler aus, der Coroutines fortsetzt, sobald die von ihnen erwarteten Ereignisse bereit sind. Dadurch können mehrere Tasks gleichzeitig ohne Betriebssystem-Threads ausgeführt werden.

Die Ausführungswarteschlange

Beginnen Sie mit einer Warteschlange für bereite Coroutines. Verarbeiten Sie bei jedem Tick alle bereiten Coroutines nacheinander.

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

Der Loop-Tick

Bei jedem Tick werden alle bereiten Coroutines aus der Warteschlange genommen und fortgesetzt. Coroutines, die einen Yield ausführen, werden pausiert, bis sie wieder zur Warteschlange hinzugefügt werden.

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

Pausieren durch Yield

Eine Coroutine führt einen Yield aus, wenn sie warten muss. Der Scheduler setzt sie beim nächsten Tick fort.

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()

Simulierte Verzögerungen

Implementieren Sie einen Sleep, indem Sie verfolgen, wann eine Coroutine wieder aufgeweckt werden soll.

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

Timer-fähige Loop

Prüfen Sie bei jedem Tick die Timer und fügen Sie Coroutines, deren Aufwachzeit verstrichen ist, wieder zur Warteschlange hinzu.

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

I/O-Integration

Integrieren Sie einen select-/poll-Mechanismus: Führen Sie bei Coroutines, die auf I/O warten, einen Yield aus und setzen Sie sie fort, sobald ihr Dateideskriptor bereit ist.

Fehlerisolierung

Umschließen Sie jedes Fortsetzen einer Coroutine mit pcall oder prüfen Sie den zurückgegebenen ok-Wert. Eine abstürzende Coroutine darf nicht die gesamte Loop zum Absturz bringen.

Kooperatives Scheduling

Tasks müssen freiwillig einen Yield ausführen. Eine Coroutine, die ohne Yield endlos läuft, blockiert alle anderen. Verwenden Sie debug.sethook mit einem Schrittzähler als Preemption-Schutz für nicht vertrauenswürdigen Code.

Task-Prioritäten

Implementieren Sie mehrere Warteschlangen (hohe/normale/niedrige Priorität) und leeren Sie bei jedem Tick zuerst die Warteschlangen mit höherer Priorität.

Alternativen aus der Praxis

Event-Loops für den Produktiveinsatz: luv (libuv-Bindings), copas (socket-basiert), OpenResty (nginx + cosockets). Entwickeln Sie eine eigene Lösung nur zu Lernzwecken oder für den Einsatz in eingebetteten Systemen.

Event-Loop-Frage

Warum müssen Coroutines in einer kooperativen Event-Loop freiwillig einen Yield ausführen?

Zusammenfassung: Einfache Event-Loop

Eine Event-Loop verwendet eine Ausführungswarteschlange für Coroutines. Bei jedem Tick werden bereite Coroutines fortgesetzt. Tasks führen zum Pausieren einen Yield aus und werden wieder in die Warteschlange eingereiht, sobald ihre Bedingung erfüllt ist. Dadurch werden nebenläufige I/O-Operationen und Timer in einem Single-Thread-Lua-Programm ermöglicht.

Häufig gestellte Fragen

Ist die Lektion „Eine einfache Ereignisschleife erstellen“ kostenlos?

Ja — der vollständige Text von „Eine einfache Ereignisschleife erstellen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Eine einfache Ereignisschleife erstellen“?

Implementieren Sie einen Coroutine-Scheduler mit Ausführungswarteschlange und Resume-Schleife Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Eine einfache Ereignisschleife erstellen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Eine einfache Ereignisschleife erstellen
Async/Await mit Coroutinen
Promise-ähnliche Muster
Nicht blockierende E/A mit luasocket

← Zurück zu Lua Academy