Lua Academy · Lekcja

Tworzenie korutyn

Proszę tworzyć korutyny za pomocą coroutine.create i coroutine.wrap.

Tworzenie korutyn to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 1 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.

Czym jest coroutine?

Coroutine to funkcja, która może wstrzymać swoje wykonanie (yield), a następnie wznowić je od miejsca, w którym zostało przerwane. W przeciwieństwie do wątków coroutine są kooperatywne — w danym momencie działa tylko jedna, a przekazanie sterowania następuje jawnie. Coroutine w Lua mają własny stos i własne zmienne lokalne.

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 a coroutine.wrap

coroutine.create(fn) tworzy coroutine i zwraca obiekt coroutine (typu thread). coroutine.wrap(fn) tworzy coroutine i zwraca funkcję, która po wywołaniu wznawia jej działanie. wrap jest prostsze, ale ukrywa obiekt coroutine.

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

Cykl życia coroutine

Coroutine ma cztery stany: suspended (zawieszona, nie działa), running (działa), dead (zakończona lub zakończona błędem) oraz normal (wstrzymana, ponieważ wznowiła inną coroutine). Stan można sprawdzić za pomocą 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

Uruchamianie wielu coroutine

Utwórz wiele coroutine i przeplataj ich działanie, wznawiając każdą po kolei. Symuluje to wykonanie współbieżne (wielozadaniowość kooperatywną). Każda coroutine zachowuje swój stan między kolejnymi wywołaniami yield.

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

Iteracja za pomocą coroutine.wrap

coroutine.wrap jest często używane do tworzenia iteratorów. Zwracana funkcja jest wywoływana za każdym razem, gdy iterator przechodzi do następnego elementu. Gdy ciało coroutine się kończy, funkcja zgłasza błąd — w razie potrzeby użyj pcall albo sprawdź stan.

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

Błąd w coroutine

Jeśli coroutine zgłosi błąd, coroutine.resume zwróci false, a następnie komunikat o błędzie. Coroutine przejdzie do stanu dead. Zakończonej coroutine nie można ponownie wznowić.

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

Tożsamość coroutine

coroutine.running() zwraca aktualnie działającą coroutine oraz wartość logiczną wskazującą, czy jest ona głównym wątkiem. Użyj tej funkcji wewnątrz coroutine, aby uzyskać odwołanie do niej samej.

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

Nieskończony generator

Ciało coroutine może zawierać nieskończoną pętlę z wywołaniami yield w środku — generator wytwarza wartości na żądanie, nie kończąc działania. To jedno z kluczowych zastosowań: leniwe, nieskończone sekwencje.

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

Coroutine jako zadania

Podstawowy harmonogram zadań przechowuje coroutine w kolejce i po kolei wznawia każdą z nich. Gdy coroutine wykona yield, wraca do kolejki. Gdy zakończy działanie, jest z niej usuwana. To minimalistyczny harmonogram kooperatywny.

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

Pamięć korutyn

Każda korutyna ma własny stos. Stosy mogą znacznie rosnąć przy głębokich łańcuchach wywołań. W scenariuszach wymagających wysokiej wydajności należy unikać tworzenia tysięcy jednocześnie aktywnych korutyn. W miarę możliwości należy ponownie używać korutyn albo korzystać z pul.

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

Szybkie sprawdzenie

W jakim stanie znajduje się korutyna bezpośrednio po wywołaniu coroutine.create(fn)?

Podsumowanie: tworzenie korutyn

Podsumowanie:

coroutine.create(fn) → obiekt korutyny; wrap(fn) → funkcja, którą można wznawiać
Stany: wstrzymana → uruchomiona → wstrzymana/zakończona
coroutine.resume(co, ...) uruchamia/wznawia korutynę
Błędy podczas wznawiania: false + komunikat błędu; korutyna → zakończona
Nieskończone generatory za pomocą while true do yield() end
Służą do współbieżnego przetwarzania kooperatywnego i leniwych sekwencji

Często zadawane pytania

Czy lekcja „Tworzenie korutyn” jest bezpłatna?

Tak — pełny tekst „Tworzenie korutyn” 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 „Tworzenie korutyn”?

Proszę tworzyć korutyny za pomocą coroutine.create i coroutine.wrap. Ć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 1 z 4.

Ile czasu zajmuje lekcja „Tworzenie korutyn”?

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