Lua Academy · Aula

Criando um laço de eventos simples

Implemente um agendador de corrotinas com fila de execução e laço de retomada.

Criando um laço de eventos simples é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

O que é um ciclo de eventos?

Um ciclo de eventos executa um agendador que retoma corrotinas quando os eventos aguardados estão prontos. Ele permite várias tarefas simultâneas sem linhas de execução do OS.

A fila de execução

Comece com uma fila de corrotinas prontas. A cada ciclo, processe todas as corrotinas prontas, uma por uma.

local queue = {}
local function spawn(fn)
  queue[#queue+1] = coroutine.create(fn)
end

O ciclo de execução

A cada ciclo, retire e retome cada corrotina pronta. As corrotinas que usam yield ficam pausadas até serem adicionadas novamente à fila.

local function runLoop()
  while #queue > 0 do
    local current = queue
    queue = {}
    for _, co in ipairs(current) do
      local ok, err = coroutine.resume(co)
      if not ok then print("Error:", err) end
      if coroutine.status(co) ~= "dead" then
        queue[#queue+1] = co  -- re-queue if still alive
      end
    end
  end
end

Usando yield para pausar

Uma corrotina usa yield quando precisa esperar. O agendador a retoma no próximo ciclo.

spawn(function()
  print("Task A: step 1")
  coroutine.yield()  -- pause
  print("Task A: step 2")
end)
spawn(function()
  print("Task B: only step")
end)
runLoop()

Atrasos simulados

Implemente uma espera acompanhando quando uma corrotina deve ser reativada.

local timers = {}
local function sleep(seconds)
  local wakeAt = os.clock() + seconds
  timers[coroutine.running()] = wakeAt
  coroutine.yield()
end

Ciclo com temporizadores

A cada ciclo, verifique os temporizadores e coloque novamente na fila as corrotinas cujo horário de ativação já passou.

local function timedLoop()
  while #queue > 0 or next(timers) do
    local now = os.clock()
    for co, wakeAt in pairs(timers) do
      if now >= wakeAt then
        timers[co] = nil
        queue[#queue+1] = co
      end
    end
    -- process queue...
  end
end

Integração com E/S

Integre um mecanismo de seleção/sondagem: suspenda as corrotinas que aguardam E/S e retome-as quando o descritor de arquivo estiver pronto.

Isolamento de erros

Envolva cada retomada de corrotina em uma chamada protegida ou verifique o valor de retorno positivo. Uma corrotina que falha não deve derrubar todo o ciclo.

Agendamento cooperativo

As tarefas devem usar yield voluntariamente. Uma corrotina que executa para sempre sem usar yield impedirá o progresso de todas as outras. Use debug.sethook com um contador de etapas como proteção contra preempção para código não confiável.

Prioridades das tarefas

Implemente várias filas (prioridade alta/normal/baixa) e esvazie primeiro as filas de maior prioridade a cada ciclo.

Alternativas do mundo real

Ciclos de eventos para produção: luv (vinculações de libuv), copas (baseado em soquetes), OpenResty (nginx + soquetes cooperativos). Crie sua própria solução apenas para aprendizado ou uso incorporado.

Pergunta sobre ciclos de eventos

Por que as corrotinas em um ciclo de eventos cooperativo devem usar yield voluntariamente?

Recapitulação: ciclo de eventos simples

Um ciclo de eventos usa uma fila de execução de corrotinas. A cada ciclo, retoma as corrotinas prontas. As tarefas usam yield para pausar e são colocadas novamente na fila quando sua condição é atendida. Isso permite E/S simultânea e temporizadores em Lua com uma única linha de execução.

Perguntas Frequentes

A aula “Criando um laço de eventos simples” é grátis?

Sim — o texto completo de “Criando um laço de eventos simples” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Criando um laço de eventos simples”?

Implemente um agendador de corrotinas com fila de execução e laço de retomada. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Criando um laço de eventos simples”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Lua Academy