Rust线程是否具备类似POSIX线程的取消点机制？

Rust标准库没有提供类似POSIX线程中pthread_cancel、pthread_setcancelstate这类强制终止线程的特性。这并非功能缺失，而是Rust内存安全设计的必然选择——强制取消线程可能导致线程在持有锁、分配内存或操作共享资源的中途被终止，进而引发资源泄漏、数据损坏、死锁等问题，完全违背Rust的安全承诺。

下面是几种Rust中优雅的线程终止方式：

1. 共享原子布尔标志 #

通过Arc<AtomicBool>创建线程间共享的取消标志，工作线程定期检查该标志，一旦标志置为true就主动退出。这种方式简单直接，适用于大多数同步场景。

use std::sync::{Arc, AtomicBool};
use std::thread;
use std::time::Duration;

fn main() {
    let cancel_flag = Arc::new(AtomicBool::new(false));
    let flag_clone = Arc::clone(&cancel_flag);

    let worker = thread::spawn(move || {
        while !flag_clone.load(std::sync::atomic::Ordering::Relaxed) {
            // 执行核心业务逻辑
            println!("Worker thread running...");
            thread::sleep(Duration::from_secs(1));
        }
        println!("Worker thread received cancel signal, exiting gracefully");
    });

    // 主线程模拟业务流程，3秒后触发取消
    thread::sleep(Duration::from_secs(3));
    cancel_flag.store(true, std::sync::atomic::Ordering::Relaxed);

    worker.join().unwrap();
}

2. 消息通道发送终止信号 #

利用std::sync::mpsc通道，主线程向工作线程发送终止消息，工作线程监听通道，收到消息后主动退出。这种方式适合需要传递额外终止信息的场景。

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    let worker = thread::spawn(move || {
        loop {
            match rx.try_recv() {
                Ok(_) => {
                    println!("Worker thread got terminate command, exiting");
                    break;
                }
                Err(mpsc::TryRecvError::Empty) => {
                    // 正常执行任务
                    println!("Worker thread processing task...");
                    thread::sleep(Duration::from_secs(1));
                }
                Err(mpsc::TryRecvError::Disconnected) => {
                    println!("Main thread disconnected, worker exiting");
                    break;
                }
            }
        }
    });

    thread::sleep(Duration::from_secs(3));
    tx.send(()).unwrap();

    worker.join().unwrap();
}

3. 异步场景下的取消令牌 #

如果使用Tokio等异步运行时，可以利用CancellationToken实现更灵活的异步任务/线程取消，支持链式取消、超时取消等高级特性。

use tokio::time::{sleep, Duration};
use tokio::sync::CancellationToken;

#[tokio::main]
async fn main() {
    let cancel_token = CancellationToken::new();
    let token_clone = cancel_token.clone();

    tokio::spawn(async move {
        loop {
            tokio::select! {
                _ = sleep(Duration::from_secs(1)) => {
                    println!("Async worker running...");
                }
                _ = token_clone.cancelled() => {
                    println!("Async worker cancelled, exiting");
                    break;
                }
            }
        }
    });

    sleep(Duration::from_secs(3)).await;
    cancel_token.cancel();
}

4. RAII模式保证资源清理 #

无论采用哪种终止方式，都应结合Rust的RAII特性（通过Drop trait）确保线程持有的资源（如锁、文件句柄、网络连接）在退出时自动清理，避免资源泄漏。例如MutexGuard会在作用域结束时自动释放锁，无需手动调用解锁操作。

内容的提问来源于stack exchange，提问作者Harry