Multithreading 从阻塞操作中获得生锈螺纹的标准方法是什么？

我来自Java，习惯于使用类似于

while（true）{
试一试{
someBlockingOperation（）；
}捕捉（中断异常e）{
Thread.currentThread.interrupt（）；//重新设置中断标志
cleanup（）；//任何必要的
打破
}
}

据我所知，这在整个JDK中适用于任何可能阻塞的内容，比如从文件、套接字、队列中读取，甚至

Thread.sleep（）

在阅读Rust中如何实现这一点时，我发现了许多看似特殊的解决方案，如

mio

，

tokio

。我还发现

ErrorKind:：Interrupted

，并尝试通过向线程发送

SIGINT

来获取此

ErrorKind

，但线程似乎立即死亡，没有留下任何（返回）痕迹

以下是我使用的代码（注意：还不是很精通生锈，所以它看起来可能有点奇怪，但它可以运行）：

所谓“阻塞操作”，我的意思是：

• 睡眠
• 套接字IO
• 文件IO
• 队列IO（尚不确定队列的位置）

---

向线程发出信号（如Java中的

thread.interrupt（）

）是时候收拾行李回家了）的相应方式是什么？

没有这样的事情。阻塞意味着阻塞

相反，您故意使用非阻塞的工具。这就是像mio、Tokio或futures这样的库的用武之地——它们处理将所有这些非阻塞、异步片段粘在一起的架构

catch（中断异常e）

Rust没有例外。如果您希望处理故障案例，最好用

结果来表示

Thread.interrupt（）

除了在线程中设置一个标志，一些代码可能会检查该标志，然后抛出一个异常之外，这实际上没有做任何事情。你可以自己建造同样的结构。一个简单的实现：

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

fn main() {
    let please_stop = Arc::new(AtomicBool::new(false));

    let t = thread::spawn({
        let should_i_stop = please_stop.clone();
        move || {
            while !should_i_stop.load(Ordering::SeqCst) {
                thread::sleep(Duration::from_millis(100));
                println!("Sleeping");
            }
        }
    });

    thread::sleep(Duration::from_secs(1));
    please_stop.store(true, Ordering::SeqCst);
    t.join().unwrap();
}

睡觉
据我所知，没有办法打扰你。文件甚至说：

在Unix平台上，由于出现信号，此函数不会提前返回

套接字IO
您可以使用如下方法将套接字置于非阻塞模式：然后使用handle

另见：





文件IO
没有一种跨平台的方式来执行异步文件IO。大多数实现都会启动线程池并在那里执行阻塞操作，通过不阻塞的方式发送数据

另见：





队列IO
也许你指的是类似于a的东西，在这种情况下，你会使用类似的工具

另见：






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

fn main() {
    let please_stop = Arc::new(AtomicBool::new(false));

    let t = thread::spawn({
        let should_i_stop = please_stop.clone();
        move || {
            while !should_i_stop.load(Ordering::SeqCst) {
                thread::sleep(Duration::from_millis(100));
                println!("Sleeping");
            }
        }
    });

    thread::sleep(Duration::from_secs(1));
    please_stop.store(true, Ordering::SeqCst);
    t.join().unwrap();
}