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

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 管共享引用。大多数由安全类型组成的结构体会自动实现;含裸指针、非原子计数等类型则不实现。

原理流程

  1. 编译器根据类型内部字段判断是否满足 Send/Sync。
  2. 跨线程传递值要求类型 Send;跨线程共享引用要求 T: Sync。
  3. 不满足时在编译期报错,阻止数据竞争。

代码或图示

// 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 中是编译错误。编译器保证类型在线程间传递/共享时满足安全约束;但死锁、逻辑竞态、顺序错误仍需人工保证。

原理流程

  1. 线程间传递值 → 检查 Send。
  2. 线程间共享引用 → 检查 Sync。
  3. 内部可变访问由锁/原子类型提供同步。
  4. 编译通过排除数据竞争,不排除所有并发问题。

代码或图示

编译期:所有权 + 借用 + 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。含非线程安全字段会把不安全传递给外层。

原理流程

  1. 遍历类型内部字段与泛型参数。
  2. 全部满足对应标记 → 自动实现。
  3. 含裸指针/非原子计数/非同步可变状态 → 不实现。

代码或图示

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 跨线程。

原理流程

  1. 判断要跨线程传递的是 owned 值还是引用。
  2. owned 值要求 T: Send。
  3. 引用 &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 把别名与可变性约束前移:可变访问独占,跨线程共享必须经同步类型,编译器据此拒绝不安全组合。

原理流程

  1. 可变数据只能有一个 &mut 或经锁/原子访问。
  2. 跨线程共享要求类型 Sync。
  3. 不满足约束的代码在编译期报错,不进入运行时。

代码或图示

// 反例(编译错误):把 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 是 Send+Sync);两者组合既共享所有权又安全修改。

概念解释

单纯 Arc 只能共享不可变数据;单纯 Mutex 需要一个可被多线程拿到的句柄。Arc 把 Mutex 分发到多个线程,每个线程通过 lock() 取得守卫,串行化内部修改。

原理流程

  1. Arc::new(Mutex::new(value)) 堆分配并共享。
  2. 各线程 Arc::clone 得到句柄。
  3. 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。

原理流程

  1. thread::spawn 检查闭包捕获类型。
  2. 发现捕获 Rc,要求 Rc: Send。
  3. 标记不满足,编译错误;改为 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 保证可安全转移。

原理流程

  1. spawn 把闭包移动到新线程。
  2. 编译器检查闭包捕获:必须 Send,且不含非 'static 借用。
  3. 借用栈数据的闭包被拒绝;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 借用切片,避免克隆。选择取决于数据生命周期与访问线程数。

原理流程

  1. 判断数据是否被多线程同时需要。
  2. 单线程消费 → move 转移。
  3. 多线程长期共享 → Arc(可变加锁)。
  4. 作用域内并行迭代 → 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,但跨线程场景仍需遵守标记规则。

原理流程

  1. 多线程 executor 把 Future 移动到 worker 线程。
  2. Future 捕获/内部状态必须 Send。
  3. 含非 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 跳过编译器检查,错误会变成运行时数据竞争。

原理流程

  1. 类型内部含裸指针/外部句柄,自动标记缺失。
  2. 审查访问路径,确认同步与别名规则。
  3. 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 编译通过后还可能有哪些并发问题?

一句话结论

编译器只排除数据竞争;死锁、活锁、饥饿、逻辑竞态、顺序依赖错误、线程泄漏仍可能发生,需要通过锁顺序、超时、状态设计与并发测试处理。

概念解释

类型安全 ≠ 业务正确。两个线程按相反顺序加锁会死锁;无界等待会饥饿;共享标志位的读写顺序可能导致业务竞态。这些属于算法与设计层面问题。

原理流程

  1. 数据竞争被编译期排除。
  2. 检查锁获取顺序、超时与释放路径。
  3. 评审共享状态的不变量与唤醒条件。

代码或图示

可能残留:死锁(循环等待)/ 活锁(反复退让)/ 饥饿 / 逻辑竞态 / 线程未退出

常见误区

  • 以为“无畏并发”等于并发代码零风险:它消除数据竞争,不保证业务并发正确。
  • 以为加了锁就没有竞态:锁只保护临界区,跨锁的复合操作仍可能有顺序问题。

追问

  • 如何避免死锁?答:统一全局加锁顺序,缩小临界区,用 try_lock 带超时,避免锁内等待其他锁。
  • 逻辑竞态怎么排查?答:复现并发时序,加日志/追踪检查共享状态变迁,用模型检查工具或压测放大概率。

04.4.2.1-013 消息传递与共享内存两种模型如何取舍?

一句话结论

消息传递通过 channel 转移数据所有权,状态分散、耦合低,适合生产者-消费者与任务编排;共享内存通过锁/原子共享同一状态,适合频繁更新的聚合数据,但要处理互斥与临界区。

概念解释

Go 风格“不要共享内存通信,而要通信共享内存”对应 channel;Rust 两种都支持。消息传递减少共享别名,共享内存减少数据拷贝。实际系统常混合:核心状态加锁,任务间用 channel 传递消息。

原理流程

  1. 判断协作模式:任务解耦/异步流 → channel;集中计数/缓存 → 共享状态。
  2. 消息路径移动所有权,避免共享可变。
  3. 共享路径用 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 闭包访问内部值。注意跨线程传递时不会共享副本,生命周期绑定线程。

原理流程

  1. thread_local! 声明变量,按线程懒初始化。
  2. 在线程内 with(|v| ...) 借用访问。
  3. 线程退出,局部值随线程销毁。

代码或图示

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。

原理流程

  1. spawn/scope 启动线程执行闭包。
  2. 需要等待时 handle.join()。
  3. 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 唤醒。两者都是标准库同步原语。

原理流程

  1. Barrier:每线程 wait(),计数到达阈值后全部放行。
  2. 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 等模型检查库,具体可用性与版本以当前文档为准。

概念解释

竞态问题概率性出现,单次测试难以复现。手段:多线程/多次运行放大概率;在关键点注入等待;用模型检查枚举执行交错;对共享状态写不变量断言。

原理流程

  1. 定义共享状态的不变量。
  2. 并发执行操作序列,反复运行。
  3. 用模型检查或压测工具覆盖更多交错,断言不变量不被破坏。

代码或图示

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 上。

原理流程

  1. 判断数据是否跨线程转移、是否被共享、生命周期多长。
  2. 叠加对应 trait 与生命周期 bound。
  3. 编译器校验实参类型满足全部约束。

代码或图示

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,或把内部状态换成线程安全类型。