Lua Academy · Oppitunti

resume ja yield

Vaihtakaa tietoja kutsujan ja korutiinin välillä resume- ja yield-funktioilla.

Oppitunti 2/412 vaihetta

resume ja yield on ilmainen Lua Academy-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Lua Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Lua Academy-kurssilla on yhteensä 4 oppituntia.

Arvojen välittäminen korutiinille

Ensimmäiselle coroutine.resume-kutsulle välitetyistä argumenteista tulee korutiinin rungon funktion parametrit. Seuraaville jatkamiskutsuille välitetyt argumentit palauttaa korutiinin keskeyttänyt coroutine.yield()-kutsu.

local co = coroutine.create(function(a, b)
  print("received:", a, b)        -- 10  20
  local c = coroutine.yield()     -- pauses
  print("after yield:", c)        -- 30
end)

coroutine.resume(co, 10, 20)  -- first call: passes a,b
coroutine.resume(co, 30)      -- subsequent: passed to yield

yield-kutsun palauttamat arvot

Kutsulle coroutine.yield(val1, val2) välitetyistä arvoista tulee sen coroutine.resume()-kutsun paluuarvot, joka pysähtyi yield-kutsuun. yield siis "palauttaa" arvoja kutsujalle.

local co = coroutine.create(function()
  coroutine.yield(1, "hello")
  coroutine.yield(2, "world")
  return 3, "done"
end)

local ok, a, b = coroutine.resume(co)
print(ok, a, b)   -- true  1  hello

ok, a, b = coroutine.resume(co)
print(ok, a, b)   -- true  2  world

ok, a, b = coroutine.resume(co)
print(ok, a, b)   -- true  3  done

Kaksisuuntainen viestintä

Korutiinit mahdollistavat aidosti kaksisuuntaisen viestinnän: kutsuja välittää tietoja resume-kutsun kautta, korutiini käsittelee ne ja palauttaa tulokset yield-kutsulla. Jokainen resume/yield on synkroninen tiedonvaihto.

local co = coroutine.create(function(x)
  while true do
    x = coroutine.yield(x * x)  -- yield x^2, get next x
  end
end)

coroutine.resume(co)  -- start (x=nil initially)
local ok, sq
ok, sq = coroutine.resume(co, 3); print(sq)  -- 9
ok, sq = coroutine.resume(co, 5); print(sq)  -- 25
ok, sq = coroutine.resume(co, 7); print(sq)  -- 49

Tuottaja–kuluttaja

Klassinen korutiinimalli: tuottaja palauttaa alkioita yksi kerrallaan, ja kuluttaja jatkaa tuottajan suoritusta aina tarvitessaan seuraavan alkion. Kumpikaan ei etene toisen edelle — täydellinen synkronointi.

local function producer(items)
  return coroutine.create(function()
    for _, item in ipairs(items) do
      coroutine.yield(item)
    end
  end)
end

local pro = producer({"apple","banana","cherry"})

-- Consumer drives the loop
while true do
  local ok, item = coroutine.resume(pro)
  if not ok or item == nil then break end
  print("consumed:", item)
end

Putki korutiineilla

Ketjuttakaa useita korutiineja putkeksi. Kukin vaihe lukee edelliseltä vaiheelta ja palauttaa arvot seuraavalle. Lopullinen vaihe ohjaa putkea jatkamalla viimeisen vaiheen suoritusta, mikä käynnistää ketjun etenemisen takaisinpäin.

local function source(items)
  return coroutine.wrap(function()
    for _, v in ipairs(items) do coroutine.yield(v) end
  end)
end

local function filter(iter, pred)
  return coroutine.wrap(function()
    for v in iter do
      if pred(v) then coroutine.yield(v) end
    end
  end)
end

local function map(iter, fn)
  return coroutine.wrap(function()
    for v in iter do coroutine.yield(fn(v)) end
  end)
end

local pipeline = map(filter(source({1,2,3,4,5,6}),
  function(n) return n%2==0 end),
  function(n) return n*n end)

for v in pipeline do io.write(v.." ") end
print()  -- 4 16 36

Korutiinit asynkronoinnin simulointiin

Ilman käyttöjärjestelmän säikeitä korutiineilla voidaan simuloida asynkronisia toimintoja: suoritus keskeytetään "odottamisen" ajaksi ja sitä jatketaan, kun "tulos" on valmis. Ajastin jatkaa korutiinia tuloksen kanssa.

local scheduler = {}
local current = nil

local function await(key)
  coroutine.yield(key)  -- tell scheduler what we need
  return coroutine.yield()  -- wait for result
end

local co = coroutine.create(function()
  local data = await("fetch:users")
  print("Got users:", data)
end)

-- Start coroutine
local ok, want = coroutine.resume(co)
print("Coroutine wants:", want)  -- fetch:users
-- Simulate delivering the result:
coroutine.resume(co, {{name="Alice"},{name="Bob"}})

yield funktion sisällä

Voitte käyttää yield-kutsua minkä tahansa korutiinin kutsuman funktion sisällä, ei vain ylimmän tason funktiossa. Keskeytys etenee kaikkien sisäkkäisten kutsujen läpi takaisin resume-kutsuun. Tätä kutsutaan "keskeytetyksi kutsupinoksi".

local function yieldTwice(label)
  coroutine.yield(label .. ":1")
  coroutine.yield(label .. ":2")
end

local co = coroutine.create(function()
  yieldTwice("A")
  yieldTwice("B")
end)

for i = 1, 4 do
  local ok, v = coroutine.resume(co)
  print(v)
end
-- A:1, A:2, B:1, B:2

Korutiinit eivät ole säikeitä

Lua-korutiinit eivät ole käyttöjärjestelmän säikeitä. Vain yksi korutiini suoritetaan kerrallaan; ennakoivaa moniajoa tai rinnakkaisuutta ei ole. Kaikki korutiinit jakavat yhden käyttöjärjestelmän säikeen. Todellista rinnakkaisuutta varten tarvitaan useita Lua-tiloja erillisissä käyttöjärjestelmän säikeissä.

-- This is NOT parallel - interleaved execution
local function task(name, n)
  for i = 1, n do
    print(name, i)
    coroutine.yield()
  end
end

local t1 = coroutine.create(function() task("A", 3) end)
local t2 = coroutine.create(function() task("B", 3) end)

-- Must explicitly schedule:
for _ = 1, 3 do
  coroutine.resume(t1)
  coroutine.resume(t2)
end
-- A1, B1, A2, B2, A3, B3 (interleaved, NOT parallel)

Tila resume-kutsun jälkeen

Tarkistakaa korutiinin tila päättääksenne, jatketaanko sitä. Suorituksensa päättänyt korutiini, jonka runko on palannut, on tilassa "dead" — sen jatkaminen palauttaa arvon false ja virheen. Tarkistakaa tila aina ennen jatkamista silmukoissa.

local co = coroutine.create(function()
  for i = 1, 3 do coroutine.yield(i) end
end)

while coroutine.status(co) ~= "dead" do
  local ok, val = coroutine.resume(co)
  if ok and val ~= nil then
    print("val:", val)
  end
end
-- val: 1, val: 2, val: 3

Useita yield-kutsuja yhden resume-kutsun aikana

Yksi coroutine.resume-kutsu suorittaa korutiinia seuraavaan yield-kutsuun asti tai sen päättymiseen saakka. Korutiinia ei voi saada suorittamaan useita yield-kutsuja yhden resume-kutsun aikana — jokainen yield keskeyttää suorituksen ja odottaa seuraavaa resume-kutsua.

local co = coroutine.create(function()
  local x = coroutine.yield("first")
  print("got:", x)
  local y = coroutine.yield("second")
  print("got:", y)
end)

local _, v1 = coroutine.resume(co)         -- starts, yields "first"
print("yielded:", v1)                       -- first
local _, v2 = coroutine.resume(co, "a")   -- passes "a", yields "second"
print("yielded:", v2)                       -- second
coroutine.resume(co, "b")                   -- passes "b", coroutine ends

Pikatarkistus

Miksi arvoiksi muuttuvat kutsulle coroutine.yield(v1, v2) välitetyt arvot?

Vastaa interaktiivisessa oppitunnissa

Kertaus: resume ja yield

Yhteenveto:

Ensimmäisen resume-kutsun argumentit → korutiinin rungon parametrit
Seuraavien resume-kutsujen argumentit → edellisen yield()-kutsun palauttamat arvot
yield-kutsun argumentit → yield-kutsun käynnistäneen resume()-kutsun palauttamat arvot
Kaksisuuntaisuus: jokainen resume/yield on tiedonvaihto
yield toimii myös mistä tahansa sisäkkäisestä funktiosta
Korutiinit ovat yhteistoiminnallisia, eivät rinnakkaisia

Aloita maksutta

Opi Lua tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 40
Oppitunnit: 159

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”resume ja yield” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Lua Academy-oppimispolun 3 oppituntia, myös oppitunnin “resume ja yield”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Lua Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”resume ja yield”?

Vaihtakaa tietoja kutsujan ja korutiinin välillä resume- ja yield-funktioilla. Harjoittelet Lua Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni Lua Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin Lua Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”resume ja yield”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä Lua Academy-oppitunnilla?

Kyllä. Jokainen Lua Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

← Takaisin: Lua Academy