Lua Academy · Ders

Coroutine Durumu

Coroutine durumunu coroutine.status ile denetleyin: running, suspended, dead.

Coroutine Durumu, CoddyKit'te ücretsiz bir Lua Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Lua Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Lua Academy kursu toplamda 4 dersten oluşur.

Dört Coroutine Durumu

Coroutine'lerin dört olası durumu vardır: askıya alınmış (oluşturulmuş veya yield edilmiş, çalışmayı bekliyor), çalışıyor (şu anda yürütülüyor), normal (başka bir coroutine'in çalışmasına izin vermek için duraklatılmış) ve ölü (tamamlanmış veya hata oluşmuş). coroutine.status(co) ile sorgulayın.

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

"normal" Durumu

Bir coroutine başka bir coroutine'i resume ettiğinde "normal" durumuna girer. Çalışıyor değildir (diğer coroutine çalışıyordur), ancak askıya alınmış da değildir; resume edilen coroutine'in yield etmesini bekler. Bu durum nadirdir, ancak karmaşık coroutine grafiklerini anlamak için önemlidir.

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

Resume Öncesi Kontrol

Özellikle döngülerde, resume etmeden önce her zaman bir coroutine'in durumunu kontrol edin. Ölü bir coroutine'i resume etmek hatadır. Çalışan bir coroutine'i resume etmek de hatadır (sonsuz özyinelemeye neden olur).

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

Hata Sonrası Durum

Bir coroutine gövdesi yakalanmamış bir hata oluşturduğunda coroutine.resume false ve hata iletisini döndürür. Coroutine "ölü" durumuna geçer. Yeniden başlatılamaz; yeniden denemek istiyorsanız yeni bir coroutine oluşturmanız gerekir.

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(), çalışan coroutine'in yield edip edemediğini belirtmek için true döndürür. Ana iş parçacığında ve yield işlemini desteklemeyen C işlevlerinde false döndürür. Bağlamdan emin değilseniz yield etmeden önce her zaman kontrol edin.

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

Bir Coroutine Kümesini İzleme

Bir coroutine havuzunu izleyin ve her resume turundan sonra ölü olanları kaldırın. Bu, bir görev zamanlayıcısının temelini oluşturur.

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

Coroutine Hatalarını Ayıklama

Coroutine tabanlı kodu izlemek ve hatalarını ayıklamak için durum kontrollerini kullanın. Akışı anlamak için durum geçişlerini yazdırın. Karmaşık sistemlerde, hata ayıklama çıktısını daha anlaşılır hâle getirmek için bir sarmalayıcı tablosu aracılığıyla coroutine'lere adlar atayın.

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

Ölü Coroutine'leri Yeniden Başlatma

Bir coroutine öldüğünde yeniden resume edilemez. Onu "yeniden başlatmak" için aynı işlevden yeni bir coroutine oluşturmanız gerekir. Yaygın bir kalıp, gerektiğinde taze bir coroutine oluşturan fabrikadır.

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

Coroutine.wrap Hata Davranışı

Sarmalanmış bir coroutine hata verdiğinde hata, sarmalayıcı işlev çağrısının dışına yayılır. false+hata döndüren coroutine.resume'dan farklı olarak wrap tarafından döndürülen işlevler hatayı doğrudan oluşturur. Hataları yakalamanız gerekiyorsa wrap çağrılarının çevresinde pcall kullanın.

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

Coroutine bağlamını incelemenin iki yolu vardır: coroutine.status(co) belirli bir coroutine'in durumunu verir; coroutine.isyieldable() ise geçerli yürütme bağlamının yield edip edemeyeceğini belirtir. Diğer coroutine'leri kontrol etmek için status, güvenli biçimde yield edip edemeyeceğinizi kontrol etmek için isyieldable kullanın.

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

Hızlı Kontrol

Bir coroutine gövde işlevini yürütmeyi bitirdiğinde hangi duruma girer?

Özet: Coroutine Durumu

Özet:

Durumlar: askıya alınmış → çalışıyor ↔ normal → ölü
coroutine.status(co) durum dizesini döndürür
Ölü = tamamlanmış veya hata oluşmuş; resume edilemez
coroutine.isyieldable() geçerli bağlamın yield edip edemeyeceğini kontrol eder
Döngülerde resume etmeden önce her zaman durumu kontrol edin
wrap hataları doğrudan yayar; resume false+hata döndürür

Sıkça Sorulan Sorular

“Coroutine Durumu” dersi ücretsiz mi?

Evet — “Coroutine Durumu” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Lua Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Lua Academy kursu toplamda 4 dersten oluşur.

“Coroutine Durumu” dersinde ne öğreneceğim?

Coroutine durumunu coroutine.status ile denetleyin: running, suspended, dead. Lua Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Lua Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Lua Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“Coroutine Durumu” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Lua Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Lua Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Lua Academy Sayfasına Dön