并发
Sprig 没有 async/await 这类语法,也没有"带颜色"的函数。并发是自带的模块 @std/concurrent.spr,用 Sprig 写成,底下一小层 Java 内核(sprig.runtime.concurrent)。任务跑在 JDK 21 的虚拟线程上:一万个会阻塞的任务和十个一样便宜,普通的阻塞代码(Java 的 HttpClient.send、JDBC、文件读写)放进任务里原样就能跑。示例项目 examples/parallel_words 用到了它的每一部分。
作用域:每个任务都有主人
import "@std/concurrent.spr" as concurrent
func word_count(line: String) -> Int:
return line.split(" ").size()
func count_all(s: concurrent.Scope) -> List[Int] throws Error:
let tasks: MutableList[concurrent.Task[Int]] = []
for line in ["the quick brown fox", "a lazy dog"]:
tasks.append(concurrent.spawn(s, fn() => word_count(line)))
return concurrent.await_all(tasks)
print(concurrent.scope(count_all))concurrent.scope(body)新建一个Scope,把它交给body运行,返回body的结果。body通常是按名字传入的具名函数,因为 lambda 只能写一个表达式。spawn(s, work)在这个作用域拥有的一条虚拟线程上运行fn() -> T,返回Task[T]。类型参数按通常的规则推断:这里从 lambda 的结果得到Int。- 离开作用域时会等所有任务结束,不管有没有
await。没有任务能活过启动它的那个函数。 - 第一个失败会取消其他兄弟任务,并由
scope()作为Error重新抛出,所以scope声明了throws Error。就算 body 是因为在等一个被这次失败取消掉的任务才失败的,你拿到的也是那个失败,而不是 "task was cancelled"。任务里的失败也会由那个任务的await()报出来;在那里接住它并不能撤销作用域的失败。要容忍某个任务失败,就在任务体里处理掉,比如返回Ok/Failed这样的 variant。await_or(fallback)并不会容忍失败:任务失败或被取消时它给出兜底值,而且没有throws子句,所以一个任务体可以用它等另一个任务,但作用域照样会失败。 - 主动取消的任务(
task.cancel()、s.cancel_all()、线程池的shutdown_now())不算失败。取消会中断任务的线程,在阻塞点生效:sleep、await、通道的receive、尊重中断的 Java I/O。一个从不阻塞的循环会跑到头。所以cancel()之后is_done()马上就是true,哪怕任务体还在跑、要到下一个阻塞点才停;作用域照样会等任务体结束。 - 没有不属于作用域的
spawn:任务永远属于启动它的那个作用域,body 返回之后再启动任务会报Error。 - 任务体是普通的函数值,捕获不了函数里的
var局部变量,所以其他语言里那种对局部变量的数据竞争在 Sprig 里写不出来。其余共享的东西都不受保护:模块顶层的var(任务体能读到它,它调用的函数也能改它),共享的MutableList、MutableMap,以及var字段。要在任务之间共享,就用下面的计数器、锁或通道。
没有结果的任务:run 和 scope_run
Unit 不是值,所以只有副作用的任务不能写成 Task[Unit]。这种任务用 run;只负责调度、不返回结果的作用域体用 scope_run:
import "@std/concurrent.spr" as concurrent
func announce(line: String) -> Unit:
print("> " + line)
func announce_all(s: concurrent.Scope) -> Unit throws Error:
for line in ["ready", "steady"]:
concurrent.run(s, fn() => announce(line))
concurrent.scope_run(announce_all)run(s, work)启动一个fn() -> Unit,返回Job。它的方法和任务一样:await()等它结束,失败时报Error,只是不返回值;cancel()、is_done()也照常可用。scope_run(body)就是给"不返回值的 body"用的scope(),规则完全相同:等所有任务和 job 结束,第一个失败会取消其余的并重新抛出。- 两条输出的先后顺序不固定,因为它们是同时运行的。
一批任务:parallel_map 和 await_all
let counts = concurrent.parallel_map(lines, fn(line: String) => word_count(line))parallel_map 自己开一个作用域,给每个元素一个任务,等全部结束后按元素顺序返回结果;await_all(tasks) 在你的作用域里对一组 Task[T] 做同样的事,遇到第一个失败就抛出。
虚拟线程让任务数量不再是成本,I/O 为主的工作不需要限流。要把 CPU 密集的工作限制在几条平台线程上,用线程池:
func count_on_pool(s: concurrent.Scope) -> List[Int] throws Error:
let pool = concurrent.pool(2)
let tasks: MutableList[concurrent.Task[Int]] = []
for line in lines:
tasks.append(concurrent.spawn_on(s, pool, fn() => word_count(line)))
let results = concurrent.await_all(tasks)
pool.shutdown()
return results池里的任务仍然属于作用域。shutdown() 之后池子不再接新任务(再 spawn_on 会报 Error),正在跑的任务照常完成;await_termination(millis) 等它们全部结束。shutdown_now() 同样让池子不再接新任务,但会取消池里的任务:正在跑的被中断,排队的不再运行。和其他主动取消一样,这不算作用域失败。parallel_map_on(pool, items, transform) 是一行的写法。
通道:线程之间传值
let words = concurrent.channel[String](16)
func produce() -> Int:
words.send("a")
words.send("b")
words.close()
return 2
func consume(s: concurrent.Scope) -> Int throws Error:
let producer = concurrent.spawn(s, fn() => produce())
var next = words.receive()
while next != null:
let word = next
if word != null:
print(word)
next = words.receive()
return producer.await()
print(concurrent.scope(consume))next 是 var,所以 while next != null 不会把它收窄。先复制到 let word,再检查 word;通过检查后,循环体里才能把它当作非空字符串使用。
channel[T](capacity)是有界队列。send在队列满时阻塞;receive()在队列空时阻塞,通道关闭且取空后返回null。通道里不放null,所以null只有"结束"这一个意思。try_send不阻塞,满了或关闭了返回false;receive_within(millis)最多等millis毫秒,超时返回null(用is_closed()区分超时和关闭)。- 往关闭的通道
send会在运行时以Error失败。send没有throws子句,这样任务体里才能调用它;失败由那个任务的await()和作用域报出来。
计数器、锁和门闩
let total = concurrent.counter(0)
total.add(3)
print(total.get())
let guard = concurrent.lock()
let finished: MutableList[String] = []
guard.run(fn() => finished.append("done"))
let size = concurrent.locked(guard, fn() => finished.size())
let gate = concurrent.latch(3)
gate.count_down()
print(gate.await_within(1000))Counter是原子的Int:get、set、add、increment、decrement、compare_and_set。和Int运算一样,add、increment、decrement的结果超出Int范围时会失败,报的是和+相同的数值错误,计数器的值保持不变。Lock是可重入的互斥锁:run(action)和locked(lock, work)在持有锁的时候运行函数值。修改共享的MutableList/MutableMap时用它。它是java.util.concurrent的锁,持有它的任务不会钉住虚拟线程的载体线程。Latch是倒数计数:每个任务count_down(),等待方await()或await_within(millis)。
任务体里的错误
任务体是 fn() -> T,没有 throws 子句,所以它不能直接调用声明了 throws Error 的函数。两种写法:
- 在任务体调用的具名函数里
try/catch,把结果转成variant(比如Ok/Failed)返回; - 让它失败:
await()在等待处报出来,作用域结束时再报一次。await_or(fallback)没有throws子句,一个任务体可以用它等另一个任务。
任务体常调用的这些都没有 throws 子句:通道的 send、receive 和 receive_within,concurrent.sleep,锁的 run,以及 concurrent.locked;参数不合法时在运行时报 Error。concurrent.spawn 和 concurrent.run 声明了 throws Error,任务体不能直接调用它们。concurrent.sleep(millis) 和 time.sleep 的区别就在这里:正在 sleep 的任务被取消时会立刻结束。
为什么不是 async/await
async 会给函数染色:async 函数只能在另一个 async 函数里 await,代码库从此分成两半。语言选择它,是因为运行时没有便宜的线程。JDK 21 起 JVM 有了虚拟线程,阻塞变得便宜,任务就只是"在别处运行的一个函数"。Sprig 和 Java、Go 一样走这条路:不加语法,不给函数染色,结构来自作用域而不是类型系统。
还没有的
Task 不能用 then 串起来,用 await_all、通道和普通函数来组合。作用域本身没有超时预算(await_within 是针对单个任务的);java.util.concurrent.StructuredTaskScope 还是预览 API,暂不使用。
sprig api @std/concurrent.spr --json 列出每个签名和注释,sprig help concurrency 是编译器自带的规则摘要。仓库里的测试 python3 tests/concurrent/check_concurrent.py 在真实线程上验证这一页说的每条行为,包括一万个睡眠任务同时完成,以及任务里的本地回环套接字回显。
