如何在Rust中从外部终止线程？

你这个思路其实方向是对的，但确实存在你担心的内存顺序问题，咱们一步步拆解来看，再聊聊更稳妥的方案。

首先说你当前实现里的疑问：Ordering::Relaxed是最宽松的内存顺序，它不保证操作的可见性顺序——也就是说，线程里可能先收到None消息，才看到cancel_token被设为true。不过其实你这里完全可以不用依赖AtomicBool，直接用None作为终止信号就行啊？

比如修改handle_messages函数，只要收到None就直接退出，这样就不用纠结原子变量的顺序问题了：

fn handle_messages(receiver: Receiver<Message>) {
    while let Some(message) = receiver.recv().unwrap() {
        // 处理消息
    }
}

然后stop方法里只需要发送None，之后等待线程结束：

pub fn stop(&mut self) {
    self.sender.send(None).unwrap();
    self.join_handle.take().unwrap().join();
}

不过这里要注意，如果线程正阻塞在recv()上，发送None会立刻唤醒它，线程就能快速退出，完全不需要原子变量。那如果你的需求是“尽快停止并丢弃剩余消息”，收到终止信号后直接退出就好，剩下的消息会随着后续逻辑自动丢弃。

如果确实需要保留原子变量的场景（比如线程还有其他阻塞操作），那你需要调整内存顺序：把cancel_token.store(true, Ordering::Release)和cancel_token.load(Ordering::Acquire)搭配使用。Release保证store的修改对后续的Acquire可见，这样线程里load到true的时候，肯定是在stop方法的store操作之后，能确保不会继续处理消息：

pub fn stop(&mut self) {
    self.cancel_token.store(true, Ordering::Release);
    self.sender.send(None).unwrap();
    self.join_handle.take().unwrap().join();
}

fn handle_messages(receiver: Receiver<Message>, cancel_token: Arc<AtomicBool>) {
    for message in receiver {
        if cancel_token.load(Ordering::Acquire) {
            return;
        }

        if let Some(_) = message {
            // do something
        }
    }
}

而针对你的需求，最简洁可靠的方案其实是利用Rust mpsc通道的特性：当所有sender被丢弃时，receiver的recv()会返回Err，循环自动终止。你可以这么修改代码：

use std::{
    sync::mpsc::{Receiver, Sender},
    thread::{self, JoinHandle},
};

type Message = u32;

pub struct MessageHandler {
    sender: Option<Sender<Message>>,
    join_handle: Option<JoinHandle<()>>,
}

impl MessageHandler {
    pub fn new() -> MessageHandler {
        let (sender, receiver) = std::sync::mpsc::channel();

        let join_handle = thread::spawn(move || {
            MessageHandler::handle_messages(receiver);
        });

        MessageHandler {
            sender: Some(sender),
            join_handle: Some(join_handle),
        }
    }

    pub fn send_message(&self, number: u32) {
        if let Some(sender) = &self.sender {
            sender.send(number).unwrap();
        }
    }

    pub fn stop(&mut self) {
        // 丢弃sender，触发通道关闭
        self.sender.take();
        // 等待线程结束
        if let Some(handle) = self.join_handle.take() {
            handle.join().unwrap();
        }
    }

    fn handle_messages(receiver: Receiver<Message>) {
        // 当所有sender被丢弃，recv会返回Err，循环自动终止
        for message in receiver {
            // 处理消息
        }
    }
}

这个方案的好处是：完全不需要额外的终止信号或原子变量，只要丢弃sender，线程就会在当前的recv()完成后（或者立刻，如果它正阻塞在recv()上）退出，剩余未接收的消息会被自动丢弃，完美匹配你“尽快停止并丢弃剩余消息”的需求。

备注：内容来源于stack exchange，提问作者Hirnlos