并发编程

NovaLang 内置丰富的并发原语，从简单的 async/await 到结构化并发。

async / await

// 异步执行，返回 Future
val future = async {
    heavyComputation()
}

// 等待结果
val result = await future

launch

fire-and-forget 异步，不关心返回值：

val job = launch {
    println("后台任务执行中")
}

parallel

同时执行多个任务，等待全部完成：

val results = parallel(
    { fetchUserData() },
    { fetchOrders() },
    { fetchRecommendations() }
)

scope / sync

适合"异步加载 → 主线程应用"的场景：

scope {
    val data = loadDataFromNetwork()
    sync {
        // 回到主线程使用数据
        updateUI(data)
    }
}

结构化并发

// 所有子任务完成后才返回
coroutineScope {
    val f1 = async { task1() }
    val f2 = async { task2() }
    println(await f1 + await f2)
}

// supervisorScope: 子任务失败不影响其他任务
supervisorScope {
    launch { riskyTask1() }
    launch { riskyTask2() }
}

Dispatchers

// 在 IO 线程池执行
withContext(Dispatchers.IO) {
    val data = readFile("large.csv")
}

// 在默认线程池执行 (CPU 密集)
withContext(Dispatchers.Default) {
    sort(largeList)
}

定时任务

// 延迟执行
val task = schedule(1000) {
    println("1 秒后执行")
}

// 重复执行
val repeating = scheduleRepeat(0, 5000) {
    println("每 5 秒执行一次")
}

// 取消
repeating.cancel()

// 异步延迟
scope {
    delay(1000)
    println("1 秒后")
}

超时控制

withTimeout(5000) {
    longRunningTask()
}
// 超时会抛出 TimeoutException

Channel — 线程间通信

val ch = Channel(10)  // 缓冲大小 10

launch {
    for (i in 1..5) {
        ch.send(i)
    }
    ch.close()
}

while (true) {
    val v = ch.receive()
    if (v == null) break
    println(v)
}

原子变量

val counter = AtomicInt(0)

parallel(
    { repeat(1000) { counter.incrementAndGet() } },
    { repeat(1000) { counter.incrementAndGet() } }
)

println(counter.get())  // 2000

Mutex — 互斥锁

val mutex = Mutex()
var shared = 0

parallel(
    { repeat(1000) { mutex.lock(); shared += 1; mutex.unlock() } },
    { repeat(1000) { mutex.lock(); shared += 1; mutex.unlock() } }
)

awaitAll / awaitFirst

val f1 = async { task1() }
val f2 = async { task2() }
val f3 = async { task3() }

// 等待全部完成
val all = awaitAll(f1, f2, f3)

// 等待最快完成的那个
val fastest = awaitFirst(f1, f2, f3)