Lua Academy · Lekcja

Stan korutyny

Proszę sprawdzać stan korutyny za pomocą coroutine.status: running, suspended, dead.

Lekcja 3 z 412 kroki

Stan korutyny to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Lua Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Lua Academy zawiera 4 lekcji w sumie.

Cztery stany korutyny

Korutyny mogą znajdować się w jednym z czterech stanów: wstrzymana (utworzona lub wstrzymana przez yield i oczekująca na uruchomienie), uruchomiona (aktualnie wykonywana), normalna (wstrzymana, aby inna korutyna mogła działać) oraz zakończona (zakończyła działanie lub wystąpił w niej błąd). Stan można sprawdzić za pomocą coroutine.status(co).

local co = coroutine.create(function()
  print(coroutine.status(coroutine.running()))  -- running
  coroutine.yield()
end)

print(coroutine.status(co))  -- suspended
coroutine.resume(co)          -- prints: running
print(coroutine.status(co))  -- suspended
coroutine.resume(co)
print(coroutine.status(co))  -- dead

Stan „normalny”

Korutyna przechodzi w stan „normalny”, gdy wznawia inną korutynę. Nie jest wtedy uruchomiona, ponieważ działa inna korutyna, ale nie jest też wstrzymana — oczekuje, aż wznowiona korutyna wykona yield. Ten stan występuje rzadko, ale jego zrozumienie jest ważne w przypadku złożonych grafów korutyn.

local inner, outer

inner = coroutine.create(function()
  print("outer status:", coroutine.status(outer))  -- normal
  coroutine.yield()
end)

outer = coroutine.create(function()
  coroutine.resume(inner)
end)

coroutine.resume(outer)
-- prints: outer status: normal

Sprawdzanie przed wznowieniem

Należy zawsze sprawdzać stan korutyny przed jej wznowieniem, zwłaszcza w pętlach. Wznowienie zakończonej korutyny jest błędem. Wznowienie działającej korutyny również jest błędem, ponieważ spowodowałoby nieskończoną rekurencję.

local function safeResume(co, ...)
  local status = coroutine.status(co)
  if status == "dead" then
    return false, "cannot resume dead coroutine"
  end
  if status == "running" then
    return false, "cannot resume running coroutine"
  end
  return coroutine.resume(co, ...)
end

Stan po błędzie

Gdy w ciele korutyny wystąpi nieprzechwycony błąd, coroutine.resume zwraca false i komunikat błędu. Korutyna przechodzi do stanu „zakończona”. Nie można jej uruchomić ponownie — aby ponowić próbę, należy utworzyć nową korutynę.

local co = coroutine.create(function()
  error("something went wrong")
end)

local ok, err = coroutine.resume(co)
print(ok, err)                      -- false  ...: something went wrong
print(coroutine.status(co))         -- dead

-- Cannot resume dead coroutine:
local ok2, err2 = coroutine.resume(co)
print(ok2, err2)  -- false  cannot resume dead coroutine

coroutine.isyieldable

coroutine.isyieldable() zwraca true, jeśli działająca korutyna może wykonać yield. Zwraca false w głównym wątku oraz w funkcjach C, które nie obsługują wstrzymywania. Jeśli kontekst jest niepewny, przed wykonaniem yield należy zawsze go sprawdzić.

local co = coroutine.create(function()
  print("isyieldable:", coroutine.isyieldable())  -- true
  coroutine.yield()
end)

coroutine.resume(co)

-- In main thread:
print("isyieldable:", coroutine.isyieldable())  -- false
-- coroutine.yield()  -- ERROR in main thread

Monitorowanie zbioru korutyn

Należy śledzić pulę korutyn i po każdej rundzie wznowień usuwać te, które zostały zakończone. Stanowi to podstawę harmonogramu zadań.

local function makeWorker(n, name)
  return coroutine.create(function()
    for i = 1, n do
      print(name, "step", i)
      coroutine.yield()
    end
  end)
end

local workers = {
  makeWorker(2, "fast"),
  makeWorker(4, "slow"),
}

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

Debugowanie korutyn

Kontrole stanu służą do instrumentowania i debugowania kodu opartego na korutynach. Należy wypisywać zmiany stanów, aby zrozumieć przebieg wykonywania. W złożonych systemach warto nadawać korutynom nazwy za pomocą tabeli opakowującej, aby uzyskać czytelniejszy wynik debugowania.

local function namedCo(name, fn)
  local co = coroutine.create(fn)
  return {
    co = co,
    name = name,
    resume = function(self, ...)
      print("[" .. self.name .. "] resume")
      local results = table.pack(coroutine.resume(self.co, ...))
      print("[" .. self.name .. "] status: " .. coroutine.status(self.co))
      return table.unpack(results, 1, results.n)
    end
  }
end

local worker = namedCo("worker1", function()
  coroutine.yield()
end)
worker:resume()
worker:resume()

Ponowne uruchamianie zakończonych korutyn

Po zakończeniu korutyny nie można jej wznowić. Aby ją „uruchomić ponownie”, należy utworzyć nową korutynę na podstawie tej samej funkcji. Często stosuje się fabrykę, która na żądanie tworzy nową korutynę.

local function makeCounter(start, step)
  return coroutine.wrap(function()
    local n = start or 0
    while true do
      coroutine.yield(n)
      n = n + (step or 1)
    end
  end)
end

local count = makeCounter(0, 2)
for i = 1, 5 do io.write(count() .. " ") end
print()  -- 0 2 4 6 8

-- "Restart" by creating a new one
count = makeCounter(100)
print(count())   -- 100

Obsługa błędów w Coroutine.wrap

Gdy opakowana korutyna zgłosi błąd, błąd propaguje się na zewnątrz wywołania funkcji opakowującej. W przeciwieństwie do coroutine.resume, które zwraca false+błąd, funkcje zwrócone przez wrap bezpośrednio zgłaszają błąd. Jeśli trzeba przechwytywać błędy, należy użyć pcall wokół wywołań wrap.

local gen = coroutine.wrap(function()
  coroutine.yield(1)
  error("oops")
  coroutine.yield(2)  -- never reached
end)

print(gen())   -- 1 (ok)
local ok, err = pcall(gen)
print(ok, err) -- false  ...: oops
-- Subsequent call: dead coroutine
ok, err = pcall(gen)
print(ok, err) -- false  cannot resume dead coroutine

isyieldable a status

Istnieją dwa sposoby sprawdzania kontekstu korutyny: coroutine.status(co) podaje stan konkretnej korutyny, a coroutine.isyieldable() informuje, czy bieżący kontekst wykonywania może wykonać yield. status służy do sprawdzania innych korutyn, a isyieldable — do sprawdzania, czy można bezpiecznie wykonać yield.

local function maybeYield()
  if coroutine.isyieldable() then
    coroutine.yield()
  else
    -- in main thread or non-yieldable context
    print("cannot yield here")
  end
end

maybeYield()  -- prints "cannot yield here" (main thread)

local co = coroutine.create(maybeYield)
coroutine.resume(co)   -- yields successfully

Szybkie sprawdzenie

Do jakiego stanu przechodzi korutyna po zakończeniu wykonywania funkcji będącej jej ciałem?

Odpowiedz w interaktywnej lekcji

Podsumowanie: stan korutyny

Podsumowanie:

Stany: wstrzymana → uruchomiona ↔ normalna → zakończona
coroutine.status(co) zwraca tekstową nazwę stanu
Zakończona = zakończyła działanie lub wystąpił w niej błąd; nie można jej wznowić
coroutine.isyieldable() sprawdza, czy bieżący kontekst może wykonać yield
W pętlach należy zawsze sprawdzać stan przed wznowieniem
Błędy wrap propagują się bezpośrednio; resume zwraca false+err

Bezpłatny start

Ucz się Lua dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 40
Lekcje: 159

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Stan korutyny” jest bezpłatna?

Tak — pełny tekst „Stan korutyny” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Lua Academy, przejdź na CoddyKit PRO. Kurs Lua Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Stan korutyny”?

Proszę sprawdzać stan korutyny za pomocą coroutine.status: running, suspended, dead. Ćwiczysz Lua Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Lua Academy?

Nie wymagamy żadnego doświadczenia. Lua Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „Stan korutyny”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Lua Academy?

Tak. Każda lekcja Lua Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Lua Academy