罗罗编程学习记录
本页内容 展开查看

04.4.2.2 通道、锁与并行 rayon

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.4 Rust / 04.4.2 并发与工程实践

04.4.2.2-001 std::sync::mpsc 通道模型是什么?

一句话结论

mpsc(多生产者单消费者)通道提供 Sender 与 Receiver:多个 Sender 克隆后向同一通道发送,一个 Receiver 接收;数据所有权随消息转移。

概念解释

通道是消息传递的同步原语,内部用锁与条件变量维护队列。Sender: Send + Sync,可克隆分发;Receiver 非 Sync,由单消费者持有。关闭后发送方收到错误,接收方收到 None。

原理流程

  1. channel() 创建队列与两端。
  2. Sender::send 把值移入队列,唤醒等待的接收方。
  3. Receiver::recv 阻塞等待,try_recv 非阻塞探测。

代码或图示

use std::sync::mpsc::channel;
let (tx, rx) = channel::<i32>();
let tx2 = tx.clone();
std::thread::spawn(move || tx.send(1).unwrap());
std::thread::spawn(move || tx2.send(2).unwrap());
let a = rx.recv().unwrap();
let b = rx.recv().unwrap();

常见误区

  • 以为 mpsc 支持多消费者:标准库 mpsc 是单消费者;多消费需自行同步或用第三方/异步通道。
  • 以为发送会克隆数据:默认移动所有权进通道。

追问

  • 通道容量有几种?答:标准库 channel() 是无界缓冲;sync_channel( bound) 是有界同步通道,满时发送阻塞。具体 API 以当前文档为准。
  • Sender 为什么能克隆?答:克隆增加发送端句柄,共享同一内部队列,对应多生产者。

04.4.2.2-002 通道关闭后发送与接收行为是什么?

一句话结论

所有 Sender 丢弃后通道关闭:继续 send 返回 Err;recv 对已缓冲消息先返回,缓冲耗尽后返回 Err(try_recv 返回 Disconnected)。

概念解释

关闭由发送端全部释放触发,不是显式 close 调用。接收方可用 recv() 循环直到 Err 判断流结束,也可迭代 rx。

原理流程

  1. 发送端句柄全部 drop,内部标记断开。
  2. 残留缓冲消息仍可被接收。
  3. 缓冲清空后接收返回断开错误。

代码或图示

use std::sync::mpsc::channel;
let (tx, rx) = channel();
tx.send(1).unwrap();
drop(tx);
assert_eq!(rx.recv().unwrap(), 1);
assert!(rx.recv().is_err()); // 已关闭

常见误区

  • 以为关闭后还能继续发送:send 返回 Err(SendError)。
  • 以为关闭会丢弃未读消息:缓冲内消息先被消费完。

追问

  • 如何遍历通道直到关闭?答:for msg in rx { ... },断开后循环自动结束。
  • 有界通道关闭时阻塞的发送方怎么办?答:断开后 send 失败返回错误,不再阻塞;具体唤醒行为以标准库实现为准。

04.4.2.2-003 Mutex<T> 的结构与 lock() 返回值是什么?

一句话结论

Mutex<T> 内部包着受互斥保护的数据与锁状态;lock() 返回 LockResult<MutexGuard<T>>,成功得到守卫,守卫离开作用域自动释放锁。

概念解释

Mutex 把“数据”和“互斥”绑定在一起,避免锁与数据分离。守卫 MutexGuard 实现 Deref/DerefMut 访问内部 T;持有守卫期间其他线程加锁阻塞。

原理流程

  1. Mutex::new(value) 包装数据。
  2. lock() 阻塞直到获得锁,返回守卫。
  3. 通过守卫读写 T;守卫 drop 时解锁。

代码或图示

use std::sync::Mutex;
let m = Mutex::new(0);
let mut g = m.lock().unwrap();
*g += 1;
drop(g); // 显式释放,或离开作用域自动释放

常见误区

  • 以为 lock() 直接返回内部 T:返回的是守卫,经 Deref 访问 T。
  • 以为守卫可以长期存放在结构体字段:长期持有会阻止其他线程访问,需评估临界区。

追问

  • try_lock 与 lock 区别?答:try_lock 不阻塞,立即返回 LockResult<Option<Guard>>(以当前签名为准),适合带超时或避免死锁的场景。
  • Mutex 内部 T 有什么约束?答:通常要求 T: Send;Mutex<T> 本身可 Sync,从而支持跨线程共享。

04.4.2.2-004 锁中毒(poisoning)是什么?

一句话结论

持锁线程在持有 MutexGuard 期间 panic,锁被标记为中毒(poisoned);后续 lock() 返回 Err(PoisonError),防止在数据可能处于不一致状态时继续访问。

概念解释

panic 中断了临界区操作,内部数据可能只被改了一半。中毒是一种保守保护:默认拒绝继续加锁,由开发者决定是恢复数据还是终止。守卫在 unwind 时解锁并置中毒标志。

原理流程

  1. 线程持有守卫时 panic,栈展开。
  2. Drop 守卫时发现 panic 正在展开,标记锁中毒。
  3. 后续加锁返回 PoisonError;可 into_inner() 取出内部数据自行恢复。

代码或图示

use std::sync::Mutex;
let m = Mutex::new(0);
let result = m.lock();
match result {
    Ok(_g) => {}
    Err(poisoned) => { let _g = poisoned.into_inner(); }
}

常见误区

  • 以为中毒后锁永久损坏:可通过 PoisonError::into_inner 取得守卫/内部值,前提是确认数据可恢复。
  • 以为中毒是死锁:中毒是状态标记,不是阻塞等待。

追问

  • 为什么标准库选择中毒而非直接放行?答:panic 可能留下半更新状态,继续访问风险高;保守拒绝由上层决策恢复。
  • 业务代码如何处理中毒?答:关键服务可记录日志后 into_inner 恢复;不可恢复的状态应让线程/进程退出。

04.4.2.2-005 RwLock<T> 适用场景与写饥饿问题?

一句话结论

RwLock 读写锁允许多个读并发、写独占;适合读多写少的数据。实现可能偏向读者或写者,存在写饥饿风险,且不同平台(Windows/POSIX)行为有差异。

概念解释

读操作不修改数据,可共享;写需要独占。RwLock 维护读计数与写标志。若实现持续放行新读,等待的写者可能长期得不到锁,即写饥饿。

原理流程

  1. 读请求:无写者且无等待写者(视实现)→ 多个读守卫并发。
  2. 写请求:无读者无写者 → 独占。
  3. 守卫 drop 后按实现策略放行等待方。

代码或图示

use std::sync::RwLock;
let rw = RwLock::new(vec![1, 2, 3]);
{ let _r = rw.read().unwrap(); }
{ let mut _w = rw.write().unwrap(); }

常见误区

  • 以为 RwLock 一定比 Mutex 快:读少写多或临界区极短时,Mutex 更简单且开销可能更低。
  • 以为跨平台读等待策略一致:读者/写者优先与饥饿处理依平台实现不同。

追问

  • 读守卫与写守卫能否同时存在?答:不能;读共享期间写阻塞,写独占期间读阻塞。
  • 什么场景避免用 RwLock?答:写频繁、临界区很短、或需要严格公平性保证时,评估 Mutex 或其他同步结构。

04.4.2.2-006 MutexGuard 的生命周期与跨线程限制?

一句话结论

守卫的生命周期从 lock() 成功到显式 drop 或离开作用域;守卫不是可跨线程发送的类型(通常非 Send),应在获得锁的线程内使用完即释放。

概念解释

守卫持有锁的独占权,移动到其他线程会破坏“锁与持有线程”的关联模型。标准库守卫类型不实现 Send,编译器阻止跨线程传递。

原理流程

  1. 加锁成功生成守卫。
  2. 守卫 Deref/DerefMut 访问数据。
  3. 守卫 drop 解锁;跨线程移动被类型检查拒绝。

代码或图示

let g = m.lock().unwrap();
// std::thread::spawn(move || { let _ = g; }); // 编译错误:guard 非 Send

常见误区

  • 把守卫存进全局/长生命周期结构:锁被长期持有,其他线程阻塞。
  • 以为复制守卫就能共享访问:守卫不可复制,一个锁同一时刻只有一个写守卫。

追问

  • 如何在函数间传递锁的所有权?答:返回内部数据的克隆/视图,不要返回守卫;确需跨层持有要明确临界区边界。
  • 守卫释放顺序?答:后创建的守卫先 drop(逆序),嵌套锁注意顺序避免死锁。

04.4.2.2-007 死锁成因与避免手段有哪些?

一句话结论

死锁源于循环等待、持锁等待、不可抢占与互斥四条件同时成立;避免手段:统一全局加锁顺序、缩小临界区、try_lock 带超时、避免锁内做阻塞 IO 或等待其他锁。

概念解释

两个线程各持一把锁并请求对方的锁,形成循环等待。Rust 编译期不检测死锁,需在设计与代码评审中消除:固定顺序获取多把锁,超时放弃并回退。

原理流程

  1. 列出所有需要的锁与获取顺序。
  2. 全代码库按同一顺序加锁。
  3. 临界区只做内存操作,IO/远程调用放到锁外。
  4. 必要时 try_lock 超时回退。

代码或图示

// 反例:A 先锁1再锁2;B 先锁2再锁1
// 正确:所有路径都先锁 A 后锁 B

常见误区

  • 以为加锁粒度越细越安全:锁越多越易出现顺序交叉;应按数据聚合划分锁。
  • 在锁内调用回调/远程服务:延长临界区,增加阻塞与死锁概率。

追问

  • 检测死锁有哪些手段?答:线程 dump/堆栈分析等待链,压测观察阻塞;部分运行时/工具可检测锁顺序(视生态而定,待确认)。
  • 拿不到锁时怎么处理?答:try_lock 失败可重试或降级;避免无限期阻塞,设置超时与告警。

04.4.2.2-008 Arc + 锁的典型共享可变集合怎么写?

一句话结论

Arc<Mutex<Vec<T>>>(或 Arc<RwLock<...>>)把共享所有权与互斥可变组合:每个线程克隆 Arc,需要修改时 lock 取守卫,操作完守卫 drop 自动解锁。

概念解释

Arc 负责把同一集合分发到多个线程,锁负责串行化修改。克隆 Arc 不克隆内部集合。临界区内只做必要的数据操作,复杂计算移到锁外。

原理流程

  1. 构造 Arc::new(Mutex::new(collection))。
  2. 工作线程 Arc::clone 句柄。
  3. lock() → 守卫 → 修改 → drop 守卫。

代码或图示

use std::sync::{Arc, Mutex};
let list = Arc::new(Mutex::new(Vec::<u32>::new()));
let mut handles = Vec::new();
for i in 0..4 {
    let l = Arc::clone(&list);
    handles.push(std::thread::spawn(move || {
        l.lock().unwrap().push(i);
    }));
}
for h in handles { h.join().unwrap(); }

常见误区

  • 在锁内做批量阻塞操作:拉长临界区,降低并发度。
  • 克隆内部 Vec 再放回:可用于读多场景减少持锁,但要注意合并回写。

追问

  • 计数与锁的开销在哪?答:Arc 原子计数增减;Mutex 加解锁系统调用/自旋;热点路径评估粒度与分区锁。
  • 分区锁(sharding)什么时候用?答:单集合竞争激烈时,按键哈希分到多个子锁,降低同一把锁的等待。

04.4.2.2-009 OnceLock/OnceCell 与 lazy_static 有何区别?

一句话结论

OnceLock<T>/OnceCell<T> 是标准库的一次性初始化容器:首次写入后不可变读取,线程安全;lazy_static 是第三方 crate,在标准库 OnceLock 稳定前提供类似能力。

概念解释

全局共享配置、单例句柄只需初始化一次。OnceLock 提供 get()/set(),标准库内置无需额外依赖;lazy_static 用宏包装静态初始化,具体能力与版本以当前文档为准。

原理流程

  1. 声明 static X: OnceLock<Config> = OnceLock::new();。
  2. 首次访问 X.get_or_init(|| build()) 初始化。
  3. 之后 X.get() 返回共享引用。

代码或图示

use std::sync::OnceLock;
static CONFIG: OnceLock<String> = OnceLock::new();
fn config() -> &'static String {
    CONFIG.get_or_init(|| "cfg".to_owned())
}

常见误区

  • 以为 OnceLock 内部值可替换:写入一次后不可变;需要可替换状态用 Mutex/RwLock。
  • 以为所有版本标准库都有 OnceLock:它在较新版本稳定,旧项目可能仍用 lazy_static/once_cell(版本待确认)。

追问

  • OnceCell 与 OnceLock 区别?答:OnceCell 单线程/非 Sync 场景使用,OnceLock 线程安全;标准库类型划分以当前文档为准。
  • 初始化函数会被调用多次吗?答:并发下只成功一次初始化,其他线程等待结果;get_or_init 保证只写入一次。

04.4.2.2-010 rayon 的 par_iter 与普通迭代器有什么区别?

一句话结论

rayon 数据并行迭代器 par_iter() 把元素分派到线程池并行处理,返回与顺序迭代器相似的适配器链;前提是迭代元素与闭包满足 Send,且操作可并行化。

概念解释

rayon 维护工作窃取线程池,自动划分任务粒度。par_iter/par_iter_mut/into_par_iter 对应三种所有权迭代;结果语义与顺序版本一致(除顺序不保证)。

原理流程

  1. 集合调用 par_iter() 进入并行迭代器。
  2. rayon 按负载切分元素到工作线程。
  3. 适配器并行执行,收集结果合并。

代码或图示

use rayon::prelude::*;
let nums: Vec<i64> = (0..1000).collect();
let sum: i64 = nums.par_iter().map(|x| x * x).sum();

常见误区

  • 以为任何迭代都该并行:任务太小、顺序依赖或共享状态竞争时,并行开销可能超过收益。
  • 以为 par_iter 保留输出顺序:收集顺序不保证;需要有序结果用对应收集方法。

追问

  • rayon 线程池大小怎么控制?答:rayon::ThreadPoolBuilder 配置全局或局部线程池;默认按 CPU 核数,具体 API 以 crate 文档为准。
  • 并行闭包捕获什么约束?答:捕获数据需 Send;可变并行迭代要求访问安全,避免在闭包里共享可变别名。

04.4.2.2-011 任务并行:rayon::scope 与标准 thread::scope 怎么用?

一句话结论

rayon::scope 在 rayon 线程池内派生并行子任务,适合数据/任务并行;标准 thread::scope 派生 OS 线程,作用域结束前自动 join,可安全借用外部数据。

概念解释

任务并行是把不同子任务分派出去,而非对单一集合切分。rayon scope 复用线程池、任务轻量;标准 scope 用 OS 线程,适合较重任务。两者都保证作用域内任务完成后才继续。

原理流程

  1. 进入 scope 闭包。
  2. 通过 spawn 派生子任务。
  3. 作用域退出前等待全部子任务完成,借用数据安全。

代码或图示

rayon::scope(|s| {
    s.spawn(|_| work_a());
    s.spawn(|_| work_b());
});

常见误区

  • 以为 rayon scope 任务脱离池长期运行:任务在池线程执行,阻塞会占用工作线程。
  • 在并行任务里做阻塞 IO:占满工作线程影响其他并行任务,应隔离到独立线程或异步运行时。

追问

  • 数据并行与任务并行怎么选?答:同构元素批量处理用 par_iter;异构子任务用 scope spawn。
  • rayon 与 OS 线程池区别?答:rayon 任务轻量、工作窃取、适合 CPU 密集;OS 线程创建销毁成本高,阻塞任务不宜塞进 rayon。

04.4.2.2-012 锁内能否做 IO 或阻塞调用?

一句话结论

不应在临界区内做阻塞 IO、远程调用或等待其他锁:这会拉长持锁时间,造成其他线程排队、吞吐下降,并提高死锁概率;需要 IO 的数据应在锁外准备或回写。

概念解释

锁保护的是内存不变量,不保护外部资源。把网络/磁盘/数据库调用放进锁内,临界区长度不可控,线程池容易被慢调用占满。正确做法:锁内取值/计算,锁外 IO,必要时再持锁回写。

原理流程

  1. lock 取守卫。
  2. 复制需要的数据或完成内存修改。
  3. drop 守卫后执行 IO/远程调用。
  4. 需要更新状态时重新加锁回写。

代码或图示

let snapshot = { list.lock().unwrap().clone() }; // 锁内只取数据
send_over_network(snapshot);                     // 锁外 IO

常见误区

  • 以为“反正要更新数据”就一直持锁:持锁等待外部响应是典型吞吐杀手。
  • 在锁内调用用户提供的回调:回调可能做任意阻塞操作,反转控制权风险高。

追问

  • 必须在锁内更新复杂状态怎么办?答:把判断与计算移到锁外,锁内做最小合并;竞争激烈时考虑分区锁或无锁结构。
  • 如何测量临界区过长?答:加计时埋点统计持锁时长,结合线程等待堆栈定位热点锁。

04.4.2.2-013 Rust 异步运行时是什么,标准库为什么不带执行器?

一句话结论

async fn 返回惰性 Future,需要 executor 轮询驱动;Rust 标准库只定义 Future trait,不内置运行时,常用 Tokio、async-std 等第三方执行器。

概念解释

标准库保持最小内核,异步运行时涉及线程池、IO 多路复用、定时器、任务调度等策略,交给生态选择。Future 被 poll 时推进状态机,未就绪则挂起等待唤醒。

原理流程

  1. async fn 调用返回 Future,不执行内部逻辑。
  2. 运行时 spawn 任务,在工作线程上 poll。
  3. Future 未就绪返回 Pending,就绪后被唤醒再 poll 到完成。

代码或图示

// tokio 示例(依赖 tokio crate)
#[tokio::main]
async fn main() {
    tokio::spawn(async { /* 异步任务 */ });
}

常见误区

  • 以为写了 async fn 就自动并发:Future 惰性,必须由执行器 poll。
  • 以为标准库自带 tokio 等价物:标准库只有 Future trait,运行时来自第三方。

追问

  • 为什么标准库不绑定单一运行时?答:不同场景对调度、阻塞隔离、IO 模型有不同需求,保持生态可替换。
  • 常用运行时区别?答:Tokio 生态最广、多线程调度;async-std 对齐标准库风格;具体特性版本以各 crate 文档为准。

04.4.2.2-014 Tokio 多线程运行时、spawn 与 spawn_blocking?

一句话结论

Tokio 多线程运行时用工作线程池调度异步任务;spawn 提交 Future 到异步线程池;CPU 密集或阻塞操作应使用 spawn_blocking 隔离到专门线程池,避免阻塞异步 worker。

概念解释

异步 worker 数量有限,被阻塞调用卡住会降低整体并发。spawn 任务必须非阻塞;阻塞计算/同步 IO 用 spawn_blocking,其专用线程池隔离阻塞影响。

原理流程

  1. 构建多线程 Runtime,启动 N 个 worker。
  2. spawn 任务进调度队列被 poll。
  3. 阻塞任务走 spawn_blocking,在隔离线程池执行,结果通过 JoinHandle 返回。

代码或图示

let handle = tokio::task::spawn_blocking(|| {
    // 阻塞 CPU 计算或同步 IO
    expensive_blocking_work()
});

常见误区

  • 在 async 任务里调用同步阻塞库:阻塞 worker,拖垮所有异步任务。
  • 以为 spawn_blocking 任务也跑在异步 worker:它使用独立阻塞线程池。

追问

  • 如何判断任务是否阻塞?答:不含 await 的长 CPU 计算、同步文件/网络调用、阻塞锁等待都属于阻塞,应隔离。
  • Tokio 线程数怎么配?答:多线程运行时默认按核数,可配置 worker 线程数与最大 blocking 线程数,具体参数以当前 tokio 版本为准。

04.4.2.2-015 Future 为什么是惰性的,poll 模型是什么?

一句话结论

Future 是返回 Poll::Ready/Poll::Pending 的状态机,不被 poll 就不推进;惰性设计让执行器决定何时轮询、在哪个线程轮询,并在未就绪时挂起让出 worker。

概念解释

每次 poll 推进到下一个 await 点:完成返回 Ready,未就绪返回 Pending 并注册唤醒器。执行器在 Future 就绪时再次 poll,直到 Ready。

原理流程

  1. 调用 async fn 构造 Future。
  2. executor 调用 poll(cx)。
  3. 未就绪 → Pending,Waker 记录;就绪 → 唤醒后再次 poll。
  4. 最终 Ready(输出)。

代码或图示

Future::poll(cx) -> Poll<Output>
  Ready(v)  → 完成
  Pending   → 挂起,Waker 就绪后再 poll

常见误区

  • 以为 Future 创建时就开始执行:创建只是构造状态机,逻辑在首次 poll 后推进。
  • 以为 Pending 会忙等:注册 Waker 后让出线程,事件就绪才唤醒。

追问

  • Waker 起什么作用?答:通知执行器该 Future 已就绪,需要再次 poll;避免执行器反复轮询。
  • Future 是 Send 吗?答:取决于内部状态;多线程运行时 spawn 要求 Future: Send。

04.4.2.2-016 异步代码里能否使用阻塞锁或阻塞 IO?

一句话结论

不能在异步任务里使用标准库阻塞 Mutex/同步阻塞 IO:它们会卡住异步 worker,阻塞整个调度;应使用运行时提供的异步锁(如 tokio::sync::Mutex)与异步 IO API。

概念解释

异步线程被阻塞调用挂起期间无法处理其他任务,线程池很快耗尽。异步锁在等待时让出执行权,不阻塞 worker;同步库的锁等待是线程级阻塞。

原理流程

  1. 异步任务遇到阻塞调用。
  2. 标准 Mutex/同步 IO 挂起当前线程。
  3. worker 无法轮询其他任务,并发度下降。
  4. 改用异步原语,等待时让出,就绪后继续。

代码或图示

// 推荐:异步 Mutex(tokio)
let lock = tokio::sync::Mutex::new(0);
let mut g = lock.lock().await;

常见误区

  • 以为短临界区用标准 Mutex 无所谓:只要等待时可能被其他线程卡住,就会阻塞 worker。
  • 在 async 里调同步数据库驱动:阻塞 IO 同理,应换异步驱动或 spawn_blocking 隔离。

追问

  • 异步 Mutex 与标准 Mutex 取舍?答:异步任务内用异步锁;纯同步代码或 spawn_blocking 内用标准 Mutex。
  • 异步锁会中毒吗?答:不同运行时实现策略不同;以对应 crate 文档为准,避免假设与标准库行为一致。

04.4.2.2-017 异步通道与同步 mpsc 的边界是什么?

一句话结论

同步 std::sync::mpsc 面向 OS 线程阻塞收发;异步通道(如 tokio::sync::mpsc/broadcast)在等待时让出异步执行权,配合 .await,用于异步任务间传递消息。

概念解释

两种通道服务不同执行模型:线程模型阻塞挂起线程;异步模型挂起任务不占 worker。跨模型边界需要小心:不要在 async 任务里阻塞等待同步通道。

原理流程

  1. 线程间通信 → 标准 mpsc/sync_channel。
  2. 异步任务间通信 → 运行时异步通道,send/recv 可 await。
  3. 阻塞任务与异步任务交接,通过专门桥接或 blocking 通道。

代码或图示

// tokio 异步通道示例
let (tx, mut rx) = tokio::sync::mpsc::channel::<i32>(16);

常见误区

  • 在 async 任务里 rx.recv() 阻塞等待同步通道:卡住 worker。
  • 混淆容量语义:异步通道缓冲容量、关闭通知与标准库 API 不完全相同。

追问

  • broadcast/watch 适用什么?答:广播给多个接收者、共享最新状态;具体语义按运行时 crate 文档。
  • 异步通道是多消费者吗?答:tokio mpsc 支持多消费者(Receiver 可克隆),与标准库单消费者不同;以实现为准。

04.4.2.2-018 并行迭代对元素有什么线程安全前提?

一句话结论

并行迭代的元素、闭包捕获与产出结果必须满足 Send;并行可变迭代要求访问不产生别名冲突;共享可变状态需通过 Arc<Mutex/RwLock> 或分区保证安全。

概念解释

rayon 把元素分发到不同线程,元素与捕获值随之跨线程移动。若闭包内部共享可变且无同步,并行即引入数据竞争。编译器 Send/Sync 检查与人工审查共同保证安全。

原理流程

  1. 迭代元素类型满足 Send。
  2. 闭包捕获数据满足 Send(共享可变为 Sync + 同步)。
  3. 并行分支互不写同一别名,或经锁/分区隔离。

代码或图示

use std::sync::{Arc, Mutex};
use rayon::prelude::*;
let counter = Arc::new(Mutex::new(0));
(0..100).into_par_iter().for_each(|_| {
    *counter.lock().unwrap() += 1;
});

常见误区

  • 在并行闭包里直接改外部可变变量:别名冲突,编译拒绝或运行时竞争。
  • 以为 par_iter 自动处理共享状态:仍需开发者提供同步结构。

追问

  • 并行归约怎么做?答:用 reduce/fold 按局部合并再汇总,避免每个元素抢同一把锁。
  • 元素不是 Send 能否并行?答:不能跨线程分发;先在单线程整理成 Send 视图,或改为顺序迭代。