无需锁与原子操作的并发:Goose 无共享内存线程模型完全指南
无需锁与原子操作的并发:Goose 无共享内存线程模型完全指南
Goose 是一种内存安全的系统编程语言,它的并发设计大胆到近乎反常识:整个语言里没有锁、没有原子操作、没有内存序,因为根本不存在共享可变内存。在 Goose 中,每个工作线程被编译器当作一个"独立程序"来编译——它拥有自己的一整套数据栈和全局变量副本,线程之间只通过"类型化队列"传递扁平数据。本文带你完整理解这套无共享内存的线程模型,看看 Goose 如何从根上消灭数据竞争。
为什么"无共享"能解决并发难题?
传统并发编程的痛苦来自两个词:锁和竞争。两个线程同时读写一块共享内存,程序员必须用 mutex、atomic 或 CAS 来小心翼翼地保护它,稍有不慎就是数据竞争、死锁或内存序错误。
Goose 的回答是釜底抽薪——既然共享可变内存是竞态的根源,那就干脆不提供:
- 线程不共享任何可变状态。工作线程(worker)用
thread_fn声明,编译器会把它和它调用的所有函数编译成一个独立的程序,拥有自己的数据栈分配,并在thread_spawn那一刻从父程序复制它用到的每个全局变量。 - 工作线程修改的是自己的副本。一个线程对全局计数器自增,增的是自己那份;
main线程的计数器纹丝不动。 - 通信走类型化队列。值从一个程序进入另一个程序,唯一通道是按类型区分的队列,且值必须是**扁平(flat)**的——任何深度都不含引用、切片或相对引用。
官方参考手册对此的总结非常直白(docs/reference.md 第 22 节 Threads):
没有数据竞争可言,语言里也就没有锁、原子操作或内存序。
线程如何通信:类型化队列与扁平值
什么是"扁平值"
根据语言规范(§1.1)的定义,一个类型是 flat 的,当它在任何深度都不包含引用(reference)、切片(slice)或相对引用。标量、定长数组、变长但内联的数据结构(如 struct Row { y: i32, cells: u8[] })都是扁平的。
为什么扁平值传递很便宜?因为 Goose 的值是连续内存布局——扁平值整个就是一块连续字节,"拷贝进队列"本质上就是一次 memcpy。这正是 23_mandelbrot_threads.goose 的玩法:一行 Mandelbrot 图像(行号 + 该行像素的字节数组)作为一个扁平值穿过队列,像素都随身携带,而不是传一个句柄。
队列 API 一览
| 内置函数 | 含义 |
|---|---|
qput(v) -> bool |
把 v 放入其类型对应的队列;队列满了则立即返回 false(永不阻塞) |
qget<T>() -> T |
阻塞,取出下一个 T |
qget<T>(ms) -> T, bool |
最多等 ms 毫秒,超时返回零值 |
qpoll<T>() -> T, bool |
非阻塞取一个;没有则返回零值和 false |
qlimit<T>(n) |
给 T 的队列设置最多 n 条消息的上限 |
注意两个精妙的设计:
- 队列按类型选择。不需要写"哪个队列",
qput(job)和qput(result)自然落到两条不同的队列上,编译期类型系统保证不会取错。 qput永不阻塞。队列有qlimit上限后,满了就直接返回false,让服务端可以"拒收"而不是无限排队——用典型消息大小估算上限即可控制队列内存。
线程生命周期 API
| 内置函数 | 含义 |
|---|---|
thread_spawn(worker, args…) -> i64 |
启动工作线程,返回一个永不复用的 id |
thread_spawn_contained(worker, args…) -> i64 |
启动"受约束"线程:它的异常只会结束它自己 |
thread_wait(id) -> bool |
阻塞到该线程结束且其存储全部释放 |
thread_wait(id, msg) -> bool |
同上,且第一次等待会把受约束线程的崩溃消息追加到 msg |
hardware_threads() -> i64 |
返回合理的线程数(不超过数据栈预算允许的上限) |
几个值得记住的行为规则(来自 goose_spec.md §11.2):
- worker 数在运行时决定,没有静态上限;
thread_spawn会现场预留一块新的栈区。 - 线程退出即释放一切。无论有没有人
thread_wait,worker 返回时都会释放它的参数副本、栈区和所有数据栈区域;运行时不保留已退出线程的记录。 - 排队的消息比发送者活得久。发送线程退出后,消息仍在队列里等待接收。
main返回时,仍在运行的 worker 会被直接杀掉——所以标准的收尾流程是:发"退出"消息 →thread_wait所有 id。- 线程 ID 单调递增、永不复用,重复
thread_wait同一个已完成的 id 会立即返回。
一个典型并发程序的骨架
Goose 教程(docs/tutorial.md 第 14 节 Threads that share nothing)给出了经典的"任务队列 + 结果队列"模式,整个模式不到 20 行:
struct Job { n: i32 }
struct Result { n: i32, digits: i32 }
thread_fn worker() {
loop {
let job = qget<Job>(); // 阻塞等待任务
guard job.n >= 0 else { break; } // n == -1 表示退出
qput(Result { n: job.n, digits: count_digits(job.n) });
}
}
fn main() {
let n = max(1, hardware_threads());
for i in 8 { qput(Job { n: (1 << (i * 3)) as i32 }); }
for i in n { qput(Job { n: -1 }); } // 每个 worker 一个退出任务
var ids: i64[>..] = [];
for i in n { ids.push(thread_spawn(worker)); }
var total = 0;
for i in 8 { let r = qget<Result>(); total += r.digits; }
for id in ids { thread_wait(id); }
print(n, " workers, ", total, " digits in total");
}
这就是全部了——没有锁、没有原子、没有内存屏障,甚至没有"共享变量"这个概念。官方示例 23_mandelbrot_threads.goose 把同一模式用在了真实的并行渲染上:主程序按行派发任务,worker 池各取一行计算并回传整行像素,结果按到达顺序收集、再按行号排序输出,最后与单线程结果逐行比对验证一致性。
容错设计:受约束线程与监督者模式
默认情况下,worker 里一次 assert 失败或 abort(msg) 会结束整个程序。但如果线程是用 thread_spawn_contained 启动的,行为完全不同:
- 崩溃只结束该 worker 自己,释放它该释放的存储;
- 崩溃消息(含源码位置)不会打到 stderr,而是留给等待者:每次
thread_wait(id)都返回false,第一次thread_wait(id, msg)把消息追加进msg。
于是可以写出"监督者重启"的经典模式:
var attempt = 0;
var why: u8[>..] = [];
while !thread_wait(thread_spawn_contained(serve, attempt), why) {
print("attempt ", attempt, " failed: ", why);
why.clear();
attempt++;
}
循环不断重启 worker,直到某次成功返回 true。完整的容错语义(哪些异常只结束 worker、哪些仍然结束整个程序)可以在 goose_spec.md §11.2 和 test/threads/ 下的测试用例(如 thread_contained.goose)中逐条对照验证。
使用注意事项与编译要求
在动手前,有 5 条实践要点值得牢记:
- 必须用真正的 C 编译器构建。带线程的 Goose 程序需要
goose build(生成 C 并交给系统 C 编译器),因为进程内的 TinyCC 后端无法安置线程本地存储(TLS)。教程和参考手册都特别提示了这一点。 - 跨线程的值必须是扁平类型——
thread_fn的参数和队列元素都不允许在任何深度出现引用或切片。想传一大块数据?把它内联进结构体(就像 Mandelbrot 的行像素那样),一次性memcpy过去。 - 全局变量也受扁平规则约束。
thread_fn能到达的任何函数里,非扁平的可变全局是编译错误;但let常量(如let NAMES = ["a", "b"])例外——它的引用都指向只读静态数据,副本查看的字节谁也分不清是"复制"的。 - 线程数别拍脑袋,用
hardware_threads()。它不仅反映 CPU 数,还受进程数据栈预算约束,用它定规模的线程池永远不会耗尽地址空间。 - 收尾要完整:给每个 worker 发退出消息、收集完结果、
thread_wait每个 id,然后才让main返回。
深入阅读:相关源码与文档路径
| 资料 | 路径 |
|---|---|
| 教程:无共享线程(第 14 节) | docs/tutorial.md |
| 参考手册:线程(第 22 节) | docs/reference.md |
| 语言规范:并发(§11.2) | docs/goose_spec.md |
| 并行 Mandelbrot 完整示例 | samples/23_mandelbrot_threads.goose |
| 线程行为测试集 | test/threads/ |
| 运行时线程实现(C) | src/runtime/runtime_threads.h |
| 项目总览 | README.md |
对实现细节感兴趣的话,src/runtime/runtime_threads.h 展示了运行时如何管理 worker:每个线程跑在一块全新的栈区上,参数由调用方打包成连续缓冲、由编译器生成的入口 thunk 解包,活动 worker 用链表跟踪——这些"锁"只服务于运行时内部簿记,与你的 Goose 代码完全隔离。
总结:一种"少即是多"的并发哲学
Goose 的无共享内存线程模型可以浓缩成三句话:
- 每个
thread_fn是一个独立程序——自己的栈、自己的全局变量副本,写的是自己,互不干扰; - 通信只走类型化队列——扁平值连续存储,一次
memcpy穿越线程边界; - 容错靠受约束线程 + 监督者重启——单 worker 崩溃不波及全局。
对于新手,这意味着并发学习曲线从"锁的层级、原子操作、内存模型"骤然降为"往队列里放东西、从队列里取东西";对于系统程序员,这意味着 Goose 把 C++/Rust 里最常见的整类并发 bug——数据竞争——在语言层面直接归零,正如 README.md 所说:"数据竞争、锁、原子操作和内存序在这个语言里不存在。"

