Lua Academy · Pelajaran

Status Coroutine

Periksa keadaan coroutine dengan coroutine.status: running, suspended, dead.

Status Coroutine adalah pelajaran Lua Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Lua Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Lua Academy mencakup 4 pelajaran total.

Empat Keadaan Korutin

Korutin memiliki empat kemungkinan keadaan: ditangguhkan (baru dibuat atau melakukan yield, menunggu untuk dijalankan), berjalan (sedang dieksekusi), normal (dijeda agar korutin lain dapat berjalan), dan mati (selesai atau mengalami kesalahan). Lakukan kueri dengan 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

Keadaan "normal"

Korutin memasuki keadaan "normal" saat melanjutkan korutin lain. Korutin tersebut tidak sedang berjalan (korutin lain yang sedang berjalan), tetapi juga tidak ditangguhkan — korutin tersebut menunggu korutin yang dilanjutkan melakukan yield. Keadaan ini jarang terjadi, tetapi penting dipahami untuk graf korutin yang kompleks.

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

Memeriksa Sebelum Resume

Selalu periksa status korutin sebelum melanjutkannya, terutama di dalam perulangan. Melanjutkan korutin yang mati merupakan kesalahan. Melanjutkan korutin yang sedang berjalan juga merupakan kesalahan (dapat menyebabkan rekursi tak terbatas).

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

Status Setelah Kesalahan

Saat badan korutin memunculkan kesalahan yang tidak tertangkap, coroutine.resume mengembalikan false dan pesan kesalahan. Korutin berpindah ke keadaan "mati". Korutin tersebut tidak dapat dimulai ulang — Anda harus membuat korutin baru jika ingin mencoba lagi.

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() mengembalikan true jika korutin yang sedang berjalan dapat melakukan yield. Fungsi ini mengembalikan false pada thread utama dan pada fungsi C yang tidak mendukung yield. Selalu periksa sebelum melakukan yield jika Anda tidak yakin dengan konteksnya.

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

Memantau Sekumpulan Korutin

Lacak pool korutin, lalu hapus korutin yang mati setelah setiap putaran resume. Ini merupakan dasar penjadwal tugas.

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

Men-debug Korutin

Gunakan pemeriksaan status untuk melakukan instrumentasi dan men-debug kode berbasis korutin. Cetak perubahan status untuk memahami alurnya. Dalam sistem yang kompleks, berikan nama kepada korutin melalui tabel pembungkus agar keluaran pen-debugan lebih mudah dipahami.

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

Memulai Ulang Korutin yang Mati

Setelah korutin mati, korutin tersebut tidak dapat dilanjutkan. Untuk "memulai ulang" korutin, Anda harus membuat korutin baru dari fungsi yang sama. Pola yang umum digunakan adalah factory yang membuat korutin baru saat diperlukan.

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

Perilaku Kesalahan Coroutine.wrap

Saat korutin yang dibungkus mengalami kesalahan, kesalahan tersebut diteruskan keluar dari pemanggilan fungsi pembungkus. Berbeda dengan coroutine.resume yang mengembalikan false+error, fungsi yang dikembalikan oleh wrap memunculkan kesalahan secara langsung. Gunakan pcall di sekitar pemanggilan wrap jika Anda perlu menangkap kesalahan.

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

Ada dua cara untuk menginspeksi konteks korutin: coroutine.status(co) memberikan keadaan korutin tertentu; coroutine.isyieldable() memberi tahu apakah konteks eksekusi saat ini dapat melakukan yield. Gunakan status untuk memeriksa korutin lain; gunakan isyieldable untuk memeriksa apakah Anda dapat melakukan yield dengan aman.

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

Pemeriksaan Singkat

Keadaan apa yang dimasuki korutin setelah selesai mengeksekusi fungsi badannya?

Ringkasan: Status Korutin

Ringkasan:

Keadaan: ditangguhkan → berjalan ↔ normal → mati
coroutine.status(co) mengembalikan teks keadaan
Mati = selesai atau mengalami kesalahan; tidak dapat dilanjutkan
coroutine.isyieldable() memeriksa apakah konteks saat ini dapat melakukan yield
Selalu periksa status sebelum melanjutkan korutin di dalam perulangan
Kesalahan wrap diteruskan secara langsung; resume mengembalikan false+err

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Status Coroutine” gratis?

Ya — teks lengkap “Status Coroutine” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Lua Academy, upgrade ke CoddyKit PRO. Kursus Lua Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Status Coroutine”?

Periksa keadaan coroutine dengan coroutine.status: running, suspended, dead. Kamu berlatih Lua Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Lua Academy?

Tidak diperlukan pengalaman sebelumnya. Lua Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Status Coroutine” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Lua Academy ini?

Ya. Setiap pelajaran Lua Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Lua Academy