Roblox Luau 专家笔记精读:调度器、Deferred 事件、类型、内存与 Parallel Luau 的实测判据
Roblox Luau 专家笔记精读:调度器、Deferred 事件、类型、内存与 Parallel Luau 的实测判据
本文以 scenario-roblox-luau 技能中的专家笔记为主体,逐条拆解 Studio 0.743(2026-10-18 实测)下的调度器语义、Deferred 事件顺序、让出边界、新旧类型求解器差异、清理与泄漏判定、Parallel Luau 与 native/buffer 优化门槛。读完后你能得到一套可复用的判断依据:哪些结论来自官方文档、哪些来自本技能的实测、哪些只是社区说法需要纠正,以及在什么数字门槛下才应该保留一项优化。
这份笔记的证据等级怎么读
专家笔记的开篇就定义了三条标注约定,理解它们是正确引用全文的前提:
- Live:表示该结论在 Studio 0.743 上于 2026-10-18 实际跑过,探针代码与结果记录在 procedures.md 里;原文写的是“参见
procedures.md”,该文件即上表路径。 - [added]:表示这是本技能在既有资料之外自己补充的结论,通常带“verified with luau / Lune / Studio”的说明。
- 无标注 + 人名/时间戳:表示来自被记录的演讲或文档,形如
(Crusherfire, [00:13:33]),时间戳是原始素材中的位置。这些属于“他人陈述”,笔记作者只对其中与实测冲突的部分做了纠正。
值得注意的是,笔记并不回避争议。例如关于 task.defer 的优先级,笔记直接写明:BrawlDev 把 defer 称作“lower priority”,而该解读是错的——defer 是“当前恢复点之后执行”的排队语义,不是低优先级。这种“结论 + 反例 + 实测”的写法,正是这份文档最有价值的地方。
任务调度器:task.spawn 不是并发
三个函数各自的真实语义
笔记把调度器的核心结论压缩成三点:
task.spawn同步执行到第一次让出。函数体会一直跑到第一个 yield 才把控制权交回调用者,因此它不是并发;同时,spawn 内部抛错不会中断调用者。实测的调用顺序是spawn:body, caller:afterSpawn。task.defer把函数排到当前恢复点末尾。多个 defer 保持调用顺序,在 MicroProfiler 中显示为 deferred threads。完整的实测顺序是spawn:body, caller:afterSpawn, caller:end, defer:1, defer:2, spawn:afterWait, delay0。task.wait()与task.delay(0, f)在下一个 Heartbeat 恢复。关键在于“从哪个上下文调用”:- 从
PreRender或PreSimulation调用:同一帧恢复; - 从
Heartbeat调用:下一帧恢复。
- 从
这两条路径的耗时差距被直接量化了:从 PreSimulation 出发是 0.07 ms,从 Heartbeat 出发是 16.42 ms(Studio 0.743,Server,60 Hz)。这解释了为什么“把逻辑挪到 PreSimulation 之后”有时会莫名其妙地省掉一帧延迟。
复现这段顺序的最小探针就在 Probe.luau 中:
function Probe.scheduler()
local log = {}
local function mark(tag)
table.insert(log, tag)
end
task.spawn(function()
mark("spawn:body")
task.wait()
mark("spawn:afterWait")
end)
mark("caller:afterSpawn")
task.defer(mark, "defer:1")
task.defer(mark, "defer:2")
task.delay(0, mark, "delay0")
mark("caller:end")
frames(4)
return { order = table.concat(log, ",") }
end
计时探针在 Probe.delayTiming:它对 PreSimulation 与 Heartbeat 各用一次 :Once(),在回调里记录 os.clock(),再用 task.delay(0, ...) 测恢复间隔,把毫秒换算交给 math.floor((os.clock() - t0) * 1e5) / 100。
遗留 API 与“精度”误区
笔记明确指出:wait、spawn、delay 是遗留且被**节流(throttled)**的。ByteBlox 的视频得出了“应该用 task.wait”的正确结论,但把原因归为“精度”,笔记纠正说真正的原因是节流——不是浮点精度问题,而是调度器主动限制恢复频率。
同样,RunService.Stepped 与 RenderStepped 已被 PreSimulation 与 PreRender 取代,且 PreSimulation 只传 delta(不再像老 API 那样传 time 与 delta 两个参数)。静态审计里对这两者分别有 superseded-runservice 规则覆盖,见 LuauAudit.luau。
采集证据的固定配方
笔记给出了一套不依赖猜测的证明方法:
debug.profilebegin("tag")
-- 被测量的工作
debug.profileend()
随后在 MicroProfiler 中 Cmd+F6 打开、Cmd+P 暂停,搜索该 tag。作者强调两点细节:把帧计数器写进 tag(这样能在时间轴上定位到具体帧),以及 tag 起止必须成对。这条配方配合“帧时间、KB/s、堆斜率”三类基线数字,构成笔记反复强调的“先测量再优化”。
Server Authority 下的额外约束
在 Server Authority 模式(Workspace.AuthorityMode = Server)中,task.defer 还有一层语义:它把工作移出仿真步,而仿真步内只有 Simulation Access 属性可写。因此效果类代码应该走 defer,否则会在重仿真(resimulation)时被重放。该结论来自 RDC 2026 的 Server Authority 议题记录(Drew Hamilton 与 Jason Knight,[00:22:19])。
Deferred 事件:默认值、顺序与四个反直觉行为
默认状态与迁移收益
笔记对“Deferred 到底是什么状态”给出了非常具体的三分法:
- Deferred 是模板默认值,也是文档推荐值;
Default在旧位置仍然等同 Immediate;Rojo 构建、且没有显式设置该属性的 place 就是 Default 行为;- Server Authority 强制 Deferred。
版本脉络也记录得很清楚:2023-04 为 opt-in,2023-11 进入模板。收益方面,有一个已上线项目的实测:仅采用 Deferred,就把帧时间从约 6–8 ms 降到约 4–5 ms(Drew Hamilton,RDC 2026,[00:17:31]),因此笔记把“迁移到 Deferred”列为走向 Server Authority 的第一步([00:16:57])。
判断当前 place 处于哪种模式是后续所有推理的前提。问题是 Workspace.SignalBehavior 是 NotScriptable,脚本读不到;探针 Probe.signals 用 pcall 包住这次读取,预期它失败并把结果记进 signalBehaviorReadable。实际可用的判断途径是 Properties 面板、Rojo 工程文件,或 Lune 侧的 rbx_luau.audit(place)。
四个被实测确认的反直觉行为
| 场景 | Immediate | Deferred(实测) |
|---|---|---|
在某个 handler 内部再连接新 handler,同一步内对第二个事件 Fire |
新旧两个都会收到 | 新连的收到 0 次 |
| 嵌套触发(A 内 fire C,外部再 fire B) | A, C, B(深度优先) | A, B, C(队列) |
Destroying / CharacterRemoving 回调里读 Parent |
通常还能读到 | 读到 nil(实例已移除) |
| 重入深度 | 文档说限制为 10 | 自触发 handler 实测达到 50 且无报错 |
这些结论在 Server 与 Client 两个数据模型上都做了验证:嵌套顺序在两端都是 A、B、C;Destroying 在两端都看到 nil。笔记因此给了两条直接的编码规则:在 handler 内部读取状态(不要在 :Fire() 之后假设 handler 已跑完),以及在 Destroy 之前把清理需要的信息先捕获下来。静态规则 removal-handler-reads-parent 正是为后者准备的,它在源码里检测 .Parent、:GetFullName()、:FindFirstAncestor 的使用,见 LuauAudit.luau。
关于重入深度,笔记的态度很明确:文档写的 10 次限制不能当作防护栏,因为实测 50 次也没报错——“do not rely on the limit as a guard”。
:Once()、Disconnect 与 Destroy 的差异
笔记给出了三者语义的精确区分,并附实测方法:
:Once()用来替代“连接后立刻断开”的写法;实测对同一事件 fire 3 次只跑 1 次;Disconnect会丢弃已排队但未执行的调用(实测在 handler 内断开后,3 次 fire 只跑了 1 次);Destroy不会丢弃,队列中的调用仍会执行(实测 2 次);- 连续 3 次属性赋值产生 3 次 changed 回调。
这套差异在中大型项目里很关键:销毁一个事件对象并不等于取消它已经排队的副作用。
让出与协程:哪些边界不能 yield
不可跨越的 C 调用边界
笔记的结论是:Luau 不能在 metamethod 或 C 调用边界上让出。具体被点名的三处是 __index 函数、table.sort 的比较器、string.gsub 的回调,错误信息就是那句熟悉的 attempt to yield across metamethod/C-call boundary。相对地,pcall 是可让出的。
复现方式必须保守。探针 Probe.yields 刻意只用 coroutine.yield() 在私有协程里试探,并在注释里写明了原因:
失败的
task.wait在pcall下会让线程继续挂在调度器上(“already 'waiting'”),Studio 0.743 在这次探测后不久就崩溃了。
对应的真实事故记录在 procedures.md 的 P4:首次 live 运行时,__index 与排序比较器里的 task.wait 被 pcall 捕获,线程状态残留,随后同一线程再次 task.wait 报出 “Cannot call task.wait on a thread that is already 'waiting' in the task library”,几秒后 place 进程崩溃(HardAssert “Tasks: Promise setValue() called multiple times”),根因未被隔离。这是一条罕见的、有具体崩溃信息支撑的警告:不要用 pcall 去“兜住”非法的让出。
协程 vs 调度函数的选择判据
笔记给出的决策条件只有一句:你的代码之后会不会手动恢复它。
- 会手动恢复(生成器、状态机、手递手控制)→
coroutine; - 由调度器按时间点触发 →
task.spawn/task.defer。
同时纠正了两个常见说法:coroutine.resume 返回 true 加让出值,或 false 加错误;coroutine.wrap 会重新抛出;结束的协程状态是 dead。协程是协作式的,真正的并行需要 Actors——“BrawlDev 用 multithreading 描述协程是错的”。
帧内 handler 的线程堆积
主线程不能被长循环阻塞,反过来,一个会 yield 的每帧 handler 会堆积线程。实测数字很直观:在 Heartbeat 里调用 task.wait(0.25),1 秒内并发线程峰值达到 16;改成忙标志(busy flag)后,同样 1 秒只运行 4 次。这段对照逻辑就在 Probe.pileup,它先测堆积版本,再用 task.delay(0.25, ...) 释放标志测受控版本。
注意一个易错点:WaitForChild 在子对象已存在时立即返回、不 yield,所以在 __index 里写 FindFirstChild(key) or WaitForChild(key, 1) 这种模式,在命中缓存时是安全的,在未命中时就会踩边界。探针里专门分了 existingChildInIndex 与 taskWaitInsidePcall 两个 case 来区分。
类型:新旧求解器必须同时通过
发布节奏与开关
笔记记录的版本事实:
- 新类型求解器在 2025-11-20 对
--!nocheck与--!nonstrict全面发布; --!strict通过Workspace.UseNewLuauTypeSolver选择加入(NotScriptable,受引擎 rollout 控制);Workspace.LuauTypeCheckMode设置项目默认值;- 旧求解器会保留到 2026 年。
实测有一个细节值得记住:LuauTypeCheckMode 能从脚本读到 Default,而另外两个属性从脚本读不到。这意味着代码无法在运行时判断自己会被哪个求解器检查,所以门禁必须是“两个都跑”。
七组对照用例
procedures.md 的 P1 用 fixture 表把差异钉死了(2026-10-18,7/7 通过):
| Fixture | 旧求解器 | 新求解器 |
|---|---|---|
local y = 5; y = "hello" |
报错 | 不报错(拓宽类型) |
function C.step(self: C, dt: number) + 字段拼写错误 |
抓到 | 抓到 |
function C:fire() + 字段拼写错误 |
漏掉(提示 self 未知类型) |
漏掉(调用点报出令人困惑的只读错误) |
| 组合(Knight 持有 Health) | 干净 | 干净 |
| 带类型的元表继承(Child 继承 Base) | 2 个误报 | 9 个误报 |
(model :: any).Humanoid.Healthh = 5 |
漏掉 | 漏掉 |
local a: { Vector3 } = table.create(n) |
干净 | 报错({unknown}) |
由此得出四条可直接落地的规则:
- 需要保持类型的局部变量必须显式标注,因为新求解器会静默拓宽;
- 方法一律写成
function Class.name(self: Class, ...),调用方仍用obj:name()——冒号写法在两个求解器上都会放过字段拼写错误; - 用组合代替带类型的元表继承链,继承在两个求解器上都会产生“does not have key”的误报;
table.create(n)要带初值,写成table.create(n, Vector3.zero),否则新求解器会把元素类型推断成unknown。
:: any 也不是逃生通道:(model :: any).Humanoid.Healthh = 5 在两个求解器上都被漏掉,正确做法是用 IsA 或 FindFirstChildOfClass 收窄类型。静态审计对 :: any 与严格模式下冒号方法分别给出 any-cast 与 colon-method-strict 两条 info 级提示,见 LuauAudit.luau。
门禁命令
rbx_luau.py typecheck <file|dir> [--sourcemap sourcemap.json] [--json]
实现上它分两遍调用 luau-lsp(solver="old" 与 solver="new"),这样每份结果只包含自己的错误,并额外产出 only_old / only_new 两个差集,便于判断“这条错误是求解器换版导致的还是我写错了”,见 rbx_luau.py。另一个容易踩的坑写在同一文件的 sourcemap() 注释里:rojo sourcemap 必须带 --include-non-scripts,否则 Folder 与 remotes 缺失,新求解器会在每条经过它们的路径上报未知键。
类与清理:Destroy 必须幂等且完全
笔记在这一节给了三条硬约束:
- 类表自己作为元表,
__index指向表而不是函数,并避免深层继承链(依据 Luau 性能页的 “Fast method calls”)。方法用obj:Method()调用,把方法缓存到局部变量并不会更快。 - 每个类都要有
Destroy,断开它创建的所有连接、销毁它创建的对象(Roblox Learn 的 OOP 内容,[00:10:32])。 - 在创建的那一行就登记清理(
trove:Add(...)、trove:Connect(...)),这样Destroy就是一次调用(B Ricey 的 Trove / Maid / Janitor 讲法,[00:07:20]–[00:12:55])。库的选择按代码库现状定:Janitor 功能全、Trove 手感好、Maid 最老。笔记明确把清理框架的选型交给scenario-roblox-architecture,本技能只负责审 Luau 本身。
模板 Class.luau 是这三条约束的可运行版本:
--!strict
local RunService = game:GetService("RunService")
local Spinner = {}
Spinner.__index = Spinner
type Fields = {
part: BasePart,
speed: number,
_connections: { RBXScriptConnection },
_destroyed: boolean,
}
export type Spinner = typeof(setmetatable({} :: Fields, Spinner))
function Spinner.new(part: BasePart, speed: number): Spinner
local self = setmetatable({
part = part,
speed = speed,
_connections = {},
_destroyed = false,
}, Spinner)
table.insert(self._connections, RunService.PreSimulation:Connect(function(dt: number)
self:step(dt)
end))
table.insert(self._connections, part.Destroying:Connect(function()
self:Destroy()
end))
return self
end
function Spinner.Destroy(self: Spinner)
if self._destroyed then
return
end
self._destroyed = true
for _, c in self._connections do
c:Disconnect()
end
table.clear(self._connections)
end
三个细节值得单独指出:连接在 new 里就进表(创建即登记);Destroying 绑定让外部销毁部件时对象自动清理;_destroyed 标志保证幂等。P6 的实测结果是部件在 30 帧内转了 90 度(π rad/s),销毁部件后 Destroy 经 Destroying 被调用,剩余连接数为 0。
最后一条经验来自 B Ricey([00:10:01]):忘记断开的连接只会在生产规模暴露,短时间的 Studio 测试看不到——这解释了为什么清理必须靠门禁而不是“我试了一下没问题”。
内存:只涨不降才叫泄漏
判定标准与预算
笔记把“内存增长”和“内存泄漏”严格分开:增长是正常的,只有永远降不下来的内存才是泄漏;判断形状要看锯齿波(Roblox Learn 的内存泄漏内容,Andrew,[00:05:58])。预算给出了两个量级:
- 服务端约 6.25 GB;
- 低端手机约 2 GB,其中约 700 MB 被操作系统占用([00:00:43]、[00:01:17])。
由此推出优先级:服务端泄漏更要紧,因为一台服务器要经历成百上千个玩家(Crusherfire,Luau Heap,[00:02:48])。
排查流程
- 在 Luau Heap 中打快照;
- 跑一个完整周期,回到相同状态;
- 再打快照,做差分;
- 只相信跨多次差分仍在上升的条目;
- 如果看到大量路径相似但彼此独立的引用,通常意味着连接把实例保住了([00:04:36]、[00:07:53]、[00:09:05])。
角色生命周期是一个具体案例:角色和玩家可能比玩家本身活得更久。可以开启 Workspace.PlayerCharacterDestroyBehavior,或在 CharacterRemoving 里销毁。实测结论很关键——在 Default 设置下,重生的旧角色只是被 unparent,它的连接仍然连着;加上 task.defer(character.Destroy, character) 后连接才断开(Roblox Learn [00:06:58],以及 P7 的 character_destroy)。
在 Roblox 里能调用的 GC 接口
笔记明确:Roblox 脚本只能调 collectgarbage("count"),gcinfo() 返回同样的 KB 数值;collectgarbage("collect") 会报错,所以无法强制回收。luau-lsp 还会把 collectgarbage 标记为 deprecated。这三条合起来决定了泄漏探针的设计:不能“先 GC 再看”,只能制造 GC 压力。
Leak.luau 的处理方式正是这样:如果能拿到真正可用的 collectgarbage(普通 luau / Lune 环境)就调用 "collect";拿不到就循环分配垃圾(每轮 20000 个小表)并逐轮 task.wait(),靠增量 GC 把垃圾推出去。存活计数用弱键表(__mode = "k")完成,探针自身不持有对象:
local weak = setmetatable({}, { __mode = "k" })
-- make(i) 创建对象,weak[o] = true 只做弱引用
release(objects)
local mode = Leak.collect(rounds)
local alive = 0
for _ in weak do alive += 1 end
P7 的结果给出了两个非常干净的对照:200 个表在模块级 registry 持有它们时全部存活,清空 registry 后为 0;100 个已销毁的 Part 在被一个未断开的 workspace.ChildAdded 连接捕获时全部存活,Disconnect 之后为 0。这就是“销毁了但还连着”这种最隐蔽泄漏的可复现证据。
Parallel Luau:并行算,串行写
五条硬约束
- 同一 Actor 下的脚本彼此不会并行,并行需要多个 Actor。
- 没有 Actor 祖先时
ConnectParallel直接报错,且该 handler 永不运行(Suphi Kaner,00:12:06])。静态规则parallel-without-actor覆盖了这一点,并且会跳过那些显式检查script:GetActor()的 worker 模板——见 [LuauAudit.luau。 - 串行 → 并行 → 串行:串行阶段做准备,
task.desynchronize()之后计算,task.synchronize()之后写入;命中类计算要重新检查Parent,因为对象可能在并行阶段被移走。 - 并行阶段不能
require,Instance 写入与大多数 Instance 方法不安全;没有 thread-safety 标注的成员一律视为 Unsafe。 - 每个 Actor 是独立的 Luau VM,模块状态不共享。
第 4、5 条的实测错误文本与数值都很具体:"require can not be used during the parallel phase"、"Property BasePart.Transparency is not safe to write in parallel"、"Function Instance.SetAttribute is not safe to call in parallel",而读取是允许的;隔离性方面,主 VM 的 Counter.n = 41,每个 Actor 看到的是 0。
一个操作细节:task.synchronize() 放在 pcall 里曾经导致 place 崩溃过一次(可能与 P4 的线程残留有关,根因未隔离),所以笔记要求阶段切换不要包在 pcall 里。写正确形态的参考实现在 procedures.md 的 SyncWriter:并行阶段算出 acc,先试探性写入(预期失败),task.synchronize() 之后再写属性,并把“早期写入是否被允许”作为事实记录下来。
Actor 数量与典型模式
- 独立单元多(如按玩家做校验)就开很多 Actor,64 个以上、即便只有 4 核也可以;
- 有相互依赖的逻辑收在同一个 Actor 里;
- 地形处理是标准范式:管理器把区块坐标消息发给 32 个 Actor,worker 并行算噪声,
WriteVoxels回到串行执行; - 跨 Actor 的同步阶段顺序每帧可能不同,不要依赖。
加速比的实测口径:32 个纯计算 job(每个 40 万次迭代,18 核 Mac),1 个 Actor 用 144.5 ms,8 个 Actor 用 19.0 ms,即 7.6×。测量工具是 Parallel.luau,任务按 round-robin 分发,结果写进 SharedTable,用 results.done 计数加超时兜底:
for i, payload in jobs do
actors[(i - 1) % #actors + 1]:SendMessage("work", i, payload, results)
end
SharedTable 的键与原子操作
键只能是字符串或 0 到 2^32 − 1 之间的非负整数;值可以是布尔、数字、向量、字符串或嵌套 SharedTable。读改写必须走 SharedTable.increment 或 SharedTable.update,因为普通 += 1 会丢更新——实测 8 个 Actor 各做 20000 次,160000 次里丢了 127107 次;改用 increment 一次不丢。
Native code generation:只在测出收益时保留
适用范围
native 代码生成只作用于服务端脚本,并且只对数字、向量、buffer 上的数值计算有效,对以 API 或库调用为主的代码没有帮助(Roblox Learn,[00:03:54])。
最关键的一条实操细节是类型标注:Vector3 参数必须标注,否则 native 代码会按 table 处理。实测对照极为干净:
| 内核 | plain | native 带类型 | native 无类型 |
|---|---|---|---|
| 数字循环(n = 200000) | 3.10 ms | 0.94 ms(3.3×) | 0.93 ms |
向量循环({ Vector3 } + Vector3 参数) |
5.23 ms | 1.06 ms(4.9×) | 5.42 ms(0.96×,无收益) |
也就是说,同一个核在参数没标注时,native 一点也没快。静态规则 native-untyped 会扫描 --!native 文件或 @native 之后的函数签名,把未标注的参数列出来,见 LuauAudit.luau。
别把所有脚本都变成 native
笔记的反面清单同样重要:
- 全量 native 会拖慢服务器启动,并消耗全局 native 内存预算([00:07:55]);
--!native撞到体积上限时改用@native标在热点函数上。 - 体积限制:每块 64K 指令、每函数 32K 块、每脚本 100 万条指令,另加全局内存上限。
- 外层作用域代码不会被 native 编译;
breakpoint、getfenv、setfenv会让优化失效([00:07:23])。静态规则env-deopt就是针对后两个的。 debug.dumpcodesize()只能在 Command Bar 的 Server 视图跑;从execute_luau调用会报"dumpcodesize can only be called from CommandBar"。
业界经验值是 4–6×(RDC23 圆桌,[00:25:02]),本技能实测为数字循环 3.3×、带类型 Vector3 循环 4.9×,两者量级一致。
Buffers:先过带宽门槛,再做范围检查
何时值得用
笔记给了一个明确的门槛:持续入站超过约 50 KB/s,或需要按实体做复制时,buffer 才划算;否则不要用(Crusherfire,[00:01:04])。
省字节的具体数字:一个 number 走 remote 是 9 字节;Color3 是 13 字节,打包后 5 字节;100 个 u16 id 是 900 字节,打包后 203 字节。线格式(wire format)的完整设计属于 scenario-roblox-networking,本文只到“值不值得打包”为止。
三个必须记住的陷阱
- buffer 的身份不会穿过 Roblox API 保留。实测通过
BindableEvent传出去的 buffer 是副本:字节相同,但不是同一个对象(received == b为 false,buffer.tostring相等为 true)。 - 整数写入静默回绕、小数静默截断:
writeu8(300)存成 44,writeu16(70000)存成 4464,writeu8(3.7)存成 3。 - JSON 编码有固定形态:
HttpService:JSONEncode把 buffer 写成{"m":null,"t":"buffer","base64":...}。另外vector.create在 Roblox 里返回的是Vector3。
口袋里的类型清单是:u8、i8、u16、i16、u32、i32、f32、f64、bool、unorm8、str8(最长 255 字节)、vec3f32。
BufferCodec.luau 的价值在于把第 2 条陷阱变成显式报错:
local Enemy = BufferCodec.schema({ { "id", "u16" }, { "hp", "f32" }, { "pos", "vec3f32" } })
local b = Enemy:encode({ id = 513, hp = 92.5, pos = vector.create(1.5, -2, 3) }) -- 18 字节
local rec = Enemy:decode(b)
local packed = Enemy:encodeList({ rec, rec }) -- u16 计数前缀
checkInt 会在值不是数字、非有限、或带小数时直接抛错,并在超范围时给出 field {name}: {v} is outside {kind} range {lo}..{hi},见 BufferCodec.luau。f32/f64 只接受有限值;unorm8 把 0..1 的浮点压进 1 字节。size 字段在 schema 含 str8 时返回 nil(变长记录),固定长度 schema 才能一次拿到记录宽度。
把笔记变成流水线:四类探针与质量门
专家笔记是“结论层”,真正执行时靠的是 AgentKit 里的四个工具,它们与笔记的章节一一对应:
| 工具 | 对应章节 | 关键输出 |
|---|---|---|
| Probe.luau | 调度器、Deferred、让出 | Probe.scheduler()、delayTiming()、signals()、yields()、pileup(1) |
| Leak.luau | 内存 | retained 存活数、sample 采样、slope 斜率(KB/周期) |
| Bench.luau | native | 交错多轮、预热、取中位数,ratio(base, other) > 1 表示更快 |
| BufferCodec.luau | buffers | size 对比 table 载荷、encodeList 打包体积 |
Bench.run 的两个设计细节呼应了笔记的“拒绝单轮基准”:每轮把各 case 交错执行(让漂移均匀作用在每个 case 上),并且先在循环外预热一次;结果同时给出 medianMs 与 minMs,默认 7 轮,每轮之间 task.wait() 以免撞上脚本超时。
在 Edit 数据模型里做静态审计可以一次拿到全部规则的命中统计:
-- dm: Edit
-- kit: LuauAudit
local r = LuauAudit.tree(game)
local rules: { [string]: number } = {}
for _, f in r.findings do
local rule: string = f.rule
rules[rule] = (rules[rule] or 0) + 1
end
return { counts = r.counts, rules = rules, total = #r.findings }
规则集覆盖了本文几乎所有章节:yield-in-frame-handler、yield-in-metamethod、removal-handler-reads-parent、superseded-runservice、env-deopt、require-in-parallel、parallel-unsafe-write、parallel-without-actor、while-true-no-yield、native-untyped、player-table-no-cleanup、module-not-strict、any-cast、colon-method-strict、index-function、signal-behavior。要理解它的能力边界:审计只读源码文本(会先把字符串内容置空、注释删除,但保留换行以维持行号),按名字传入的 handler 不会被跟踪(例如 Heartbeat:Connect(onStep) 里的 onStep)。Test 结果是 luau 与 Lune 各 13/13;在 Studio 里对 13 个脚本、278 行跑出的计数与 Lune 完全一致。唯一的环境差异是 Workspace.SignalBehavior 在 Studio 里读不出来,所以 signal-behavior 规则只在离线时触发。
最终的质量门可以压缩成四句话:两个求解器 0 错误、审计 0 错误、Leak.retained 的 alive 为 0 且斜率平坦、native 与 parallel 的收益比值达标(分别 1.2 与 1.5 以上)。达不到就回退,不保留“感觉更快”的改动。
结语:这份笔记的方法论价值
把专家笔记当作一份“事实清单”来读,它的密度来自三个习惯:每条结论都标明来源与时间戳;凡有分歧就点名纠正(defer 的优先级、协程的多线程说法、wait 的精度归因);凡有实测就写出数字与失败信息(0.07 ms vs 16.42 ms、127107 次丢失、u8 存 300 得 44、“dumpcodesize can only be called from CommandBar”)。如果要在这个仓库里继续深入,procedures.md 提供 P1–P10 的完整代码与结果,critique.md 提供交付前的自评清单,sources.md 记录了被引用的专家、文档与工具,三份文件与本文的主体共同构成一个闭环:结论可追溯、行为可复现、优化可证伪。