0Pricing
Lua Academy · Aula

Evitando vazamentos de memória

Conheça padrões comuns de vazamento no Lua e estratégias para evitá-los.

Evitando vazamentos de memória é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 4 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 vazamento de memória em Lua?

Um vazamento de memória ocorre quando objetos se acumulam na memória porque uma referência impede que o GC os colete, embora o programa não precise mais deles.

Vazamento comum: acúmulo global

Armazenar objetos em uma tabela global sem removê-los é um vazamento clássico. A tabela global é sempre uma raiz do GC.

local cache = {}  -- global-like upvalue
function storeResult(key, val)
  cache[key] = val  -- never evicted!
end

Correção: cache limitado

Limite o tamanho do cache e remova entradas antigas usando uma estratégia LRU ou um limite de tamanho simples.

local MAX = 100
local function boundedStore(cache, key, val)
  if #cache >= MAX then
    table.remove(cache, 1)  -- evict oldest
  end
  cache[key] = val
end

Vazamento comum: ouvintes de eventos

Registrar uma closure como ouvinte de eventos e nunca cancelar seu registro mantém a closure e seus upvalues ativos.

local listeners = {}
function on(event, fn)
  listeners[event] = listeners[event] or {}
  listeners[event][#listeners[event]+1] = fn
end
-- Always provide off() to deregister!

Correção: tabelas fracas de ouvintes

Armazene os ouvintes em uma tabela de valores fracos para que, se o objeto assinante for coletado, seu ouvinte seja removido automaticamente.

local listeners = setmetatable({}, {__mode = "v"})

Vazamento comum: closures que capturam tabelas grandes

Uma closure que captura uma tabela grande a mantém ativa enquanto a closure existir, mesmo que apenas uma pequena parte da tabela seja necessária.

local bigData = {-- 100MB of data --}
local fn = function()
  return bigData[1]  -- bigData stays alive!
end

Correção: extraia os valores necessários

Extraia apenas os valores necessários antes de criar a closure, para que a tabela grande possa ser coletada.

local needed = bigData[1]
bigData = nil  -- allow collection
local fn = function() return needed end

Vazamentos de corrotinas

Uma corrotina suspensa está ativa e mantém todas as suas variáveis locais. Corrotinas mortas (com status "dead") podem ser coletadas. Nunca perca o controle das corrotinas suspensas.

Acúmulo de strings

Concatenar strings em um loop com .. cria muitas strings intermediárias. Use table.concat para criar strings grandes com eficiência.

local parts = {}
for i = 1, 1000 do parts[i] = tostring(i) end
local result = table.concat(parts, ",")

Depuração de vazamentos

Use collectgarbage("count") antes e depois das operações para medir o crescimento da memória. Registre crescimentos suspeitos para restringir a origem do vazamento.

local before = collectgarbage("count")
-- ... run operation ...
collectgarbage()
local after = collectgarbage("count")
print(("Delta: %.1f KB"):format(after - before))

Ferramentas de criação de perfil

Ferramentas como luamemprof e contadores personalizados de alocação com debug.sethook podem identificar quais caminhos de código alocam mais memória.

Pergunta sobre vazamentos de memória

Qual padrão tem maior probabilidade de causar um vazamento de memória?

Recapitulação: evitando vazamentos de memória

Os vazamentos em Lua surgem de caches sem limite, ouvintes cujo registro não foi cancelado, closures que abrangem tabelas grandes e corrotinas suspensas esquecidas. Use tabelas fracas, caches limitados e collectgarbage("count") para detectar e evitar vazamentos.

Perguntas Frequentes

A aula “Evitando vazamentos de memória” é grátis?

Sim — o texto completo de “Evitando vazamentos de memória” é 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 “Evitando vazamentos de memória”?

Conheça padrões comuns de vazamento no Lua e estratégias para evitá-los. 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 4 de 4.

Quanto tempo leva a aula “Evitando vazamentos de memória”?

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

  1. Noções básicas do coletor de lixo do Lua
  2. Chaves e valores fracos
  3. Finalizadores com __gc
  4. Evitando vazamentos de memória
← Voltar para Lua Academy