Lua Academy · Pelajaran

Membuat Coroutine

Buat coroutine dengan coroutine.create dan coroutine.wrap.

Membuat Coroutine adalah pelajaran Lua Academy gratis di CoddyKit. Ini adalah pelajaran 1 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.

Apa Itu Coroutine?

Coroutine adalah fungsi yang dapat menghentikan eksekusinya (yield) dan kemudian melanjutkan kembali dari tempat terakhir berhenti. Tidak seperti utas, coroutine bersifat kooperatif—hanya satu yang berjalan pada satu waktu, dan coroutine secara eksplisit menyerahkan kendali. Coroutine Lua memiliki tumpukan dan variabel lokalnya sendiri.

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

coroutine.create(fn) membuat coroutine dan mengembalikan objek coroutine (bertipe thread). coroutine.wrap(fn) membuat coroutine dan mengembalikan fungsi yang, saat dipanggil, melanjutkan coroutine tersebut. wrap lebih sederhana, tetapi menyembunyikan objek 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

Siklus Hidup Coroutine

Coroutine memiliki empat status: suspended (tidak berjalan), running (sedang dieksekusi), dead (telah mengembalikan nilai atau mengalami kesalahan), dan normal (dijeda karena melanjutkan coroutine lain). Periksa status dengan 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

Menjalankan Beberapa Coroutine

Buat beberapa coroutine dan jalankan secara berselang-seling dengan melanjutkan masing-masing secara bergantian. Hal ini menyimulasikan eksekusi serentak (multitugas kooperatif). Setiap coroutine mempertahankan statusnya sendiri di antara operasi 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

Iterasi coroutine.wrap

coroutine.wrap sering digunakan untuk membuat iterator. Fungsi yang dikembalikan dipanggil setiap kali iterator maju. Saat isi coroutine berakhir, fungsi tersebut menghasilkan kesalahan—gunakan pcall atau periksa status jika diperlukan.

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

Kesalahan dalam Coroutine

Jika coroutine menghasilkan kesalahan, coroutine.resume mengembalikan false yang diikuti pesan kesalahan. Coroutine berpindah ke status dead. Coroutine yang sudah mati tidak dapat dilanjutkan lagi.

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

Identitas Coroutine

coroutine.running() mengembalikan coroutine yang sedang berjalan dan nilai boolean yang menunjukkan apakah coroutine tersebut adalah utas utama. Gunakan ini di dalam coroutine untuk memperoleh referensi ke dirinya sendiri.

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

Generator Tak Terbatas

Isi coroutine dapat memuat perulangan tak terbatas dengan operasi yield di dalamnya—generator menghasilkan nilai sesuai permintaan tanpa berhenti. Ini adalah salah satu penggunaan utama: rangkaian malas yang tak terbatas.

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

Penjadwal tugas dasar: simpan coroutine dalam antrean dan lanjutkan masing-masing secara bergantian. Saat coroutine melakukan yield, coroutine tersebut kembali ke antrean. Saat coroutine mati, coroutine tersebut dihapus. Ini adalah penjadwal kooperatif minimal.

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

Memori Korutin

Setiap korutin memiliki stack-nya sendiri. Stack dapat membesar jika rantai pemanggilan sangat dalam. Dalam skenario yang membutuhkan performa tinggi, hindari membuat ribuan korutin yang aktif secara bersamaan. Gunakan kembali korutin jika memungkinkan, atau gunakan pool.

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

Pemeriksaan Singkat

Dalam keadaan apa korutin berada tepat setelah coroutine.create(fn)?

Ringkasan: Membuat Korutin

Ringkasan:

coroutine.create(fn) → objek korutin; wrap(fn) → fungsi yang dapat dilanjutkan
Keadaan: ditangguhkan → berjalan → ditangguhkan/mati
coroutine.resume(co, ...) memulai/melanjutkan
Kesalahan selama resume: false + pesan kesalahan; korutin → mati
Generator tak terbatas melalui while true do yield() end
Gunakan untuk multitugas kooperatif dan urutan malas

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Membuat Coroutine” gratis?

Ya — teks lengkap “Membuat 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 “Membuat Coroutine”?

Buat coroutine dengan coroutine.create dan coroutine.wrap. 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 1 dari 4.

Berapa lama pelajaran “Membuat 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