Lua语言使用自动内存管理。程序可以创建对象，但却没有函数来删除对象。Lua语言通过垃圾收集自动删除称为垃圾的对象，从而将程序员从内存管理的绝大部分负担中解放出来。

更重要的是，将程序员从与内存管理相关的大多数Bug中解放出来。例如无效指针和内存泄露等问题。
在一个理想的环境中，垃圾收集器对程序员来说是不可见的，就像一个好的清洁工不会和其他工人打交道一样。不过，有时即使是智能的垃圾收集器也会需要我们的辅助。在某些关键的性能阶段，我们可能需要将其停止，或者让只在特定的时间运行。另外，一个垃圾收集器只能收集它确定是垃圾的内容，而不能猜测我们把什么当作垃圾。没有垃圾收集器能够做到让我们完全不用操心资源管理的问题，比如驻留内存和外部资源。
弱引用表、析构器和函数collectgarbage是在Lua语言中用来辅助垃圾收集器的主要机制。弱引用表允许收集Lua语言中还可以被程序访问的对象；析构器允许收集不在垃圾收集器直接控制下的外部对象；函数collectgarbage则允许我们控制垃圾收集器的步长。

弱引用表

我们知道，数组的有效部分总是向顶部扩展的，但Lua语言却不知道。如果弹出一个元素时只是简单地递减顶部索引，那么这个仍然留在数组中的对象对于Lua语言来说并不是垃圾。同理，即使是程序不会再用到的、存储在全局变量中的对象，对于Lua语言来说也不是垃圾。在这两种情况下，都需要我们将这些对象所在的位置赋值为nil，以便这些位置不会锁定可释放的对象。
不过，简单地清除引用可能还不够。在有些情况下，还需要程序和垃圾收集器之间的协作。一个典型的例子是，当我们要保存某些类型的活跃对象的列表时。这个需要看上去简单，我们只需要把每个新对象插入数组即可；但是，一旦一个对象成为了数组的一部分，它就再也无法被回收！虽然已经没有其他任何地方在引用它，但数组依然在引用它。除非我们告诉Lua语言数组对该对象的引用不应该阻碍对此对象的回收，否则Lua语言本身是无从知晓的。
弱引用表就是这样一个用来告知Lua语言一个引用不应阻止一个对象回收的机制。所谓所引用是一种不在垃圾收集器考虑范围内的对象引用。如果一个对象的所有引用都是弱引用，弱引用表就是元素均为弱引用的表，这意味着如果一个对象只被一个弱引用持有，那么Lua语言最终会回收这个对象。
表由键值对组成，其两者都可以容纳任何类型的对象。在正常情况下，垃圾收集器不会回收一个在可访问的表中作为键或值的对象。也就是说，键和值都是强引用，它们会阻止对其所指向对象的回收。在一个弱引用表中，键和值都可以是弱引用的。这就意味着有三种类型的弱引用表，即具有弱引用键的表、具有弱引用值的表及同时具有弱引用键和值的表。不论是哪种类型的弱引用表，只要有一个键或值被回收了，那么对应的整个键值对都会被从表中删除。
一个表是否为弱引用表是由其元表中的__mode字段决定的。当这个字段存在时，其值应为一个字符串：如果这个字符串是”k”，那么这个表的键是弱引用的；如果这个字符串是”v”，那么这个表的值是弱引用的；如果这个字符串是”kv”，那么这个表的键和值都是弱引用的。下面的示例虽然有些可以，但演示了弱引用表的基本行为：

1
2
3
4
5
6
7
8
9

a = {}
mt = {__mode = "k"}
setmetatable(a,mt)		-- 现在'a'的键是弱引用的了
key = {}
a[key] = 1				-- 创建第一个键
key = {}
a[key] = 2				-- 创建第二个键
collectgarbage()		-- 强制进行垃圾回收
for k, v in pairs(a) do print(v) end		-- 2

记忆函数

空间换时间是一种常见的编程技巧。我们可以通过记忆函数的执行结果，在后续使用相同参数再次调用该函数时直接返回之前记忆的结果，来加快函数的运行速度。
假设有一个通用的服务器，该服务器接收的请求是以字符串形式表示的Lua语言代码。每当服务器接收到一个请求时，它就对字符串运行load函数，然后再调用编译后的函数。不过，函数load的开销很昂贵，而且发送给服务器的某些命令的出现频率可能很高。这样，与其每次收到一条诸如”closeconnection()”这样的常见命令就重复地调用函数load，还不如让服务器用一个辅助表记忆所有函数load的执行结果。在调用函数load前，服务器先在表中检查指定的字符串是否已经被处理过。如果没有，就调用函数load并将返回值保存到表中。我们可以将这种行为封装为一个新的函数：

1
2
3
4
5
6
7
8
9

local results = {}
function mem_loadstring(s)
	local res = results[s]
	if res == nli then
		res = assert(laod(s))
		results[s] = res
	end
	return res
end

1
2
3
4

local results = {}
setmetatable(results,{__mode = "v"})		-- 让值称为弱引用
funciton mem_loadstring(s)
--下面内容同前

1

setmetatable(results,{__mode = "kv"})

1
2
3

function createRGB(r,g,b)
	return {red = r, green = g ,blue = b}
end

1
2
3
4
5
6
7
8
9
10
11

local results = {}
setmetatable(results,{__mode = "v"})		-- 让值称为弱引用
function createRGB( r,g,b )
	local key = string.format("%d-%d-%d",r,g,b)
	local color = results[key]
	if color == nil then
		color = {red = r, green = g, blue = b}
		results[key] = color
	end
	return color
end

对象属性

弱引用表的另外一种重要应用是将属性与对象关联起来。在各种各样的情况下，我们都需要把某种属性绑定到某个对象，例如函数名、表的默认值及数组的大小等。
当对象是一个表时，可以通过适当的唯一键把属性存储在这个表自身中。不过，如果对象不是一个表，那么它就不能保存它自己的属性。另外，即使是表，有时我们也不想把属性保存在原始的对象。例如，当想保持属性的私有性时，或不想让属性干扰表的遍历时，就需要用其他办法来关联对象和属性。
当然，外部表为对象和属性的映射提供了一种理性的方法，即对偶表示，其中将对象用作键、将对象的属性用作值。由于Lua语言允许使用任意类型的对象作为键，因此一个外部表可以保存任意类型对象的属性。此外，存储在外部表中的属性不会干扰其他对象，并且可以像表本身一样是私有的。
不过，这个看似完美的方案有一个重大缺陷：一旦我们把一个对象当作表中的一个键，那么就是引用了它。Lua语言无法回收一个正在被用作键的对象。例如，如果使用一个普通的表来映射函数和函数名，那么这些函数就永远无法被回收。

回顾具有默认值的表

在第一种解决方案中，我们使用了一个弱引用表来映射每一个表和它的默认值：

1
2
3
4
5
6
7

local defaults = {}
setmetatable(defaults,{__mode = "k"})
local mt = {__index = function(t) return defaults[t] end}
function setDefault (t,d)
	defaults[t] = d
	setmetatable(t,mt)
end

1
2
3
4
5
6
7
8
9
10

local metas = {}
setmetatable(metas,{__mode = "v"})
function setDefault(t,d)
	local mt = metas[d]
	if mt == nil then
		mt = {__index = function() return d end}
		metas[d] = mt
	end
	setmetatable(t,mt)
end

瞬表

一种棘手的情况是，一个具有弱引用键的表中的值又引用了对应的键。
这种情况看上去更加常见。一个典型的示例是常量函数工厂。这种工厂的参数是一个对象，返回值是一个被调用时返回传入对象的函数：

1
2
3

function factory(o)
	return (function() return o end)
end

示例 使用记忆技术的常量函数工厂

1 2 3 4 5 6 7 8 9 10 11 12

do local mem = {} setmetatable(mem, {__mode = "k"}) function factory(o) local res = mem[o] if not res then res = (function() return o end) mem[o] = res end return res end end

不过，这里另有玄机。请注意，表mem中与一个对象关联的值回指了它自己的键。虽然表中的键是弱引用的，但是表中的值却不是弱引用的。从一个弱引用表的标准理解看，记忆表中没有任何东西会被移除。由于值不是弱引用的，所以对于每一个函数来说都存在一个强引用。每一个函数都指向其对应的对象，因而对于每一个键来说都存在一个强应用。因此，即使有弱引用的键，这些对象也不会被回收。
不过，这种严格的理解不是特别有用。大多数人希望一个表中的值只能通过对应的键来访问。我们可以认为之前的情况是某种环，其中闭包引用了指回闭包的对象。
Lua语言通过瞬表的概念来解决上述问题。在Lua语言中，一个具有弱引用键和强引用值的表是一个瞬表。在一个顺表中，一个键的可访问性控制着对应值的可访问性。更确切地说，考虑瞬表中的一个元素，指向的v的引用只有当存在某些指向k的其他外部引用存在时才是强引用，否则，即使v引用了k，垃圾收集器最终会收集k并把元素从表中移除。

析构器

虽然垃圾收集器的目标是回收对象，但是它可以帮助程序员来释放外部资源。处于这种目的，几种编程语言提供了析构器。析构器是一个与对象关联的函数，当该对象即将被回收时该函数会被调用。
Lua语言通过元方法gc实现析构器，如下例所示：

1
2
3
4

o = {x = "hi"}
setmetatable(o,{__gc = function(o) print(o.x) end})
o = nil
collectgarbage()		-- nil

1
2
3
4
5
6

o = {x = "hi"}
mt = {}
setmetatable(o,mt)
mt.__gc = function(o) print(o.x) end
o = nil
collectgarbage()		-- (print nothing)

1
2
3
4
5
6

o = {x = "hi"}
mt = {__gc = true}
setmetatable(o,mt)
mt.__gc = function(o) print(o.x) end
o = nil
collectgarbage()		-- nil

1
2
3
4
5
6
7

mt = {__gc = function(o) print(o[1]) end}
list = nil
for i = 1 , 3 do
	list = setmetatable({i,link = list},mt)
end
list = nil
collectgarbage()

复苏必须是可传递的。考虑如下代码：

1
2
3
4
5

A = {x = "this is A"}
B = {f = A}
setmetatable(B,{__gc = function(o) print(o.f.x) end})
A,B = nil
collectgarbage() 		-- this is A

1
2
3
4
5

local t = {__gc = function()
	print("finishing Lua program")
	end}
setmetatable(t,t)
_G["*AA*"] = t

示例 在每次GC后运行一个函数

1 2 3 4 5 6 7 8 9 10 11

do local mt = {__gc = function(o) print("new cycle") setmetatable({},getmetatable(o)) end} setmetatable({},mt) end collectgarbage() -- 一次垃圾收集 collectgarbage() -- 一次垃圾收集 collectgarbage() -- 一次垃圾收集

具有析构器的对象和弱引用表之间的交互也有些微妙。在每个垃圾收集周期内，垃圾收集器会在调用析构器前清理弱应用表中的值，在调用析构器之后再清理键。这种行为的原理在于我们经常使用带有弱引用键的表来保存对象的属性，因此，析构器可能需要访问那些属性。不过，我们也会使用具有弱引用值的表来重用活跃的对象，在这种情况下，正在被析构的对象就不再有用了。

垃圾收集器

一直到Lua5.0，Lua语言使用的都是一个简单的标记-清除式垃圾收集器。这种收集器又被称为“stop-the-world（全局暂停）”式的收集器，意味着Lua语言会时不时地停止主程序的运行来执行一次完整的垃圾收集周期。每一个垃圾收集周期由四个阶段组成：标记、清理、清除和析构。
标记阶段把根节点集合标记为活跃，根结点集合由Lua语言可以直接访问的对象组成。在Lua语言中，这个集合只包括C注册表。
保存在一个活跃对象中的对象是程序可达的，因此也会被标记活跃。当所有可达对象都被标记为活跃后，标记阶段完成。
在开始清除阶段前，Lua语言先执行清理阶段，在这个阶段中处理析构器和弱引用表。首先，Lua语言遍历所有被标记为需要进行析构、但又没有被标记为活跃状态的对象。这些没有标记为活跃状态的对象会被标记为活跃，并被放在一个单独的列表中，这个列表会在析构阶段用到。然后，Lua语言遍历弱引用表并从中移除键或值未被标记的元素。
清理阶段遍历所有对象。如果一个对象没有被标记为活跃，Lua语言就将其回收，否则，Lua语言清理标记，然后准备进行下一个清理周期。
最后，在析构阶段，Lua语言调用清理阶段被分离出的对象的析构器。
使用真正的垃圾收集器意味着Lua语言能够处理对象引用之间的环。在使用环形数据结构时，我们不需要花费外的精力，它们会像其他数据一样被回收。
Lua5.1使用了增量式垃圾收集器。这种垃圾收集器像老版的垃圾收集器一样执行相同的步骤，但是不需要在垃圾收集期间停止主程序的运行。相反，它与解释器一起交替运行。每当解释器分配了一定数量的内存时，垃圾收集器也执行一小步（这意味着，在垃圾收集器工作期间，解释器可能会改变一个对象的可达性。为了保证垃圾收集器的正确性，垃圾收集器中的有些操作具有发现危险改动和纠正所涉及对象标记的内存屏障）。
Lua5.2引入了紧急垃圾收集。当内存分配失败时，Lua语言会强制进行一次完整的垃圾收集，然后再次尝试分配。这些紧急情况可以发生在Lua语言进行内存分配的任意时刻，包括Lua语言处于不一致的代码执行状态时，因此，这些收集动作不能运行析构器。

控制垃圾收集的步长

通过函数collectgarbage可以对垃圾收集器进行一些额外的控制，该函数实际上是几个函数的集合体：第一个参数是一个可选的字符串，用来说明进行何种操作；有些选项使用一个整型作为第二个参数，称为data。
第一个参数的选项包括如下七个。
“stop”:停止垃圾收集器，知道使用选项”restart”再次调用collectgarbage。
“restart”:重启垃圾收集器。
“collect”:执行一次完整的垃圾收集，回收和析构所有不可达的对象。这是默认的选项。
“step”:执行某些垃圾收集工作，第二个参数data指明工作量，即在分配了data字节后垃圾收集器应该做什么。
“count”:以KB为单位返回当前自己已用内存数，该结果是一个浮点数，乘以1024得到的就是精确的字节数。该值包括了尚未被回收的死对象。
“setpause”:设置收集器的stepmul参数。参数data给出新值，也是以百分比为单位。
两个参数pause和stepmul控制着垃圾收集器的角色。任何垃圾收集器都是使用CPU时间换内存空间。在极端情况下，垃圾收集器可能根本不会运行。但是，不耗费CPU时间是以巨大的内存消耗为代价的。在另外一种极端的情况下，收集器可能每进行一次赋值就得运行一次完整的垃圾收集。程序能够使用尽可能少的内存，但是是以巨大的CPU消耗为代价的。pause和stepmul的默认值正式试图在这两个极端之间找到的对大多数应用来说足够好的平衡点。不过，在某些情况下，还是值得试着对它们进行优化。
参数pause用于控制垃圾收集器在一次手机完成后等待多久再开始新的一次手机。当值为零时，表示Lua语言在上一次垃圾回收结束后立即开始一次新的收集。当值为200%时表示在重启垃圾收集器前等待内存使用翻番。如果想消耗更多的CPU时间换取更低的内存消耗，那么可以把这个值设置得小一点。通常，我们应该把这个值设在0到200%之间。
参数stepmul控制对于每分配1KB内存，垃圾收集器应该进行多少工作。这个值越高，垃圾收集器使用的增量越小。一个像10000000%一样巨大的值会让收集器表现得像一个非增量的垃圾收集器。默认值是200%，地于100%的值会让收集器运行得很慢，以至于可能一次收集也完不成。
函数collectgarbage的另外一些参数用来在垃圾收集器运行时控制它的行为。同样，对于大多数程序员来说，默认值已经足够好了，但是对于一些特殊的应用，用手工控制可能会更好，游戏就经常需要这种类型的控制。例如，如果我们不想让垃圾收集在某些阶段运行，那么可以通过调用函数collectgarbage(“stop”)停止垃圾收集器，然后再调用collectgarbage(“restart”)重新启动垃圾收集器。在一些具有周期性休眠阶段的代码中，可以让垃圾收集器停止，然后在程序休眠期间调用collectgarbage(“step”,n)。要设置在每一个休眠期间进行多少工作，要么为n实验性地选择一个恰当的值，要么把n设成零，然后在一个循环中调用函数collectgarbage直到休眠结束。