Skip to content

任务交给线程后,谁还拥有它?从一个队列看 Rust 所有权 ​

有个很普通的需求:主线程从队列里拿出图片处理任务,交给工作线程执行,同时留下日志。换成不少语言,无非是取出对象、启动线程、再打印一下对象内容。Rust 往往在这一步就给出编译错误。第一次看到错误,容易觉得编译器太较真:任务的字符串明明还在内存里,为什么连读一下都不让?

把错误当成“语法还没记熟”会错过这个例子的重点。队列、主线程和工作线程之间,任务究竟归谁管理?工作线程启动后,主线程还能不能改它?线程异常退出时,任务会不会回到队列?这些是不同的问题。Rust 会在编译时挡住其中一些危险用法,却不会替业务决定失败后的补偿方式。

下面用标准库做一组小实验。编译输出来自本机 rustc 1.67.0,使用 --edition=2021。代码只在内存里模拟任务,没有外部服务;具体错误提示的排版可能随编译器版本变化,关键是错误对应的操作边界。

日志为什么得在启动线程之前打 ​

先不建队列,只把一个字符串交给线程。以下代码保存为 moved_job.rs:

rust
use std::thread;

fn main() {
    let job = String::from("resize:photo-1");
    let worker = thread::spawn(move || job.len());
    println!("queued: {job}");
    println!("bytes: {}", worker.join().unwrap());
}

运行 rustc --edition=2021 moved_job.rs,编译器在 println! 那一行报 E0382:job 已经移动进闭包,不能再借它打印。这里的 move 并非“立即把字符串逐字节复制到另一个地方”。它要求闭包取得所捕获值的所有权。String 自身可以理解为持有堆上字符数据的管理信息;转移所有权后,旧变量不能继续当作这块资源的主人。线程何时真正开始执行,也不改变这个结论。

如果让主线程继续使用旧变量,两个线程就可能同时认为自己能管理同一个值。等函数退出,谁负责释放?若主线程中途改变内容,工作线程看到的又是什么?编译器无需猜线程调度次序,直接规定这次转移之后旧绑定失效。

有三种常见改法,含义却不同。若日志只需记录任务编号,先打印再移动,主线程不必保留任务;若确实需要两份互不影响的数据,可以克隆字符串,但大任务的复制有成本,后续修改也不会同步;若多个线程必须看同一份值,就要设计共享所有权以及可能需要的同步。别为了让报错消失,就机械地在每个变量后面加 clone()。先问:两边究竟需要的是同一任务,还是两份快照?

本例选择第一种。把任务从队列取出后先记日志,再交给线程,编译器就能看出每一步的主人:

rust
use std::collections::VecDeque;
use std::thread;

fn main() {
    let mut jobs = VecDeque::from([String::from("resize:photo-1")]);
    let job = jobs.pop_front().unwrap();
    println!("queued: {job}");
    let worker = thread::spawn(move || job.len());
    println!("bytes: {}", worker.join().unwrap());
    println!("remaining: {}", jobs.len());
}

运行结果依次为 queued: resize:photo-1、bytes: 14、remaining: 0。pop_front() 把 String 从队列交给局部变量 job;打印时只是临时借用它;闭包随后接管它;join() 把工作线程的返回值送回主线程。队列仍由主线程持有,所以最后能查询剩余数量。这段代码的价值不是会打印 14,而是每条所有权边界都能说清楚。

先看队首,再取出,为什么也会报错 ​

我们可能还想先看队首任务,等准备好后再弹出。写成下面这样:

rust
use std::collections::VecDeque;

fn main() {
    let mut jobs = VecDeque::from([String::from("resize:photo-1")]);
    let next = jobs.front().unwrap();
    jobs.pop_front();
    println!("completed: {next}");
}

front() 返回的是指向队列内部元素的引用,不是把任务取了出来。next 仍指着队首字符串;pop_front() 则要从队列移走这个元素。若允许两句同时成立,最后的打印就可能访问已经不在队列里的值。本机编译器给出 E0502:jobs 仍被不可变借用,不能在借用还要被使用时可变借用它。

把 println! 挪到 pop_front() 前面,借用在最后一次使用后就结束了,通常能编译。这不是一条“引用必须活到花括号结尾”的死规则。编译器会按实际使用位置分析借用区间。不过,能提前结束借用不等于可以随意改队列:在还要使用 next 的地方,那个被引用的元素就必须保持有效。

这一点也跑了一遍。在 borrow_ends.rs 里,先打印 next,再取出任务,最后打印已经取得所有权的 owned。本机输出两次相同的任务名,编译通过。它并不是把同一引用延长到了出队之后:第一次打印用的是队列里的借用,第二次打印用的是从队列拿走的 String。如果把第二次打印改回 next,又会回到 E0502。只看运行时两个字符串一样,很容易忽略这两次访问走的是不同的所有权路径。

如果业务动作是“领取任务”,最清楚的写法仍是 pop_front(),让返回的 Option<String> 转移所有权。若只是想查看而不领取,就用 front(),不要在引用还要使用时改变队列。两个 API 看着只差一个词,背后代表的操作却不同。这里也能看出为什么生命周期标注救不了这个错误:标注描述引用之间的关系,不能让已经弹出的元素继续存在。

所有权转了,资源什么时候释放 ​

move 以后,旧变量不能用,但值并没有立刻被销毁。它随新主人继续生活。要看得更直观,可以给任务做一个简单的析构日志:

rust
use std::thread;

struct Job(&'static str);
impl Drop for Job {
    fn drop(&mut self) { println!("drop {}", self.0); }
}
fn main() {
    let first = Job("first");
    {
        let second = Job("second");
        println!("inside block");
        drop(second);
    }
    let worker = thread::spawn(move || {
        let _moved = first;
        println!("worker done");
    });
    worker.join().unwrap();
    println!("main done");
}

本次运行先打印 inside block、drop second,随后是 worker done、drop first,最后才有 main done。second 被显式 drop,因此在内层代码块结束前就释放;first 被移动进线程,由线程闭包持有,工作结束时才析构。join() 让主线程等到工作线程结束,所以本例中 drop first 先于 main done。如果丢掉 JoinHandle,工作线程会脱离等待,主线程将失去从这个 handle 观察完成与否的机会。

要小心,不要从几行日志反推任意线程间的执行顺序。这里能确定的顺序来自 join();没有同步的两个线程,各自的打印先后可能变化。Drop 管理的是进程内资源的收尾,不能把它当成数据库事务提交或远程任务确认。程序被强制终止时,也不能依赖这段析构日志作为业务完成记录。

这里可以再沿着 spawn 的接口想一步。它接收的闭包需要能移动到新线程,闭包的返回值也要能安全地从新线程交回 join() 的调用者。所以约束不只落在 job 上;如果工作线程打算返回一个含有局部借用的结果,返回方向同样会受限制。JoinHandle<T> 像一张取件凭证:它能让调用者等待并取回 T,但它本身不是任务的持久凭证。把 handle 丢掉,线程仍可能继续运行,只是调用者不能再通过这张 handle 等待它或拿到 panic 结果。

对工作池来说,这个区别会影响监督方式。示例始终保留 handle 并调用 join(),才知道 worker 是否 panic。若某个业务入口启动线程后马上丢弃 handle,却把“线程已经启动”当作“任务最终会完成”,那连进程内的失败信号也丢了。Drop 自动释放任务占用的内存,与有人负责观察任务结局,是两件事。内存能正确回收,队列里的业务状态仍可能错误。

借一个值给线程,不一定要把它移走 ​

thread::spawn 可以在调用方返回后继续跑,因此它要求闭包里捕获的引用满足相应的 'static 约束。有人看到这个词就以为“数据必须永远不释放”,其实更准确地说,普通 spawn 不能携带可能先于线程结束而失效的短期借用。把一个局部队列的引用硬塞进去,编译器无法证明线程一定在队列销毁前结束;哪怕代码下一行准备调用 join(),普通 spawn 的类型要求也不会因此改变。

对应的失败实验很短:局部变量 jobs 装着一项任务,thread::spawn(|| println!("{}", jobs[0])) 试图让线程借它读,紧接着主线程调用 join()。编译器仍报 E0373,指出闭包可能比当前函数活得更久。错误提示建议加 move,那会让闭包接管 jobs,而不是实现“借一会儿再还”。如果后面还要用这个队列,直接照提示改就会遇到另一个所有权问题。我们真正需要表达的是“工作线程必定在局部变量还活着的范围内结束”,而不是让它拿走队列。

若任务只是临时读取,而且必须在线程退出后才继续往下走,可以用作用域线程。保存为 scoped_borrow.rs:

rust
use std::thread;
fn main() {
    let jobs = vec![String::from("resize:photo-1")];
    thread::scope(|scope| {
        scope.spawn(|| println!("worker read: {}", jobs[0]));
    });
    println!("main still owns {} jobs", jobs.len());
}

作用域结束前会等待其中的线程,外层 jobs 在此期间仍存在,所以子线程可以借它读。运行结果是工作线程打印任务名,随后主线程打印 main still owns 1 jobs。这个例子没有把任务“交给”工作线程,只有短暂借阅。若工作线程需要把任务带到作用域之外处理,就必须重新设计所有权,不能靠加一个生命周期名字延长队列的生命。

如果工作能提前分成互不重叠的两组,连共享锁也不需要。比如已经有四张图片的处理结果待更新,左边两项交给一个线程,右边两项交给另一个线程:

rust
use std::thread;
fn main() {
    let mut sizes = [1_u32, 2, 3, 4];
    let (left, right) = sizes.split_at_mut(2);
    thread::scope(|scope| {
        scope.spawn(|| {
            for value in left { *value *= 10; }
        });
        scope.spawn(|| {
            for value in right { *value *= 100; }
        });
    });
    println!("{:?}", sizes);
}

本机打印 [10, 20, 300, 400]。这里最有意思的不是乘法,而是 split_at_mut(2):它从一个可变切片中产生两个互不重叠的可变切片。两个线程各管自己那一段;作用域保证它们结束以后主线程才重新读取完整数组。不能把这段代码简单改为“两个线程都拿 &mut sizes,再用下标选不同位置”,因为编译器从两个指向整个数组的可变引用里无法得到不重叠的保证。把数据按所有权边界切开,比先共享整份数据、再用锁争抢,往往更容易推理。

不过,这种办法要求任务在开工前就能划分。如果工作线程必须动态领取下一张图片,事先切片不合适,还是要队列和同步。选用哪种并发方式,先看工作分配能否固定,再看共享状态能否缩小;不必一见多线程就把所有数据塞进同一把锁。

同一份队列给两个线程,Arc 解决了哪一半 ​

前面的工作线程只接收一个已经取出的任务。如果两个线程都要从同一个队列领取任务,单次 move 就不够了:第一个闭包拿走队列后,第二个闭包不能再拿一次。我们需要共享队列,并保证“取队首”在并发下是一个互斥动作。

Rc 提供引用计数,看起来像一种共享方法,但把 Rc<String> 移进 thread::spawn 会得到 E0277:Rc<String> 没有实现 Send。这里不是字符串内容不能跨线程,而是 Rc 的引用计数方式不适合被多个线程同时更新。换成 Arc 可以让引用计数跨线程安全变化;队列本身仍会被多个线程修改,因此还要用 Mutex 包住它。

rust
use std::collections::VecDeque;
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
    let queue = Arc::new(Mutex::new(VecDeque::from([
        String::from("resize:photo-1"), String::from("resize:photo-2")
    ])));
    let workers: Vec<_> = (0..2).map(|_| {
        let queue = Arc::clone(&queue);
        thread::spawn(move || {
            let job = queue.lock().unwrap().pop_front();
            job.map(|s| s.len())
        })
    }).collect();
    let lengths: Vec<_> = workers.into_iter().map(|h| h.join().unwrap()).collect();
    println!("lengths: {:?}", lengths);
    println!("remaining: {}", queue.lock().unwrap().len());
}

在本次运行中,两个线程分别领到一个任务,打印 lengths: [Some(14), Some(14)] 和 remaining: 0。不能从两个相同的长度判断哪个线程领了哪一项;这个例子只证明每次弹出都在锁的保护下进行,并且两个线程都结束了。Arc 负责共享所有权,Mutex 负责互斥访问,JoinHandle 负责观察线程结果。把这些角色分开看,比记住“多线程就套 Arc<Mutex<_>>”更有用。

锁的范围也值得注意:代码先弹出任务,然后锁守卫就结束,实际处理在锁外进行。若把整个图片处理都放在锁内,两个线程虽然能创建,却可能轮流独占队列,失去并行意义。反过来,锁放得太窄也不能让多步业务操作自动成为事务。编译器只保证这里没有违反 Rust 的内存访问规则,队列语义仍由我们决定。

为什么 Arc 外面套 RefCell 也不行 ​

看到 Arc 能跨线程共享,可能会想到把锁换成 RefCell。它也能在运行时检查借用规则,代码写起来还轻一些。试一试:

rust
use std::cell::RefCell;
use std::collections::VecDeque;
use std::sync::Arc;
use std::thread;
fn main() {
    let queue = Arc::new(RefCell::new(VecDeque::from([String::from("job")])));
    let other = Arc::clone(&queue);
    thread::spawn(move || other.borrow_mut().pop_front()).join().unwrap();
}

仍是 E0277,只是这次编译器指出 RefCell<VecDeque<String>> 没有实现 Sync,因此这个组合也不能作为 Send 值传入新线程。这并不矛盾。Arc 使“还有几个主人”这件事的计数更新可以在线程之间安全进行;它没有替内部的 RefCell 提供互斥。多个线程同时调用 borrow_mut(),运行时借用状态本身也需要跨线程保护,所以简单地包一层 Arc 不够。

把 Send 和 Sync 放回这个例子就不那么抽象了:Send 关心一个值能否安全地转移到另一个线程;Sync 关心指向它的共享引用能否安全地给多个线程使用。Rc 不是 Send,RefCell 不是 Sync。Arc<Mutex<VecDeque<String>>> 能用于这里,是这些类型组合之后满足了跨线程移动与共享的要求,外加 Mutex 限定同一时刻谁能改队列。它们没有替我们验证“处理图片”这一步是否正确,也没有判断任务在外部服务上是否执行过。

这里还有一个容易误会的词:Arc::clone(&queue) 只让两个变量共同持有同一队列,不会把整个队列复制一份。它和 String::clone() 的业务意义不同。前者共享状态,需要协调访问;后者得到独立字符串,后续修改不会同步。看代码时仅凭 clone 这个方法名,判断不了数据是不是被复制,应看被克隆的类型。

能安全出队,也可能把任务弄丢 ​

让工作线程刚取出任务就崩溃,看看队列会怎样。panic_after_pop.rs 仍只用内存队列:

rust
use std::collections::VecDeque;
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
    let queue = Arc::new(Mutex::new(VecDeque::from([String::from("resize:photo-1")])));
    let worker_queue = Arc::clone(&queue);
    let handle = thread::spawn(move || {
        let job = worker_queue.lock().unwrap().pop_front().unwrap();
        println!("popped: {job}");
        panic!("simulated processing failure");
    });
    println!("join failed: {}", handle.join().is_err());
    println!("remaining: {}", queue.lock().unwrap().len());
}

运行时线程确实 panic,join() 返回错误,队列剩余数却是 0。任务已经弹出,处理没有完成,也没有自动回队。由于 pop_front() 后锁守卫就释放,这个 panic 不在持锁区间内;Mutex 是否中毒也不是判断业务任务是否完成的办法。就算整个程序从未触发未定义行为,任务仍可能丢失。

这也是本期最重要的边界:所有权系统告诉我们某一刻谁能管理内存里的值,不能替我们保证“任务至少处理一次”或“恰好处理一次”。若任务有价值,领取后应先留可恢复的状态;处理成功后再确认完成;失败或进程退出后要能重新发现未完成任务。换成持久队列时,还要考虑重试导致重复执行,用业务编号和幂等处理约束副作用。这个设计已经超出 Arc 与 Mutex 的职责,不能靠编译通过来证明。

锁中毒能不能替我们报警 ​

前一个崩溃发生在任务出队之后、锁守卫释放之后。有人可能会问:如果让工作线程拿着锁时崩溃,Mutex 会标记中毒,那是否就能据此恢复任务?把 pop_front() 和 panic! 放在同一个持锁区间,就可以直接观察:

rust
use std::collections::VecDeque;
use std::sync::{Arc, Mutex};
use std::thread;
fn main() {
    let queue = Arc::new(Mutex::new(VecDeque::from([String::from("job")])));
    let worker_queue = Arc::clone(&queue);
    let handle = thread::spawn(move || {
        let mut guard = worker_queue.lock().unwrap();
        let job = guard.pop_front().unwrap();
        println!("popped: {job}");
        panic!("simulated failure while holding lock");
    });
    println!("join failed: {}", handle.join().is_err());
    println!("poisoned: {}", queue.is_poisoned());
    let guard = queue.lock().unwrap_or_else(|error| error.into_inner());
    println!("remaining: {}", guard.len());
}

本机输出 join failed: true、poisoned: true、remaining: 0。中毒标记确实出现,任务也确实不在队列了。PoisonError::into_inner() 允许我们拿到守卫检查数据,但这行代码只是为了观察实验结果,不能作为“生产环境遇到中毒就忽略”的通用写法。锁中毒提示的是持锁线程异常结束,受保护数据可能处于某种未完成的状态。究竟能否继续使用,必须根据队列维护的不变量检查;它不会记住被弹出的 job,更不能把已经执行到一半的外部副作用撤销。

把两个崩溃例子并排看,界限更清楚:锁外 panic,队列空,锁不因这次 panic 中毒;锁内 panic,队列仍空,同时出现中毒。中毒与否都不能充当任务确认记录。 Mutex 保证的是同一时刻的内存访问边界,不是任务处理的持久状态。甚至“线程正常结束,队列剩余 0”也只说明内存队列空了;若图片处理结果还没写入持久存储,业务仍可能没有完成。

把“取走”拆成领取和确认 ​

前面的 pop_front() 一步就把任务从队列里拿没了。要让线程 panic 后还能重领,可以先在进程内把任务分成 pending 和 in_flight 两处。claim() 从待处理队列弹出,并在进行中表里留下同一任务编号;工作完成后 ack(id) 删除进行中记录;监督线程发现 worker 的 join() 返回错误,就用 requeue(id) 把任务放回待处理队列。完整可运行代码放在同目录的 recoverable_in_memory.rs。其中关键状态转移是:

rust
fn claim(&mut self) -> Option<Job> {
    let job = self.pending.pop_front()?;
    self.in_flight.insert(job.id, job.clone());
    Some(job)
}
fn ack(&mut self, id: u64) { self.in_flight.remove(&id); }
fn requeue(&mut self, id: u64) {
    if let Some(job) = self.in_flight.remove(&id) {
        self.pending.push_front(job);
    }
}

测试里任务编号为 7。监督线程先领取并记下任务编号,再启动第一个 worker;worker 故意 panic,join() 返回错误,监督线程据编号重排队;第二个 worker 又拿到编号 7,完成后确认。原始输出中依次能看到 first claimed 7、second claimed 7: resize:photo-1,最后是 pending=0 in_flight=0。这至少证明了同一个进程还活着、监督线程还在、panic 能被 join() 观察到的情况下,任务有一次重领路径。它也让任务编号不再只是日志装饰:没有编号,监督线程就难以准确指出哪项任务需要重试。

注意 claim() 为了把一份任务交给 worker,同时在 in_flight 保留了一份,示例直接克隆了 Job,包括字符串载荷。实际任务若含大文件内容,不该照搬这种复制方式;通常只在队列里存任务编号和可查的载荷位置。Mutex 把内存里的领取状态转移保护起来,但进程一死,两处内存都会消失。而且监督线程如果自己也消失,或者 worker 在外部副作用完成后、ack 之前失败,重领会带来重复处理。因此这段代码演示的是所有权边界和失败时序,并没有实现可持久恢复的任务系统。

任务做完了,确认却没写下 ​

刚才的失败发生在真正处理之前,重领看起来很顺利。把崩溃位置往后挪一步:工作线程已经把图片写入目标目录,正要调用 ack(7),此时 panic。监督线程只能看到任务 7 仍在 in_flight,无法从这张内存表判断图片是否已经写好。把任务重新放回队列,会让下一位工作线程再做一次。

这个时间差可以用一个小实验固定下来。duplicate_after_effect.rs 把“写出结果”简化为向 completed_effects 里追加任务编号;第一次追加后故意 panic,不确认;监督线程重排队,第二次处理再次追加。两次处理结束,程序打印:

text
effect IDs: [7, 7]
pending=0 in_flight=0

队列已经空了,进行中表也已经空了,但同一编号的效果发生了两次。这个实验没有真的调用图片服务,也不证明某种外部存储一定会重复写入;它只是把“效果完成”和“队列确认”分成两个独立动作,展示它们之间存在的失败窗口。把 Vec<u64> 换成文件、数据库或支付接口,问题会更难,因为第二次操作可能不能简单撤销。

有人会想把 ack() 放到处理之前,保证不会重复。那只是把失败窗口搬到了另一侧:先确认、再处理,线程在两步之间死掉,队列认为任务完成,图片却没生成。若把处理和确认都放在一个 Mutex 守卫内,其他线程只能等待,并且外部服务不会因为本进程的锁自动加入同一笔事务。锁只能约束这块内存,不能把跨进程的两个动作变成原子操作。

所以要先决定允许哪种失败语义。允许重试时,结果写入处最好按稳定的任务编号去重:例如目标路径由编号确定,写入前后能核对内容;或者数据库把编号作为唯一键,重复请求返回已有结果。若副作用无法做幂等处理,就必须接受不确定状态并建立对账流程。所谓“恰好一次”通常不是队列本身能独立承诺的;要把任务状态和实际副作用放进同一个可核对的协议里。

这也反过来解释 Job 的所有权为什么不是整个故事。Rust 能保证某一时刻只有合法的引用或拥有者操作这个值,却无法根据类型系统判断远端是否已经接收一张图片。我们甚至可以让任务在内存里只存在一份、没有任何数据竞争,仍然在网络超时后不知道远端是否处理完成。编译时的安全和业务上的完成,是两套需要分别验证的事实。

两个 worker 同时领任务,还要守住哪些不变量 ​

示例中 claim() 和 requeue() 都在同一把锁下修改 pending 与 in_flight。这里真正需要保护的不是某个 VecDeque 方法,而是状态转移:一个任务编号不能同时留在待处理队列和进行中表;确认过的编号不应又被重排队;同一编号也不应同时交给两个 worker。若把 pop_front() 和 in_flight.insert() 分别放进两段加锁代码,其他线程会看见“任务已从待处理队列消失、进行中表却没有记录”的中间状态。同一把锁可以挡住其他线程在两步之间观察或修改队列,但它不是事务回滚机制;若持锁代码本身 panic,仍要检查数据不变量,而不能认为两处变化自动撤销。

但锁的持有范围不应覆盖图片处理。假设处理一张图片需要几秒,两个 worker 若都必须持锁完成整个处理,第二个 worker 在这几秒里无法领取另一张。示例只在领取、确认和重排队时持锁,处理在锁外进行。这样可以并行处理,代价是我们必须明确处理中任务的归属和失败后的恢复路径。锁范围不是越大越安全,也不是越小越快;要用状态不变量决定哪些操作必须一起做,再把耗时的外部工作留在临界区之外。

当前实验还有一个刻意简化的地方:监督线程先领取,再把任务交给工作线程,而且始终记得领取的编号。真实工作池里多个 worker 可能自己领取任务,监督者需要知道每个 worker 持有哪些编号,否则 join() 报错后不知道重排哪一项。更复杂时,worker 可能没有 panic,只是卡住;监督者还需要超时或租约,才能重新发放任务。租约到期与原 worker 继续运行可能重叠,便会出现两个 worker 同时尝试完成编号 7。此时仅有 Arc<Mutex<_>> 仍不能阻止外部效果重复,领取还需要代次、版本或其他可检查的约束。本文的小程序没有实现租约,因此不能拿它冒充可靠队列。

可以把“处理很慢”和“线程已经死了”分开想。假设任务 7 的第一次处理实际用了 12 秒,监督者在第 10 秒认定它超时,交给第二个 worker。第 12 秒第一个 worker 终于返回;第 13 秒第二个 worker 也返回。两人都没有触犯 Rust 的借用规则,因为他们持有的是两个合法的任务值;若两人写向同一个外部目标,数据竞争保护也未必能约束那边的业务操作。仅凭一个过期的任务编号,无法知道哪次结果应该被接受。

一种常见的做法是领取时给任务增加单调递增的代次:第一次拿到 (7, 1),超时重领后拿到 (7, 2)。确认时不仅比对任务编号,还要检查代次仍是当前值。这样旧 worker 的确认可以被拒绝,队列状态不会被过期的线程写回。但如果旧 worker 在被拒绝之前已经调用了外部系统,代次检查仍不能撤销那个效果。目标系统也必须参与检查,或者按任务编号做到幂等。把代次只放在内存 HashMap 里,进程重启后又会丢失。这个边界说明,队列里的互斥、领取资格和外部副作用,是三层不同的保护。

真正的任务确认该放在哪里 ​

给这个小程序加“可靠”两个字,设计就不再是换一个智能指针那么简单。至少得回答三件事:任务领取后放哪儿,处理结果写到哪儿,什么时刻算完成。一个可推敲的状态机是 待处理 -> 处理中 -> 已完成。领取时记录任务和领取者,处理成功并确认结果后转为已完成;处理超时或工作线程消失后,重新暴露未完成任务。状态需要落在进程重启后仍可查询的存储中,内存 VecDeque 做不到。具体用数据库、消息队列还是外部任务系统,取决于已有架构和吞吐要求;本文的实验没有对它们做性能比较。

即使有了持久状态,工作线程可能在外部服务已经完成操作、但“已完成”记录尚未写入时崩溃。下一次领取会再次执行。同一任务的编号必须在业务侧保持稳定,让写入目标能识别重复;或者先查询可复核的处理结果。若目标系统不支持幂等,通常只能把不确定结果交给对账或人工处理,不能宣称靠 Rust 所有权或一次数据库事务就做到了跨系统恰好一次。

这也解释了为什么不能把 Arc<Mutex<VecDeque<_>>> 当成这个问题的最终答案。它可以构成一个安全的进程内工作池原型;进程异常退出、线程 panic、外部调用超时、结果已写入但回执丢失,都要另行设计。编译通过,只证明 Rust 的类型与借用规则在这段代码里得到满足。把任务可靠性写成可检查的状态和恢复流程,才是下一层工程工作。

从最初那个 E0382 回头看,编译器并没有故意阻止打印日志。它迫使我们决定任务交接的顺序:在移交之前记录,还是为两个地方准备独立副本,或者明确共享同一对象。这个决定会一路影响队列 API、线程边界和失败恢复。所有权值得学的地方,也正在这里。

自己跑一遍 ​

文中的成功与失败示例、编译器输出都已保存。先下载领取、失败、重领程序和效果完成后确认丢失程序,在本地依次运行:

sh
rustc --edition=2021 recoverable_in_memory.rs -o recoverable_in_memory
./recoverable_in_memory
rustc --edition=2021 duplicate_after_effect.rs -o duplicate_after_effect
./duplicate_after_effect

两个程序的第一次 worker 都会故意 panic,终端出现 panic 信息是实验的一部分,不代表主线程运行失败。本文使用 rustc 1.67.0 得到的原始输出可供对照;其余借用、析构、作用域线程和锁中毒示例也放在同一实验目录,并在11 月 9 日、11 月 13 日、11 月 14 日的输出中记录了结果。不同版本的报错字句与行号可能变化,关键要核对的是任务从哪一步转移、哪一步失去确认。

参考资料 ​

梧桐和风 · 让复杂的技术讲得更清楚