Wzorzec producent-konsument
Proszę implementować potok producent-konsument z użyciem korutyn.
Wzorzec producent-konsument to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 4 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.
Wyjaśnienie wzorca
Wzorzec producent–konsument z użyciem korutyn: producent generuje dane i przekazuje każdy element za pomocą yield, a konsument odbiera elementy pojedynczo. Żaden z nich nie musi znać implementacji drugiego — komunikują się przez yield/resume. Dzięki temu generowanie danych jest oddzielone od ich przetwarzania.
local function makeProducer(items)
return coroutine.create(function()
for _, item in ipairs(items) do
coroutine.yield(item)
end
end)
end
local function consume(producer)
while true do
local ok, item = coroutine.resume(producer)
if not ok or item == nil then break end
print("Processing:", item)
end
end
consume(makeProducer({10, 20, 30, 40}))Nieskończony producent
Korutyna producenta może zwracać nieskończoną sekwencję. To konsument decyduje, kiedy zakończyć działanie. Doskonale sprawdza się to w przypadku strumieniowych źródeł danych, takich jak odczyty z czujników, zdarzenia w dziennikach czy generowane sekwencje.
local function primes()
return coroutine.wrap(function()
local function isPrime(n)
if n<2 then return false end
for i=2, math.floor(math.sqrt(n)) do
if n%i==0 then return false end
end
return true
end
local n = 2
while true do
if isPrime(n) then coroutine.yield(n) end
n = n + 1
end
end)
end
local gen = primes()
for i = 1, 10 do
io.write(gen() .. " ")
end
print() -- 2 3 5 7 11 13 17 19 23 29Konsument jako korutyna
Konsument również może być korutyną, tworząc w pełni symetryczną parę producent–konsument. Trzecia funkcja, „sterownik”, koordynuje działanie obu korutyn. Jest to przydatne w buforowanych potokach, w których producent i konsument działają z różną szybkością.
local function producer()
return coroutine.create(function(consumer)
for i = 1, 5 do
coroutine.resume(consumer, i * 10)
coroutine.yield() -- wait
end
end)
end
local consumer = coroutine.create(function()
while true do
local val = coroutine.yield()
print("Received:", val)
end
end)
coroutine.resume(consumer) -- start, waits for data
local pro = producer()
for i = 1, 5 do
coroutine.resume(pro, consumer)
endBackpressure
Backpressure występuje, gdy konsument sygnalizuje producentowi, aby zwolnił. W przypadku korutyn dzieje się to naturalnie: producent wykonuje yield po każdym elemencie i czeka, aż konsument zażąda następnego. Jeśli konsument działa wolno, producent po prostu czeka.
local function slowConsumer(gen)
for v in gen do
-- Simulate slow processing
print("Processing", v, "...")
-- In real code: os.execute("sleep 0.1")
end
end
local function fastProducer(n)
return coroutine.wrap(function()
for i = 1, n do
print("Producing", i)
coroutine.yield(i)
end
end)
end
-- Producer automatically waits for consumer:
slowConsumer(fastProducer(4))Przetwarzanie pakietowe
Producent pakietowy zbiera N elementów przed wykonaniem yield z całym pakietem. Konsument odbiera i przetwarza kompletne pakiety. Zmniejsza to narzut koordynacji w przypadku producentów generujących dane z dużą częstotliwością.
local function batchProducer(items, batchSize)
return coroutine.wrap(function()
local batch = {}
for _, item in ipairs(items) do
batch[#batch+1] = item
if #batch >= batchSize then
coroutine.yield(batch)
batch = {}
end
end
if #batch > 0 then coroutine.yield(batch) end
end)
end
local data = {1,2,3,4,5,6,7,8,9,10}
for batch in batchProducer(data, 3) do
print("Batch:", table.concat(batch, ","))
end
-- Batch: 1,2,3
-- Batch: 4,5,6
-- Batch: 7,8,9
-- Batch: 10Producent wierszy pliku
Plik można odczytywać leniwie: korutyna producenta odczytuje wiersze pojedynczo i przekazuje każdy z nich za pomocą yield. Konsument przetwarza wiersze bez wczytywania całego pliku do pamięci.
local function lineProducer(path)
return coroutine.wrap(function()
local f = io.open(path, "r")
if not f then return end
for line in f:lines() do
coroutine.yield(line)
end
f:close()
end)
end
-- Process file line by line without loading all at once
local wordCount = 0
for line in lineProducer("data.txt") do
for _ in line:gmatch("%S+") do
wordCount = wordCount + 1
end
end
print("Words:", wordCount)Etap transformacji
Między producentem a konsumentem można umieścić etap transformacji. Transformacja odczytuje dane z jednej korutyny i przekazuje przetworzone wartości do następnej za pomocą yield. Łącząc takie etapy, można budować potoki danych.
local function transform(source, fn)
return coroutine.wrap(function()
for v in source do
coroutine.yield(fn(v))
end
end)
end
local numbers = coroutine.wrap(function()
for i = 1, 6 do coroutine.yield(i) end
end)
local doubled = transform(numbers, function(n) return n*2 end)
local filtered = coroutine.wrap(function()
for v in doubled do
if v > 4 then coroutine.yield(v) end
end
end)
for v in filtered do io.write(v.." ") end
print() -- 6 8 10 12Propagacja błędów w potokach
Błędy w potokach korutyn propagują się przez stan zakończenia albo za pomocą pcall. Należy opakować etapy potoku w pcall, aby przechwytywać błędy i obsługiwać je bezpiecznie, bez przerywania działania całego potoku.
local function safeStage(source, fn)
return coroutine.wrap(function()
for v in source do
local ok, result = pcall(fn, v)
if ok then
coroutine.yield(result)
else
print("Error processing", v, ":", result)
end
end
end)
end
local data = coroutine.wrap(function()
for _, v in ipairs({4, -1, 9, 0, 16}) do coroutine.yield(v) end
end)
local results = safeStage(data, function(n)
assert(n > 0, "non-positive")
return math.sqrt(n)
end)
for v in results do print(v) endŁączenie producentów
Można połączyć wielu producentów w jednego: należy cyklicznie wybierać spośród wszystkich aktywnych producentów i kolejno przekazywać elementy każdego z nich. Należy zakończyć działanie, gdy wszyscy producenci wyczerpią dane.
local function merge(...)
local producers = {...}
return coroutine.wrap(function()
while #producers > 0 do
local alive = {}
for _, co in ipairs(producers) do
local ok, v = coroutine.resume(co)
if ok and v ~= nil then
coroutine.yield(v)
alive[#alive+1] = co
end
end
producers = alive
end
end)
end
local function src(items)
return coroutine.create(function()
for _,v in ipairs(items) do coroutine.yield(v) end
end)
end
for v in merge(src({1,3,5}),src({2,4,6})) do
io.write(v.." ")
end
print() -- 1 2 3 4 5 6Przykład z praktyki
Potok przetwarzania dzienników: producent odczytuje wiersze dziennika, etap filtrowania pozostawia tylko wiersze z błędami, etap transformacji wyodrębnia najważniejsze informacje, a konsument grupuje dane według typu błędu. Każdy etap jest niezależną korutyną, którą można testować osobno.
local function makeFilter(src, pred)
return coroutine.wrap(function()
for line in src do
if pred(line) then coroutine.yield(line) end
end
end)
end
local logs = coroutine.wrap(function()
local entries = {
"INFO: started",
"ERROR: timeout",
"DEBUG: connecting",
"ERROR: auth failed",
}
for _, e in ipairs(entries) do coroutine.yield(e) end
end)
local errors = makeFilter(logs, function(l) return l:match("^ERROR") end)
for line in errors do print(line) end
-- ERROR: timeout
-- ERROR: auth failedSzybkie sprawdzenie
W jaki sposób wzorzec producent–konsument oparty na korutynach obsługuje backpressure?
Podsumowanie: producent–konsument
Podsumowanie:
- Producent przekazuje elementy za pomocą yield; konsument steruje działaniem, wywołując resume
- Nieskończeni producenci:
while true do yield() end - Potoki: między producentem a konsumentem należy łączyć korutyny transformujące
- Backpressure jest obsługiwany automatycznie: producent czeka na konsumenta
- Etapy grupowania, filtrowania i łączenia jako opakowania korutyn
- W etapach potoku należy używać pcall, aby izolować błędy
Często zadawane pytania
Czy lekcja „Wzorzec producent-konsument” jest bezpłatna?
Tak — pełny tekst „Wzorzec producent-konsument” 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 „Wzorzec producent-konsument”?
Proszę implementować potok producent-konsument z użyciem korutyn. Ć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 4 z 4.
Ile czasu zajmuje lekcja „Wzorzec producent-konsument”?
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
- Tworzenie korutyn
- resume i yield
- Stan korutyny
- Wzorzec producent-konsument