0Pricing
Lua Academy · Lezione

Prevenzione delle perdite di memoria

Riconosca i pattern comuni delle perdite di memoria in Lua e le strategie per prevenirle.

Prevenzione delle perdite di memoria è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Che cos'è una perdita di memoria in Lua?

Si verifica una perdita di memoria quando gli oggetti si accumulano in memoria perché un riferimento impedisce al GC di raccoglierli, anche se il programma non ne ha più bisogno.

Perdita comune: accumulo globale

Memorizzare oggetti in una tabella globale senza rimuoverli è una classica perdita di memoria. La tabella globale è sempre una radice del GC.

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

Correzione: cache a dimensione limitata

Limiti la dimensione della cache ed elimini le voci meno recenti utilizzando una strategia LRU o un semplice limite dimensionale.

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

Perdita comune: listener di eventi

Registrare una closure come listener di eventi senza mai rimuoverla mantiene in vita sia la closure sia i suoi upvalue.

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

Correzione: tabelle di listener deboli

Memorizzi i listener in una tabella a valori deboli, in modo che, se l'oggetto sottoscrittore viene raccolto, il relativo listener venga rimosso automaticamente.

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

Perdita comune: closure che acquisiscono tabelle grandi

Una closure che acquisisce una tabella grande la mantiene in vita finché la closure esiste, anche se serve solo una piccola parte della tabella.

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

Correzione: estrarre i valori necessari

Estragga solo i valori necessari prima di creare la closure, così la tabella grande potrà essere raccolta.

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

Perdite nelle coroutine

Una coroutine sospesa è in vita e mantiene tutte le proprie variabili locali. Le coroutine terminate, con stato "dead", possono essere raccolte. Non perda mai il riferimento alle coroutine sospese.

Accumulo di stringhe

Concatenare stringhe in un ciclo con .. crea molte stringhe intermedie. Utilizzi table.concat per costruire grandi stringhe in modo efficiente.

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

Debug delle perdite di memoria

Utilizzi collectgarbage("count") prima e dopo le operazioni per misurare la crescita della memoria. Registri la crescita sospetta per restringere la ricerca dell'origine della perdita.

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

Strumenti di profilazione

Strumenti come luamemprof e contatori personalizzati delle allocazioni basati su debug.sethook possono individuare i percorsi del codice che allocano più memoria.

Domanda sulle perdite di memoria

Quale schema è più probabilmente causa di una perdita di memoria?

Riepilogo: evitare le perdite di memoria

In Lua, le perdite derivano da cache senza limiti, listener non rimossi, closure che acquisiscono tabelle grandi e coroutine sospese dimenticate. Utilizzi tabelle deboli, cache a dimensione limitata e collectgarbage("count") per rilevare e prevenire le perdite.

Domande Frequenti

La lezione «Prevenzione delle perdite di memoria» è gratuita?

Sì — il testo completo di «Prevenzione delle perdite di memoria» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Prevenzione delle perdite di memoria»?

Riconosca i pattern comuni delle perdite di memoria in Lua e le strategie per prevenirle. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Prevenzione delle perdite di memoria»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Nozioni di base sul garbage collector di Lua
  2. Chiavi e valori deboli
  3. Finalizzatori con __gc
  4. Prevenzione delle perdite di memoria
← Torna a Lua Academy