Lua 核心知识:元表与元方法、面向对象、GC、弱表与全局表保护

5035 字
25 分钟
Lua 核心知识:元表与元方法、面向对象、GC、弱表与全局表保护

Lua 在 Unity 中主要用于热更新,各方案的对比见 热更新。本文中的行为以 Lua 5.3 / 5.4 为准,涉及版本差异的地方会单独说明(xLua 默认使用 Lua 5.3,toLua 使用 LuaJIT,LuaJIT 兼容 Lua 5.1)。

一、基础#

八种类型#

类型说明
nil空。变量未赋值时为 nil,给 table 的字段赋 nil 就是删除它
booleantrue / false。只有 nil 和 false 是假,0 和空字符串 "" 都是真
number数字。Lua 5.3 起分为整数和浮点数两种子类型
string不可变;短字符串会被内部化(相同内容只存一份),比较字符串只需比较地址
tableLua 唯一的数据结构,数组、字典、对象、模块都用它实现
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
end
end
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()
__tostringtostring(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)
__pairspairs(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,否则会无限递归。

例子:默认值、只读表#

-- 默认值:读取不存在的字段时返回 0
local 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) -- 把元表换成 Dog
end
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 cls
end
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 = phase
end

私有成员与多重继承#

  • 私有成员:Lua 的 table 字段都是公开的。需要真正私有时,可以把数据放在闭包的局部变量中,只通过返回的函数访问,代价是每个对象都持有一组闭包。实践中多用命名约定(如下划线前缀)。
  • 多重继承:把 __index 设置为一个函数,在多个父类中依次查找。

面向对象的设计思想见 面向对象,这里只讲 Lua 中的实现方式。

四、__gc:终结器#

local obj = setmetatable({}, {
__gc = function(o) print("被回收了") end
})
obj = nil
collectgarbage() -- 输出:被回收了
  • 对象被垃圾回收时调用,用于释放对象关联的外部资源(文件句柄、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 -- 拼写错误,变成了创建一个新的全局变量 coutn
end
  • 少写 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+:_ENV
local _ENV = setmetatable({}, { __index = _G }) -- 可以读取 _G,写入只会写到自己的环境中
-- Lua 5.1 / LuaJIT:setfenv
setfenv(1, setmetatable({}, { __index = _G }))

这也是实现沙箱的方式:只给不受信任的代码提供一个受限的环境。

方法三:静态检查#

使用 luacheck 这类静态分析工具,在提交代码前检查未声明的全局变量、未使用的变量等。成本最低,建议加入 CI 流程。

顺便:把常用的全局函数缓存为局部变量#

local insert = table.insert
local 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 函数要及时释放,否则会形成跨语言循环引用,两边都无法回收。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

Lua 核心知识:元表与元方法、面向对象、GC、弱表与全局表保护
https://xslab.cloud/posts/lua/lua-essentials/
作者
LuxFire
发布于
2026-10-12
许可协议
CC BY-NC-SA 4.0
相关文章 智能推荐
1
C# 与 Lua 交互原理:以 xLua 为例,Vector3 为什么能变快
Lua Lua 虚拟栈是 C# 与 Lua 交互的基础;C# 调用 Lua、Lua 调用 C# 时分别发生了什么;C# 对象如何以 userdata 的形式进入 Lua;反射与生成代码两种调用方式;交互的性能热点;xLua 的 GCOptimize 如何让 Vector3 等结构体零 GC 传递;以及减少交互开销的实践方法。
2
AssetBundle 原理与打包策略:文件结构、压缩、加载、依赖与冗余
Unity底层/资源与内存 AssetBundle 的文件里有什么;LZMA、LZ4、不压缩三种方式在大小、速度、内存上的差异;LoadFromFile、LoadFromMemory、LoadFromStream 等加载方式的区别;依赖的加载顺序与卸载;打包粒度、公共资源、Shader 与图集的打包策略和冗余检测;构建管线与哈希变化;以及常见面试题。
3
面向对象:三大特性、设计原则与组合优于继承
C#底层/面向对象 封装、继承、多态分别解决什么问题;抽象类与接口如何选择;面向对象七大设计原则(SOLID、迪米特法则、合成复用)的含义与示例;以及为什么 Unity 的组件系统是"组合优于继承"的典型。
4
Unity 内存构成:托管内存、原生内存与显存
Unity底层/资源与内存 一个 Unity 游戏的内存由哪几块组成、分别由谁分配和释放。重点讲 UnityEngine.Object 的"托管壳 + 原生本体"结构,以及资源卸载、显存估算和内存排查工具。
5
C# GC 原理:从 .NET 分代回收到 Unity 的 Boehm GC
C#底层/内存 GC 如何判断对象可以回收;.NET CLR 的分代、大对象堆和写屏障;Finalizer 与 Dispose 模式;以及 Unity 使用的 Boehm GC 为什么不分代、不压缩,增量 GC 和手动控制 GC 的做法。
随机文章 随机推荐
Profile Image of the Author
LuxFire
Hello, I'm LuxFire.
公告
欢迎来到我的博客!这是一则示例公告。
音乐
封面

音乐

暂未播放

0:00 0:00
暂无歌词
分类
标签
站点统计
文章
60
分类
6
标签
164
总字数
171,869
运行时长
0 天
最后活动
0 天前

文章目录