Lua 核心知识:元表与元方法、面向对象、GC、弱表与全局表保护
Lua 在 Unity 中主要用于热更新,各方案的对比见 热更新。本文中的行为以 Lua 5.3 / 5.4 为准,涉及版本差异的地方会单独说明(xLua 默认使用 Lua 5.3,toLua 使用 LuaJIT,LuaJIT 兼容 Lua 5.1)。
一、基础
八种类型
| 类型 | 说明 |
|---|---|
nil | 空。变量未赋值时为 nil,给 table 的字段赋 nil 就是删除它 |
boolean | true / false。只有 nil 和 false 是假,0 和空字符串 "" 都是真 |
number | 数字。Lua 5.3 起分为整数和浮点数两种子类型 |
string | 不可变;短字符串会被内部化(相同内容只存一份),比较字符串只需比较地址 |
table | Lua 唯一的数据结构,数组、字典、对象、模块都用它实现 |
function | 一等公民,可以赋值、传参、返回,支持闭包 |
userdata | 由 C 创建的数据,xLua 中的 C# 对象在 Lua 中就是 userdata |
thread | 协程 |
table
local t = { 10, 20, 30, name = "sword", [100] = "x" }- 内部分为数组部分和哈希部分:连续的正整数 key(从 1 开始)存在数组部分,访问快;其他 key 存在哈希部分。
- 下标从 1 开始。
#t求长度,只对没有空洞的序列可靠。{1, nil, 3}这种中间有 nil 的 table,#的结果是不确定的。ipairs从 1 开始按顺序遍历,遇到第一个 nil 就停止;pairs遍历所有键值,顺序不确定。
局部变量与全局变量
x = 1 -- 全局变量:实际上是 _G.x = 1(Lua 5.2+ 中是 _ENV.x)local y = 2 -- 局部变量- 不写
local就是全局变量,这是 Lua 中最常见的 Bug 来源(见第七节)。 - 局部变量存在寄存器中,全局变量每次访问都要查一次表,局部变量快得多。
函数与闭包
function Counter() local count = 0 -- 被内部函数引用的局部变量,叫上值(upvalue) return function() count = count + 1 return count endend
local c = Counter()print(c(), c()) -- 1 2- 函数可以返回多个值:
return a, b。 - 可变参数:
function f(...) local n = select("#", ...) end。
冒号语法
function Player:TakeDamage(d) self.hp = self.hp - d end -- 等价于 function Player.TakeDamage(self, d)player:TakeDamage(10) -- 等价于 Player.TakeDamage(player, 10)冒号只是语法糖:定义时自动加上 self 参数,调用时自动把调用者作为第一个参数传入。
二、元表与元方法
元表是什么
每个 table(和 userdata)都可以设置一个元表(metatable)。当对这个 table 做某些操作、而它本身无法处理时,Lua 会去元表中找对应的元方法来处理。
local t = {}local mt = {}setmetatable(t, mt)print(getmetatable(t) == mt) -- true元表让 table 可以自定义”找不到字段时怎么办""相加时怎么办""被调用时怎么办”等行为。
常用元方法
| 元方法 | 触发时机 |
|---|---|
__index | 读取一个不存在的字段时 |
__newindex | 给一个不存在的字段赋值时 |
__call | 把 table 当作函数调用:t() |
__tostring | tostring(t)、print(t) 时 |
__len | #t 时 |
__eq / __lt / __le | ==、<、<= 比较时 |
__add __sub __mul __div __mod __pow __unm | 算术运算 + - * / % ^ 和取负 |
__idiv、__band、__bor 等 | 整除 // 和位运算(Lua 5.3+) |
__concat | 字符串连接 .. 时 |
__gc | 对象被垃圾回收时(见第四节) |
__mode | 声明弱表(见第六节) |
__close | 带 <close> 标记的局部变量离开作用域时(Lua 5.4) |
__pairs | pairs(t) 时(Lua 5.2+) |
__metatable | 保护元表:设置后 getmetatable 返回这个值,setmetatable 会报错 |
__index 的查找过程
__index 是最重要的元方法,面向对象、继承、默认值都靠它实现:
读取 t.key │ ├─ t 自身有 key? ──是──▶ 返回 t.key │ └─ 否:t 有元表,且元表有 __index? ├─ 没有 ──▶ 返回 nil ├─ __index 是 table ──▶ 在这个 table 中继续查找 key(这个 table 也可能有自己的元表,于是形成一条链) └─ __index 是函数 ──▶ 返回 __index(t, key) 的结果__newindex 类似:给不存在的字段赋值时,如果 __newindex 是 table,就赋值到那个 table 上;如果是函数,就调用它。
绕过元方法:rawget(t, k)、rawset(t, k, v) 直接读写 table 本身,不触发 __index / __newindex。在 __newindex 中给自身赋值时必须用 rawset,否则会无限递归。
例子:默认值、只读表
-- 默认值:读取不存在的字段时返回 0local stats = setmetatable({}, { __index = function() return 0 end })print(stats.attack) -- 0
-- 只读表:禁止修改function ReadOnly(t) return setmetatable({}, { __index = t, __newindex = function() error("只读表,不能修改", 2) end, __metatable = false, -- 防止别人通过 setmetatable 解除保护 })end三、面向对象的实现
Lua 没有类,但可以用 table + 元表 + __index 模拟。
类与实例
local Animal = {}Animal.__index = Animal -- 实例找不到的字段,到 Animal 中找
function Animal.new(name) local obj = { name = name } -- 实例只保存自己的数据 return setmetatable(obj, Animal)end
function Animal:Speak() print(self.name .. " ...")end
local a = Animal.new("猫")a:Speak() -- a 自身没有 Speak → 元表 Animal 的 __index 是 Animal → 找到 Animal.Speak方法只存在于”类”表中,所有实例共享一份,实例中只有各自的数据。
继承
local Dog = setmetatable({}, { __index = Animal }) -- Dog 找不到的,到 Animal 中找Dog.__index = Dog
function Dog.new(name) local obj = Animal.new(name) -- 调用父类构造 return setmetatable(obj, Dog) -- 把元表换成 Dogend
function Dog:Speak() -- 重写 Animal.Speak(self) -- 调用父类方法:显式传入 self print(self.name .. " 汪")end
local d = Dog.new("小黑")d:Speak()查找链:d → Dog → Animal。这就是用 __index 链实现的继承,子类中定义同名方法就是重写(多态)。
通用的 class 函数
项目中一般会封装一个 class 函数,统一类的创建方式:
function class(super) local cls = {} cls.__index = cls if super then setmetatable(cls, { __index = super }) end cls.super = super
cls.new = function(...) local obj = setmetatable({}, cls) if obj.ctor then obj:ctor(...) end return obj end return clsend
local Enemy = class()function Enemy:ctor(hp) self.hp = hp end
local Boss = class(Enemy)function Boss:ctor(hp, phase) Boss.super.ctor(self, hp) -- 调用父类构造 self.phase = phaseend私有成员与多重继承
- 私有成员:Lua 的 table 字段都是公开的。需要真正私有时,可以把数据放在闭包的局部变量中,只通过返回的函数访问,代价是每个对象都持有一组闭包。实践中多用命名约定(如下划线前缀)。
- 多重继承:把
__index设置为一个函数,在多个父类中依次查找。
面向对象的设计思想见 面向对象,这里只讲 Lua 中的实现方式。
四、__gc:终结器
local obj = setmetatable({}, { __gc = function(o) print("被回收了") end})obj = nilcollectgarbage() -- 输出:被回收了- 对象被垃圾回收时调用,用于释放对象关联的外部资源(文件句柄、C 层资源)。
- 设置元表时,元表中必须已经有
__gc字段,对象才会被标记为”需要终结”。先设置元表、之后再往元表里加__gc是无效的。 - 和 C# 的终结器一样,调用时机不确定,带
__gc的对象至少要经过两轮回收才能真正释放(第一轮调用__gc,第二轮释放内存)。不要依赖它做业务逻辑。 - 版本差异:Lua 5.1(包括 LuaJIT)中
__gc只对 userdata 有效,对 table 无效;Lua 5.2 起 table 也支持。 - 在 xLua 中,C# 对象传入 Lua 后是一个带
__gc的 userdata,被回收时通知 C# 端释放对这个对象的引用。
五、Lua 的 GC
算法:增量式的三色标记-清除
Lua 使用标记-清除算法,不移动对象。为了避免一次回收卡住太久,它是增量进行的:回收工作被拆成很多小步,穿插在程序的内存分配之间执行。
增量回收需要三色标记来记录进度:
| 颜色 | 含义 |
|---|---|
| 白色 | 还没被访问到。标记结束时仍为白色的,就是垃圾 |
| 灰色 | 已经访问到,但它引用的对象还没处理完 |
| 黑色 | 自身和它引用的对象都已处理完 |
1. 开始:所有对象为白色,把根对象(全局表、注册表、主线程栈等)标为灰色2. 标记:不断取出一个灰色对象,把它引用的白色对象标为灰色,自己标为黑色3. 原子阶段:一次性处理需要不被打断完成的工作(如弱表、需要终结的对象)4. 清除:释放所有白色对象5. 终结:调用被回收对象的 __gc写屏障:标记是分多次进行的,中途程序还在运行,可能把一个白色对象的引用存进一个已经是黑色的对象中。黑色对象不会再被检查,这个白色对象就会被误删。所以 Lua 在这种赋值发生时通过写屏障做修正:要么把白色对象标为灰色,要么把黑色对象退回灰色重新检查。
分代模式:Lua 5.4 新增了分代模式(collectgarbage("generational")),基于”大部分对象很快死亡”的假设,多数时候只回收新对象。默认仍是增量模式。
控制 GC
collectgarbage("count") -- 当前内存占用(KB)collectgarbage("collect") -- 执行一次完整回收collectgarbage("step", n) -- 执行一步增量回收collectgarbage("stop") -- 停止自动回收collectgarbage("restart") -- 恢复collectgarbage("setpause", 200) -- 内存增长到上次回收后的 200% 时开始新一轮回收collectgarbage("setstepmul", 200) -- 每一步回收的工作量,越大回收越快、单步越卡(Lua 5.4 中推荐用 collectgarbage("incremental", pause, stepmul) 设置。)
游戏中常见的做法:在切换场景、加载界面时主动执行一次完整回收;战斗中调大 pause 降低回收频率。
GC 算法总览
| 算法 | 原理 | 优点 | 缺点 | 代表 |
|---|---|---|---|---|
| 引用计数 | 每个对象记录被引用的次数,归零立即释放 | 释放及时、没有集中停顿 | 无法回收循环引用;每次赋值都要增减计数 | CPython、Swift ARC、C++ shared_ptr |
| 标记-清除 | 从根出发标记可达对象,清除其余 | 实现简单,不移动对象 | 内存碎片;需要遍历堆 | Lua、Unity 的 Boehm GC |
| 标记-压缩 | 标记后把存活对象移到一起 | 没有碎片,分配快 | 移动对象、更新引用的开销 | .NET CLR |
| 复制 | 内存分成 From、To 两半,把 From 中的存活对象复制到 To,然后互换 | 没有碎片;只处理存活对象,存活少时极快 | 一半内存闲置;存活对象多时复制开销大 | 分代 GC 的新生代(JVM、Mono SGen 的新生代) |
| 分代 | 按对象年龄分区,频繁回收新生代 | 大部分时候只处理一小块 | 需要写屏障处理跨代引用 | CLR、JVM、SGen、Lua 5.4 分代模式 |
| 增量 / 三色标记 | 把一次回收拆成多步,与程序交替执行 | 减少单次停顿 | 需要写屏障,总开销略增 | Lua、Unity 增量 GC、Go |
STW(Stop-The-World):回收期间暂停整个程序。非增量的标记-清除就是一次完整的 STW;增量和并发 GC 都是为了缩短或消除 STW。
.NET 与 Unity 的 GC 详见 C# GC 原理。
引用计数一般用在什么地方
虽然通用的 GC 很少只用引用计数,但它在资源管理中非常常见:
- AssetBundle、资源的加载与卸载:每次加载计数加一,释放减一,归零时卸载。资源的释放时机需要确定(用完马上释放内存),而资源之间一般不会形成循环引用,正适合引用计数(见 资源加载与管理 和 YooAsset 的句柄机制)。
- C++ 的智能指针
shared_ptr、Objective-C / Swift 的 ARC、COM 组件。 - 对象池、共享数据的生命周期管理。
它的共同点是:需要确定性的释放时机,并且对象之间的引用关系简单、不成环。
六、弱表
什么是弱表
普通 table 对其中的键和值都是强引用:只要 table 还在,里面的对象就不会被回收。
弱表中的引用是弱引用:不阻止对象被回收。对象被回收后,它在弱表中的那一项会被自动删除。
通过元表的 __mode 字段声明:
__mode | 含义 | 对象被回收后 |
|---|---|---|
"k" | 键是弱引用 | 键被回收,整项删除 |
"v" | 值是弱引用 | 值被回收,整项删除 |
"kv" | 键和值都是弱引用 | 任意一个被回收,整项删除 |
local cache = setmetatable({}, { __mode = "v" })cache[1] = {} -- 这个 table 只被弱表引用collectgarbage()print(cache[1]) -- nil:已经被回收,这一项被删除了特性与注意点
- 只有”对象”会被回收:table、函数、userdata、协程。数字、布尔值不会被回收;字符串虽然也受 GC 管理,但被视为值,不会从弱表中被移除。所以
__mode = "k"的表用字符串做键,是没有”弱”的效果的。 - 删除发生在 GC 之后:对象没人引用了,但在下一次 GC 运行之前,它仍然在弱表里。
- 蜉蝣表(Ephemeron):Lua 5.2 起,弱键表中如果值引用了自己的键,这个引用不会让键保持存活。避免了”值引用键,导致键永远不能被回收”的问题。
用途
| 模式 | 用途 | 例子 |
|---|---|---|
弱值 "v" | 缓存 | 资源缓存、对象缓存:还有人用时直接复用,没人用了允许被回收 |
弱键 "k" | 给对象附加额外数据,而不影响对象的生命周期 | extra[obj] = { selected = true },obj 被回收时这项数据自动消失 |
"kv" | 两边都不想持有 | 对象之间的临时映射关系 |
七、保护全局表
为什么要保护
function Update() coutn = count + 1 -- 拼写错误,变成了创建一个新的全局变量 coutnend- 少写
local或拼错变量名,Lua 不会报错,而是悄悄创建或读取一个全局变量,Bug 很难发现。 - 全局变量永远被全局表引用,不会被回收,容易造成内存泄漏。
- 全局变量的访问比局部变量慢。
- 热更新的多个模块之间可能互相覆盖同名的全局变量。
方法一:给全局表设置元表
在所有正式的全局变量定义完成之后,禁止再新增,并拦截对未定义变量的访问:
setmetatable(_G, { __newindex = function(t, k, v) error("禁止定义全局变量: " .. tostring(k), 2) end, __index = function(t, k) error("访问了未定义的全局变量: " .. tostring(k), 2) end,})
-- 确实需要定义全局变量时,用 rawset 绕过检查rawset(_G, "GameConfig", {})error 的第二个参数 2 表示把错误位置指向调用者,日志中能直接看到是哪一行写错了。Lua 官方发行版中的 strict.lua 就是这个思路。
注意:一些第三方库可能依赖动态创建全局变量,开启保护后要逐个排查。通常只在开发和测试版本中开启,或者只记录警告不报错。
方法二:为每个模块设置独立的环境
让模块中”全局变量”的读写只发生在模块自己的环境表中,而不是真正的 _G:
-- Lua 5.2+:_ENVlocal _ENV = setmetatable({}, { __index = _G }) -- 可以读取 _G,写入只会写到自己的环境中
-- Lua 5.1 / LuaJIT:setfenvsetfenv(1, setmetatable({}, { __index = _G }))这也是实现沙箱的方式:只给不受信任的代码提供一个受限的环境。
方法三:静态检查
使用 luacheck 这类静态分析工具,在提交代码前检查未声明的全局变量、未使用的变量等。成本最低,建议加入 CI 流程。
顺便:把常用的全局函数缓存为局部变量
local insert = table.insertlocal floor = math.floor在频繁调用的代码中,局部变量的访问比每次查找全局表再查找字段快。
八、xLua 中 C# 与 Lua 的交互
交互的底层原理(虚拟栈、包装函数、对象池、GCOptimize)见 C# 与 Lua 交互原理,本节只做概要。
交互的开销
- 跨语言调用:每次调用都要在 Lua 栈和 C# 之间转换参数和返回值,比两边各自内部的调用慢得多。热路径(每帧、大量循环)中要减少跨语言调用,尽量在一边内批量完成。
- 字符串:在两边传递字符串需要转换编码并分配内存。
- 值类型:Vector3 这类结构体传给 Lua 时,默认会装箱成一个对象,产生 GC。xLua 提供了
GCOptimize标记,对指定的结构体做无 GC 的传递。 - 生成适配代码:为常用的 C# 类型生成绑定代码,避免运行时通过反射调用,既快又避免反射带来的分配。
内存泄漏
C# 对象传入 Lua 后,C# 端会在一张表中记录它,防止它被 C# 的 GC 回收,直到 Lua 端的 userdata 被回收(通过 __gc 通知)。反过来,C# 中持有 Lua 函数(LuaFunction、委托),Lua 端也会保留这个函数的引用。
于是就会出现跨语言的循环引用:
C# 对象 ──持有委托──▶ Lua 函数 ──闭包引用──▶ Lua 中代表这个 C# 对象的 userdata ──▶ C# 对象两边的 GC 各自只能看到自己这一侧的引用,谁都回收不了。典型例子是 C# 的事件或按钮监听注册了一个 Lua 函数,界面关闭时没有移除。
规则:
- C# 中持有的 Lua 函数、
LuaTable,不用时要调用Dispose或置空;注册给 C# 事件的 Lua 回调,要在对象销毁时移除。 - 关闭
LuaEnv时如果报”还有 C# 回调未释放”之类的错误,就是存在没有释放的委托,要排查清理。
常见追问
Lua 有哪些数据类型?哪些值为假? nil、boolean、number、string、table、function、userdata、thread。只有 nil 和 false 为假,0 和空字符串都为真。
元表是什么?说几个元方法。
元表定义 table 在特定操作下的行为。常用的有 __index、__newindex、__call、__tostring、__len、__eq、__lt、__add、__concat、__gc、__mode、__metatable。
__index 和 __newindex 的区别?
__index 在读取不存在的字段时触发,__newindex 在给不存在的字段赋值时触发。两者都可以是 table 或函数。
Lua 怎么实现面向对象和继承?
类是一个 table,并把它的 __index 设为自身;实例是设置了这个元表的 table。继承是让子类的元表 __index 指向父类,形成查找链。
__gc 有什么用?有什么注意点?
对象被回收时调用,用于释放外部资源。设置元表时 __gc 必须已经存在;调用时机不确定;Lua 5.1 中只对 userdata 有效。
Lua 的 GC 是怎么实现的? 增量式的三色标记-清除:白、灰、黑三色记录标记进度,回收分成小步与程序交替执行,用写屏障保证正确性,不移动对象。Lua 5.4 增加了分代模式。
常见的 GC 算法有哪些? 引用计数、标记-清除、标记-压缩、复制(From/To 两个空间)、分代、增量与三色标记。
引用计数一般用在什么地方? 资源管理,比如 AssetBundle 和资源的加载卸载;以及智能指针、ARC。适合需要确定性释放、引用关系不成环的场景。
弱表的 k、v、kv 有什么区别?
k 是键为弱引用,v 是值为弱引用,kv 是两者都是弱引用;对应的对象被回收后,整个键值对从表中删除。字符串、数字不会被移除。弱值表常用于缓存,弱键表常用于给对象附加数据。
怎么保护 Lua 的全局表?
给 _G 设置元表,用 __newindex 禁止新增全局变量、__index 拦截未定义变量的访问,需要时用 rawset 定义;或者为模块设置独立的 _ENV 环境;再配合 luacheck 静态检查。
为什么要尽量使用局部变量? 局部变量在寄存器中,访问快;全局变量要查表,而且永远不会被回收,还容易被误写和覆盖。
xLua 中 C# 和 Lua 交互要注意什么? 跨语言调用有转换开销,热路径中要减少;值类型默认会装箱,可以用 GCOptimize;C# 持有的 Lua 函数要及时释放,否则会形成跨语言循环引用,两边都无法回收。
文章分享
如果这篇文章对你有帮助,欢迎分享给更多人!