Lua Academy · Aula

Async/await com corrotinas

Crie auxiliares async() e await() que suspendam e retomem corrotinas.

Async/await com corrotinas é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 2 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.

A ideia de assíncrono/await

Assíncrono/await é um modelo de programação no qual as operações assíncronas parecem código síncrono. Em Lua, as corrotinas fornecem naturalmente o mecanismo de yield/resume para implementar esse modelo.

Função await

await(future) suspende a corrotina atual e armazena um retorno de chamada que a retoma quando o futuro é concluído.

local function await(future)
  local co = coroutine.running()
  future.onComplete = function(result)
    coroutine.resume(co, result)
  end
  return coroutine.yield()
end

Invólucro de função assíncrona

async(fn) envolve uma função para que ela seja executada em uma nova corrotina gerenciada pelo agendador.

local function async(fn)
  return function(...)
    local co = coroutine.create(fn)
    local ok, err = coroutine.resume(co, ...)
    if not ok then print("async error:", err) end
    return co
  end
end

Objeto futuro simples

Um resultado futuro representa um resultado pendente. Conclua-o mais tarde para retomar todas as corrotinas que estão esperando.

local function newFuture()
  local f = {done=false, value=nil, waiters={}}
  f.complete = function(val)
    f.done = true; f.value = val
    for _, cb in ipairs(f.waiters) do cb(val) end
  end
  f.andThen = function(cb)
    if f.done then cb(f.value)
    else f.waiters[#f.waiters+1] = cb end
  end
  return f
end

await na prática

Escreva código assíncrono com aparência sequencial que internamente usa yield e resume.

local fetchData = async(function(url)
  local result = await(httpGet(url))  -- yields
  local parsed = await(parseJSON(result))  -- yields again
  print("Got:", parsed.name)
end)
fetchData("http://example.com/api")

Propagação de erros

Propague os erros pelo resultado futuro: se a operação falhar, retome a corrotina com um sinalizador de erro e a mensagem de erro.

local function awaitSafe(future)
  local co = coroutine.running()
  future.onComplete = function(ok, result)
    coroutine.resume(co, ok, result)
  end
  return coroutine.yield()
end

Sequencial versus paralelo

Use await em sequência para operações dependentes. Para operações independentes, inicie ambas as corrotinas e aguarde um futuro de junção.

Padrão Promise.all

Execute várias tarefas assíncronas e aguarde a conclusão de todas usando um futuro contador.

local function all(futures)
  local results = {}
  local count = #futures
  local combined = newFuture()
  for i, f in ipairs(futures) do
    f:andThen(function(v)
      results[i] = v
      count = count - 1
      if count == 0 then combined.complete(results) end
    end)
  end
  return combined
end

Cancelamento

Implemente o cancelamento marcando a corrotina como cancelada antes de retomá-la. A corrotina verifica a marca e retorna antecipadamente.

Integração com E/S

Integre E/S não bloqueante: quando uma chamada de E/S bloquearia, use yield e registre um retorno de chamada para retomar a execução quando os dados estiverem disponíveis.

Comparação com o estilo de retornos de chamada

O modelo assíncrono/await com corrotinas é muito mais legível do que retornos de chamada aninhados. O tratamento de erros com chamadas protegidas também é mais simples do que usar parâmetros de erro em retornos de chamada.

Pergunta sobre assíncrono/await

O que await(future) faz em um sistema assíncrono baseado em corrotinas?

Recapitulação: assíncrono/await com corrotinas

Implemente assíncrono/await com corrotinas envolvendo operações assíncronas como futuros que retomam a corrotina suspensa quando são concluídas. O resultado é um código com aparência sequencial, mas que na verdade não bloqueia a execução.

Perguntas Frequentes

A aula “Async/await com corrotinas” é grátis?

Sim — o texto completo de “Async/await com corrotinas” é 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 “Async/await com corrotinas”?

Crie auxiliares async() e await() que suspendam e retomem corrotinas. 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 2 de 4.

Quanto tempo leva a aula “Async/await com corrotinas”?

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