Lua Academy · Lektion

Coroutinen erstellen

Erstellen Sie Coroutinen mit coroutine.create und coroutine.wrap

Coroutinen 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 Coroutine?

Eine Coroutine ist eine Funktion, die ihre Ausführung pausieren (yield) und später an derselben Stelle fortsetzen kann. Anders als Threads sind Coroutines kooperativ – immer nur eine läuft gleichzeitig, und sie gibt die Kontrolle ausdrücklich ab. Lua-Coroutines verfügen über ihren eigenen Stack und eigene lokale Variablen.

local co = coroutine.create(function()
  print("start")
  coroutine.yield()
  print("resumed")
  coroutine.yield()
  print("done")
end)

print(coroutine.status(co))   -- suspended
coroutine.resume(co)          -- start
print(coroutine.status(co))   -- suspended
coroutine.resume(co)          -- resumed

coroutine.create im Vergleich zu coroutine.wrap

coroutine.create(fn) erstellt eine Coroutine und gibt ein Coroutine-Objekt (Typ thread) zurück. coroutine.wrap(fn) erstellt eine Coroutine und gibt eine Funktion zurück, die sie beim Aufruf fortsetzt. wrap ist einfacher, verbirgt aber das Coroutine-Objekt.

-- create: returns coroutine object
local co = coroutine.create(function(x)
  return x * 2
end)
local ok, val = coroutine.resume(co, 5)
print(ok, val)   -- true  10

-- wrap: returns a resumable function
local gen = coroutine.wrap(function(x)
  return x * 3
end)
print(gen(5))    -- 15

Lebenszyklus einer Coroutine

Eine Coroutine hat vier Zustände: suspended (nicht ausgeführt), running (wird gerade ausgeführt), dead (hat einen Wert zurückgegeben oder einen Fehler ausgelöst) und normal (pausiert, weil sie eine andere Coroutine fortgesetzt hat). Prüfen Sie den Zustand mit coroutine.status(co).

local co = coroutine.create(function()
  coroutine.yield()
end)

print(coroutine.status(co))  -- suspended
coroutine.resume(co)          -- runs until yield
print(coroutine.status(co))  -- suspended again
coroutine.resume(co)          -- runs until end
print(coroutine.status(co))  -- dead

Mehrere Coroutines ausführen

Erstellen Sie mehrere Coroutines und verschachteln Sie ihre Ausführung, indem Sie sie abwechselnd fortsetzen. Dadurch wird eine nebenläufige Ausführung simuliert (kooperatives Multitasking). Jede Coroutine behält ihren Zustand zwischen den yield-Aufrufen bei.

local function worker(name, steps)
  for i = 1, steps do
    print(name .. ": step " .. i)
    coroutine.yield()
  end
end

local co1 = coroutine.create(function() worker("A", 3) end)
local co2 = coroutine.create(function() worker("B", 3) end)

for _ = 1, 3 do
  coroutine.resume(co1)
  coroutine.resume(co2)
end
-- A:1, B:1, A:2, B:2, A:3, B:3

Iteration mit coroutine.wrap

coroutine.wrap wird häufig zum Erstellen von Iteratoren verwendet. Die zurückgegebene Funktion wird bei jedem Weiterschalten des Iterators aufgerufen. Wenn der Coroutine-Body endet, löst die Funktion einen Fehler aus – verwenden Sie bei Bedarf pcall oder prüfen Sie den Zustand.

local function range(n)
  return coroutine.wrap(function()
    for i = 1, n do
      coroutine.yield(i)
    end
  end)
end

for v in range(5) do
  io.write(v .. " ")
end
print()  -- 1 2 3 4 5

Fehler in Coroutines

Wenn eine Coroutine einen Fehler auslöst, gibt coroutine.resume false gefolgt von der Fehlermeldung zurück. Die Coroutine wechselt in den Zustand dead. Eine beendete Coroutine kann nicht erneut fortgesetzt werden.

local co = coroutine.create(function(x)
  if x < 0 then error("negative input: " .. x) end
  return math.sqrt(x)
end)

local ok, val = coroutine.resume(co, -1)
print(ok, val)    -- false  input:2: negative input: -1
print(coroutine.status(co))  -- dead

-- Can't resume a dead coroutine:
ok, val = coroutine.resume(co)
print(ok, val)    -- false  cannot resume dead coroutine

Identität einer Coroutine

coroutine.running() gibt die aktuell ausgeführte Coroutine sowie einen Boolean zurück, der angibt, ob es sich um den Hauptthread handelt. Verwenden Sie dies innerhalb einer Coroutine, um eine Referenz auf sich selbst zu erhalten.

local co = coroutine.create(function()
  local self, isMain = coroutine.running()
  print("type:", type(self))      -- thread
  print("isMain:", isMain)        -- false
  print("status:", coroutine.status(self)) -- running
end)

coroutine.resume(co)

-- In main thread:
local main, isMain = coroutine.running()
print("main isMain:", isMain)    -- true

Endloser Generator

Der Body einer Coroutine kann eine Endlosschleife mit yield-Aufrufen enthalten – der Generator erzeugt Werte bei Bedarf, ohne zu enden. Das ist ein wichtiger Anwendungsfall: faule, unendliche Sequenzen.

local function naturals(start)
  return coroutine.wrap(function()
    local n = start or 1
    while true do
      coroutine.yield(n)
      n = n + 1
    end
  end)
end

local gen = naturals(1)
for i = 1, 8 do
  io.write(gen() .. " ")
end
print()  -- 1 2 3 4 5 6 7 8

Coroutines als Aufgaben

Ein einfacher Aufgabenplaner speichert Coroutines in einer Warteschlange und setzt sie nacheinander fort. Wenn eine Coroutine einen yield-Aufruf ausführt, wird sie wieder in die Warteschlange eingereiht. Wenn sie beendet ist, wird sie entfernt. Das ist ein minimaler kooperativer Scheduler.

local tasks = {}

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

local function run()
  while #tasks > 0 do
    local alive = {}
    for _, co in ipairs(tasks) do
      coroutine.resume(co)
      if coroutine.status(co) ~= "dead" then
        alive[#alive+1] = co
      end
    end
    tasks = alive
  end
end

spawn(function() for i=1,3 do print("T1:"..i); coroutine.yield() end end)
spawn(function() for i=1,3 do print("T2:"..i); coroutine.yield() end end)
run()

Coroutine-Speicher

Jede Coroutine verfügt über einen eigenen Stack. Bei tiefen Aufrufketten können Stacks stark anwachsen. Vermeiden Sie in Hochleistungsszenarien, Tausende gleichzeitig aktiver Coroutines zu erstellen. Verwenden Sie Coroutines nach Möglichkeit wieder oder nutzen Sie Pools.

-- Coroutine pool concept
local pool = {}

local function getCoroutine(fn)
  -- Reuse dead coroutine slots
  for i, co in ipairs(pool) do
    if coroutine.status(co) == "dead" then
      pool[i] = coroutine.create(fn)
      return pool[i]
    end
  end
  local co = coroutine.create(fn)
  pool[#pool+1] = co
  return co
end

print("Pool pattern for coroutine reuse")

Schnelltest

In welchem Zustand befindet sich eine Coroutine unmittelbar nach coroutine.create(fn)?

Rückblick: Coroutines erstellen

Zusammenfassung:

coroutine.create(fn) → Coroutine-Objekt; wrap(fn) → fortsetzbare Funktion
Zustände: suspended → running → suspended/dead
coroutine.resume(co, ...) startet die Coroutine oder setzt sie fort
Fehler während des Fortsetzens: false + Fehlermeldung; Coroutine → dead
Endlose Generatoren mit while true do yield() end
Verwenden Sie Coroutines für kooperatives Multitasking und verzögerte Sequenzen

Häufig gestellte Fragen

Ist die Lektion „Coroutinen erstellen“ kostenlos?

Ja — der vollständige Text von „Coroutinen 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 „Coroutinen erstellen“?

Erstellen Sie Coroutinen mit coroutine.create und coroutine.wrap 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 „Coroutinen 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

← Zurück zu Lua Academy