04.4.2.1 Send/Sync 与无畏并发
所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.4 Rust / 04.4.2 并发与工程实践
04.4.2.1-001 Send 与 Sync 分别是什么标记 trait?
一句话结论
Send 表示类型的值可以安全地转移到另一个线程;Sync 表示类型的不可变引用 &T 可以安全地跨线程共享。二者都是编译器自动推导的标记 trait,没有方法。
概念解释
这两个 trait 是 Rust 线程安全检查的类型级标签。Send 管所有权转移,Sync 管共享引用。大多数由安全类型组成的结构体会自动实现;含裸指针、非原子计数等类型则不实现。
原理流程
- 编译器根据类型内部字段判断是否满足 Send/Sync。
- 跨线程传递值要求类型
Send;跨线程共享引用要求T: Sync。 - 不满足时在编译期报错,阻止数据竞争。
代码或图示
// i32、String、Vec<T> 等通常是 Send + Sync
// Rc<T> 既不是 Send 也不是 Sync
// RefCell<T> 不是 Sync
常见误区
- 以为 Send 和 Sync 是一回事:Send 转移所有权,Sync 共享引用;一个类型可以是 Send 但不是 Sync。
- 以为标记 trait 有方法可实现:它们是空 trait,靠编译器自动实现或 unsafe 手动标记。
追问
&T什么时候是 Send?答:当T: Sync时,不可变引用&T自动实现 Send,即共享引用可以跨线程传递。- 如何查看某类型是否实现?答:写
std::thread::spawn移动该类型,或用泛型约束fn f<T: Send>();编译器错误会指出缺失的标记。
04.4.2.1-002 什么是“无畏并发”?
一句话结论
无畏并发(fearless concurrency)指 Rust 在编译期通过所有权、借用规则与 Send/Sync 检查消除数据竞争,把并发 bug 拦截在编译阶段,开发者可以放心重构并发代码而不必担心隐蔽的竞态。
概念解释
数据竞争(同一时刻多线程访问同一内存,至少一个写,且无同步排序)在 Rust 中是编译错误。编译器保证类型在线程间传递/共享时满足安全约束;但死锁、逻辑竞态、顺序错误仍需人工保证。
原理流程
- 线程间传递值 → 检查
Send。 - 线程间共享引用 → 检查
Sync。 - 内部可变访问由锁/原子类型提供同步。
- 编译通过排除数据竞争,不排除所有并发问题。
代码或图示
编译期:所有权 + 借用 + Send/Sync
↓ 通过
运行时:无数据竞争;仍需避免死锁与逻辑竞态
常见误区
- 以为编译通过就没有并发问题:死锁、活锁、业务顺序竞态编译器不检查。
- 以为无畏并发不需要同步原语:共享可变数据仍要 Mutex/RwLock/原子类型。
追问
- 数据竞争与逻辑竞态区别?答:数据竞争是未同步的内存访问,属未定义行为;逻辑竞态是顺序依赖导致的业务错误,即使无数据竞争也可能发生。
- Rust 如何在编译期知道线程边界?答:
spawn闭包要求Send + 'static,类型系统沿闭包捕获字段推导安全约束。
04.4.2.1-003 哪些类型自动实现 Send/Sync,哪些不实现?
一句话结论
由安全类型组成、内部状态有同步保护的类型自动实现 Send/Sync;Rc(非原子计数)、RefCell(非同步借用计数)、裸指针、static mut 等不满足线程安全,不实现对应标记。
概念解释
自动实现规则是“字段规则”:结构体所有字段都 Send 则结构体 Send;所有字段都 Sync 则结构体 Sync。含非线程安全字段会把不安全传递给外层。
原理流程
- 遍历类型内部字段与泛型参数。
- 全部满足对应标记 → 自动实现。
- 含裸指针/非原子计数/非同步可变状态 → 不实现。
代码或图示
use std::rc::Rc; use std::cell::RefCell;
// Rc<i32> : !Send, !Sync
// RefCell<i32> : Send, !Sync
// Arc<Mutex<T>> : Send + Sync
常见误区
- 以为
String/Vec不能跨线程:owned 集合是 Send,其&T共享取决于元素是否 Sync。 - 以为
RefCell完全不能跨线程:它是 Send(可转移所有权),但不是 Sync(不能共享引用)。
追问
Cell<T>的线程安全属性?答:通常是 Send,不是 Sync;与 RefCell 一样仅限单线程共享使用。- 自定义结构体默认实现吗?答:字段都安全则自动派生 Send/Sync;含不安全字段需手动评估或封装同步。
04.4.2.1-004 &T 与 T: Sync 的传递规则是什么?
一句话结论
&T 实现 Send 当且仅当 T: Sync;也就是说,一个不可变引用能跨线程传递,前提是被引用类型允许被多线程共享。
概念解释
共享引用本身是一份访问句柄,多个线程持有 &T 等于共享内部状态。若 T 不是 Sync,共享引用会引入竞争,因此编译器不允许 &T 跨线程。
原理流程
- 判断要跨线程传递的是 owned 值还是引用。
- owned 值要求
T: Send。 - 引用
&T要求T: Sync,引用本身据此成为 Send。
代码或图示
fn share<T: Sync>(x: &T) {
std::thread::spawn(move || { let _ = x; });
}
常见误区
- 以为只要是引用就能跨线程:非 Sync 类型的引用共享会被拒绝。
- 混淆 Send 与 Sync 方向:转移 owned 看 Send,共享引用看 Sync。
追问
&mut T跨线程要求什么?答:&mut T是 Send 当T: Send;独占可变引用本身不允许多线程共享。- 标准库哪些类型是 Sync 但内部可变?答:
Mutex<T>、RwLock<T>、原子类型,它们通过同步机制让共享访问安全。
04.4.2.1-005 数据竞争在 Rust 中为什么是编译错误?
一句话结论
数据竞争需要“多线程访问同一内存 + 至少一个写 + 无同步排序”;Rust 的借用规则保证可变引用独占,Send/Sync 规则限制跨线程共享,使这种组合在类型层面无法构造,因此编译期即排除。
概念解释
在其他语言里数据竞争是运行时才暴露的未定义行为。Rust 把别名与可变性约束前移:可变访问独占,跨线程共享必须经同步类型,编译器据此拒绝不安全组合。
原理流程
- 可变数据只能有一个
&mut或经锁/原子访问。 - 跨线程共享要求类型 Sync。
- 不满足约束的代码在编译期报错,不进入运行时。
代码或图示
// 反例(编译错误):把 Rc 传入线程
// std::thread::spawn(move || { let _ = rc; });
// 正确:Arc<Mutex<T>>
常见误区
- 以为运行时也会检测数据竞争:Rust 类型系统在编译期拦截,不靠运行时检查器兜底。
- 以为 unsafe 块也受同样保护:unsafe 内可绕过部分检查,线程安全需人工保证。
追问
- 编译器如何识别“同一内存”?答:基于借用与类型所有权分析,跟踪引用与共享状态;跨线程边界由 spawn 闭包约束。
- 原子类型为什么不构成数据竞争?答:原子指令本身带内存序与硬件同步,多个线程原子访问同一变量是定义良好的。
04.4.2.1-006 Arc<Mutex<T>> 为什么能跨线程共享可变数据?
一句话结论
Arc 提供跨线程的共享所有权(原子计数,Send+Sync),Mutex 提供互斥可变访问(加锁后独占访问内部 T,Mutex
概念解释
单纯 Arc 只能共享不可变数据;单纯 Mutex 需要一个可被多线程拿到的句柄。Arc 把 Mutex 分发到多个线程,每个线程通过 lock() 取得守卫,串行化内部修改。
原理流程
Arc::new(Mutex::new(value))堆分配并共享。- 各线程
Arc::clone得到句柄。 lock()阻塞直到获得锁,返回MutexGuard,通过守卫访问 T;守卫 drop 释放锁。
代码或图示
use std::sync::{Arc, Mutex};
let data = Arc::new(Mutex::new(Vec::new()));
let h = std::thread::spawn({
let d = Arc::clone(&data);
move || { d.lock().unwrap().push(1); }
});
h.join().unwrap();
常见误区
- 以为 Arc 内部值可直接修改:必须先 lock 拿守卫,通过守卫访问。
- 以为锁守卫可以跨线程传递:守卫不是 Send(通常),应在当前临界区内使用完即释放。
追问
- 读多写少为什么考虑 RwLock?答:RwLock 允许多个读并发,写独占;Mutex 无论读写都互斥。
- Mutex 内部 T 需要满足什么?答:通常
T: Send;跨线程共享由 Arc 负责,锁保护可变访问。
04.4.2.1-007 把 Rc 传到 spawn 会报什么错?
一句话结论
编译器报错要求类型实现 Send:Rc<T> 计数非原子,不是 Send,无法进入线程闭包;错误信息会指出 Rc<T> 不能在线程间安全传递。
概念解释
spawn 的闭包必须 Send + 'static。Rc 的强/弱计数用普通整数增减,跨线程并发增减会产生计数竞争,导致提前释放或泄漏,因此被标记为非 Send。
原理流程
thread::spawn检查闭包捕获类型。- 发现捕获
Rc,要求Rc: Send。 - 标记不满足,编译错误;改为
Arc解决。
代码或图示
use std::rc::Rc;
let rc = Rc::new(1);
// std::thread::spawn(move || println!("{}", rc));
// 错误:Rc<{integer}> cannot be sent between threads safely
常见误区
- 以为把 Rc 包一层就能跨线程:问题在内部非原子计数,包装无法消除竞争。
- 以为单线程程序里 Rc 也该换 Arc:单线程用 Rc 避免原子开销,跨线程才用 Arc。
追问
- 错误信息通常怎么描述?答:类似
the trait bound Rc<T>: Send is not satisfied,并提示闭包要求Send。 - 跨线程共享不可变数据用什么?答:
Arc<T>;需要可变再配Mutex/RwLock。
04.4.2.1-008 spawn 闭包为什么要求 'static 与 Send?
一句话结论
子线程可能比当前作用域长寿,闭包不能借用当前栈上的短期数据,因此捕获值必须拥有所有权或为 'static;同时跨线程传递要求 Send。
概念解释
thread::spawn 返回的 JoinHandle 不保证线程何时结束,若闭包借用局部变量,线程后续访问会悬垂。'static 约束排除短期借用,Send 保证可安全转移。
原理流程
- spawn 把闭包移动到新线程。
- 编译器检查闭包捕获:必须
Send,且不含非'static借用。 - 借用栈数据的闭包被拒绝;owned 数据或静态引用可传入。
代码或图示
let s = String::from("x");
std::thread::spawn(move || { println!("{}", s); }); // move 取得所有权
常见误区
- 以为
'static要求数据在静态内存:owned 类型不含借用即满足'static,可进入线程。 - 以为闭包可以
&捕获局部变量传给线程:短期借用不满足'static,编译拒绝。
追问
- 如何让线程借用外部数据而不转移所有权?答:用
scoped线程(std::thread::scope),作用域保证线程在作用域结束前 join,可安全借用。 move闭包在这里的作用?答:把捕获变量移动进闭包,使闭包拥有'static所有权数据。
04.4.2.1-009 跨线程共享引用与转移所有权怎么选?
一句话结论
数据只由一个线程拥有并使用 → 移动所有权(move 闭包);多个线程长期持有同一份数据 → Arc 共享所有权;需要在作用域内临时借用 → scoped 线程。
概念解释
所有权转移最简洁、无共享开销;共享所有权需要 Arc 计数;作用域内并发处理可用 scope 借用切片,避免克隆。选择取决于数据生命周期与访问线程数。
原理流程
- 判断数据是否被多线程同时需要。
- 单线程消费 → move 转移。
- 多线程长期共享 → Arc(可变加锁)。
- 作用域内并行迭代 →
scope借用。
代码或图示
let numbers = vec![1, 2, 3];
std::thread::scope(|s| {
for n in &numbers {
s.spawn(|| println!("{}", n)); // 作用域内安全借用
}
});
常见误区
- 能共享却到处克隆:增加拷贝开销,Arc/scope 常更合适。
- 用 Arc 传递一次性数据:单消费者场景 move 转移更轻量。
追问
- scoped 线程与普通 spawn 区别?答:scope 内线程在作用域退出前自动 join,可借用栈数据;普通 spawn 要求
'static。 - Arc 克隆是否克隆内部值?答:只克隆句柄并增加原子计数,内部值共享。
04.4.2.1-010 同步类型与异步类型在 Send/Sync 上有差异吗?
一句话结论
Send/Sync 规则对同步与异步类型一致:跨线程传递看 Send,共享引用看 Sync;异步任务(Future)被 spawn 到运行时执行时,其捕获状态同样必须满足 Send(多线程运行时)。
概念解释
Future 本身是惰性状态机,多线程运行时可能在不同 worker 线程轮询,其状态跨线程移动,因此要求 Send。单线程运行时不强制 Send,但跨线程场景仍需遵守标记规则。
原理流程
- 多线程 executor 把 Future 移动到 worker 线程。
- Future 捕获/内部状态必须
Send。 - 含非 Send 类型的 Future 只能在单线程执行器上运行。
代码或图示
// 多线程 Tokio:spawn 的任务必须 Send
// tokio::spawn(async move { ... });
常见误区
- 以为异步代码不受 Send/Sync 约束:任务跨线程调度时状态安全同样由类型检查保证。
- 以为 Rc 可以出现在异步任务里:多线程运行时会拒绝非 Send Future。
追问
- 如何判断 Future 是否 Send?答:编译期由运行时 spawn 约束检查;错误提示 Future 不满足 Send,可检查内部是否持有 Rc/RefCell/裸指针。
- 单线程 executor 有什么取舍?答:不强制 Send,简化部分场景,但不能利用多核,任务阻塞会影响整个线程。
04.4.2.1-011 什么时候需要手动 unsafe impl Send/Sync?
一句话结论
封装了裸指针或非安全字段、但人工保证了线程不变量的类型,可以用 unsafe impl Send/unsafe impl Sync 显式声明;开发者承担全部线程安全责任,必须证明无数据竞争。
概念解释
自动推导因内部字段不安全而拒绝实现;如果类型通过内部同步(原子、锁、独占访问)保证安全,可手动标记。unsafe impl 跳过编译器检查,错误会变成运行时数据竞争。
原理流程
- 类型内部含裸指针/外部句柄,自动标记缺失。
- 审查访问路径,确认同步与别名规则。
unsafe impl Send for T {}(或 Sync),并在注释写明不变量。
代码或图示
struct Wrapper { raw: *mut u8 }
// 仅当内部访问由外部同步保证时:
unsafe impl Send for Wrapper {}
unsafe impl Sync for Wrapper {}
常见误区
- 随便加 unsafe impl 消除编译错误:未真正同步会引入数据竞争与未定义行为。
- 以为手动 impl 后编译器继续兜底:unsafe 标记意味着检查责任转移给作者。
追问
- 标准库哪些类型手动实现了 Send/Sync?答:带裸指针但内部有同步或独占语义的类型(如某些指针/句柄包装),具体以标准库源码为准。
- 评审 unsafe impl 重点看什么?答:共享可变状态是否有锁/原子保护,别名是否独占,是否存在跨线程悬垂。
04.4.2.1-012 编译通过后还可能有哪些并发问题?
一句话结论
编译器只排除数据竞争;死锁、活锁、饥饿、逻辑竞态、顺序依赖错误、线程泄漏仍可能发生,需要通过锁顺序、超时、状态设计与并发测试处理。
概念解释
类型安全 ≠ 业务正确。两个线程按相反顺序加锁会死锁;无界等待会饥饿;共享标志位的读写顺序可能导致业务竞态。这些属于算法与设计层面问题。
原理流程
- 数据竞争被编译期排除。
- 检查锁获取顺序、超时与释放路径。
- 评审共享状态的不变量与唤醒条件。
代码或图示
可能残留:死锁(循环等待)/ 活锁(反复退让)/ 饥饿 / 逻辑竞态 / 线程未退出
常见误区
- 以为“无畏并发”等于并发代码零风险:它消除数据竞争,不保证业务并发正确。
- 以为加了锁就没有竞态:锁只保护临界区,跨锁的复合操作仍可能有顺序问题。
追问
- 如何避免死锁?答:统一全局加锁顺序,缩小临界区,用
try_lock带超时,避免锁内等待其他锁。 - 逻辑竞态怎么排查?答:复现并发时序,加日志/追踪检查共享状态变迁,用模型检查工具或压测放大概率。
04.4.2.1-013 消息传递与共享内存两种模型如何取舍?
一句话结论
消息传递通过 channel 转移数据所有权,状态分散、耦合低,适合生产者-消费者与任务编排;共享内存通过锁/原子共享同一状态,适合频繁更新的聚合数据,但要处理互斥与临界区。
概念解释
Go 风格“不要共享内存通信,而要通信共享内存”对应 channel;Rust 两种都支持。消息传递减少共享别名,共享内存减少数据拷贝。实际系统常混合:核心状态加锁,任务间用 channel 传递消息。
原理流程
- 判断协作模式:任务解耦/异步流 → channel;集中计数/缓存 → 共享状态。
- 消息路径移动所有权,避免共享可变。
- 共享路径用 Mutex/RwLock/原子保护。
代码或图示
use std::sync::mpsc::channel;
let (tx, rx) = channel();
std::thread::spawn(move || tx.send(42).unwrap());
let v = rx.recv().unwrap();
常见误区
- 以为消息传递完全没有共享:channel 内部仍有同步,但业务数据所有权转移。
- 以为共享内存一定更慢:频繁小更新加锁可能比序列化拷贝更省,反之亦然,需实测。
追问
- channel 发送的数据是否克隆?答:默认移动所有权进通道;可克隆可 Clone 类型后发送副本。
- 两种模型在 Rust 里的类型安全?答:channel 转移 Send 值;共享内存经 Send/Sync 与锁检查保证安全。
04.4.2.1-014 thread_local! 有什么作用与边界?
一句话结论
thread_local! 为每个线程创建独立存储,变量不在线程间共享;适合线程缓存、随机数种子、上下文标识等,但线程结束后值销毁,不能用作跨线程状态。
概念解释
线程局部存储避免每个访问都加锁:每个线程有自己的副本。通过 with 闭包访问内部值。注意跨线程传递时不会共享副本,生命周期绑定线程。
原理流程
thread_local!声明变量,按线程懒初始化。- 在线程内
with(|v| ...)借用访问。 - 线程退出,局部值随线程销毁。
代码或图示
use std::cell::RefCell;
thread_local! { static COUNTER: RefCell<i32> = RefCell::new(0); }
COUNTER.with(|c| *c.borrow_mut() += 1);
常见误区
- 以为 thread_local 是全局共享变量:每个线程独立副本,互不可见。
- 以为内部可用 Mutex:线程内无并发,通常用 Cell/RefCell 即可;跨线程状态应另存。
追问
- thread_local 的值是 Send 吗?答:副本绑定线程,不能把内部值随意移出到其他线程;访问接口受借用规则约束。
- 长时间运行的线程缓存要注意什么?答:避免无界增长;配合清理与上限,防止线程驻留导致内存累积。
04.4.2.1-015 标准库线程 API:spawn、JoinHandle、scope 怎么用?
一句话结论
std::thread::spawn 创建 OS 线程并移动闭包,返回 JoinHandle 用于 join() 等待与取返回值;std::thread::scope 创建作用域线程,可在作用域内安全借用外部数据,退出前自动 join。
概念解释
普通 spawn 的闭包要求 Send + 'static;scope 线程在 scope 闭包返回前保证全部 join,因此可以借用栈上数据。JoinHandle::join 返回线程返回值的 Result。
原理流程
- spawn/scope 启动线程执行闭包。
- 需要等待时
handle.join()。 - scope 结束自动等待所有作用域线程完成。
代码或图示
let h = std::thread::spawn(|| 1 + 1);
let n = h.join().unwrap();
let data = vec![1, 2, 3];
std::thread::scope(|s| {
s.spawn(|| println!("{:?}", data));
});
常见误区
- 忘记 join 导致线程分离:主进程退出时分离线程被终止;需要结果必须 join。
- 以为 scope 线程也要求
'static:scope 内可借用外部数据,生命周期由作用域保证。
追问
join返回什么?答:Result<T, Box<dyn Any + Send>>,线程 panic 时为 Err,正常返回 Ok(返回值)。- 线程数量怎么控制?答:OS 线程创建有成本,CPU 密集用接近核数,IO 密集可配合池/异步运行时,不要无界 spawn。
04.4.2.1-016 Barrier、Condvar 分别解决什么?
一句话结论
Barrier 让一组线程到达屏障后一起放行,用于分阶段并行;Condvar(条件变量)配合 Mutex,让线程等待某个条件成立,被通知后再继续。
概念解释
Barrier 计数等待 N 个线程全部到达,再同时释放;Condvar 在条件不满足时挂起线程,其他线程改变状态后 notify_one/notify_all 唤醒。两者都是标准库同步原语。
原理流程
- Barrier:每线程
wait(),计数到达阈值后全部放行。 - Condvar:加锁检查条件,不满足
wait()释放锁并挂起;状态变化后通知。
代码或图示
use std::sync::{Arc, Mutex, Condvar, Barrier};
let barrier = Arc::new(Barrier::new(3));
let pair = Arc::new((Mutex::new(false), Condvar::new()));
常见误区
- 用 Condvar 不检查条件:唤醒可能是伪唤醒,必须在循环里重新判断条件。
- 以为 Barrier 可重复用于多轮:标准库 Barrier 可复用,所有线程再次 wait 进入下一轮(以当前文档为准)。
追问
- Condvar 为什么必须配合 Mutex?答:条件判断与状态修改需要互斥访问,
wait原子地释放锁并挂起,避免检查与等待之间漏通知。 - 通知用
notify_one还是notify_all?答:一个等待者可被唤醒用 one;条件变化影响多个等待者或不确定时用 all。
04.4.2.1-017 并发测试有哪些思路与工具?
一句话结论
并发测试包括提高重复次数与线程数、注入随机调度、使用模型检查工具穷举交错、加断言校验不变量;Rust 生态有 loom 等模型检查库,具体可用性与版本以当前文档为准。
概念解释
竞态问题概率性出现,单次测试难以复现。手段:多线程/多次运行放大概率;在关键点注入等待;用模型检查枚举执行交错;对共享状态写不变量断言。
原理流程
- 定义共享状态的不变量。
- 并发执行操作序列,反复运行。
- 用模型检查或压测工具覆盖更多交错,断言不变量不被破坏。
代码或图示
cargo test -- --test-threads=N # 控制测试并行
# loom:对并发原语做模型检查(第三方 crate,版本待确认)
常见误区
- 跑一次通过就认为并发安全:偶发竞态需要反复与模型检查。
- 只测正常路径:边界通知、panic、超时路径也要覆盖。
追问
- 如何让测试更容易暴露竞态?答:增大迭代次数、交错线程调度、在关键位置
yield_now/sleep 注入时序,结合 sanitizer(若工具链支持)。 - 标准库测试如何控制并行?答:
cargo test --test-threads调整并行线程数;单测内部可再用 scope 构造并发场景。
04.4.2.1-018 泛型约束 T: Send + Sync + 'static 什么时候写?
一句话结论
当类型要被多线程任务长期持有并共享访问时,约束 T: Send + Sync + 'static:Send 可转移、Sync 可共享、'static 不含短期借用;这是线程池/任务容器/共享配置类的常见 bound。
概念解释
不同场景要求不同:只跨线程转移用 T: Send;多线程共享引用再加 Sync;任务生命周期超出当前作用域再加 'static。组合 bound 写在泛型参数或 trait 上。
原理流程
- 判断数据是否跨线程转移、是否被共享、生命周期多长。
- 叠加对应 trait 与生命周期 bound。
- 编译器校验实参类型满足全部约束。
代码或图示
struct Worker<T: Send + Sync + 'static> {
value: T,
}
fn spawn_task<F: FnOnce() + Send + 'static>(f: F) { ... }
常见误区
- 不必要地全加
Send + Sync + 'static:限制可用类型,按实际线程边界选择。 - 以为
Sync包含Send:二者独立,需分别声明。
追问
- 闭包 bound 怎么写?答:任务闭包通常
F: FnOnce() + Send + 'static;需要在多线程共享闭包内部状态再加 Sync。 - 约束过严导致类型传不进去怎么办?答:检查是否真的需要共享/长期持有;可缩小到 Send,或把内部状态换成线程安全类型。