Rust：关于Future和JoinHanlder的思考

Future和JoinHandler是不同的，但这两个都与异步（多线程）相关。

概念不同

• JoinHandler：是指一个异步方法的句柄，用来监控或控制这个异步方法，以及接收异步方法的执行结果。
• Future：表示的是在未来某个时刻执行的代码片段

执行的时机不同

• JoinHandler：在有该对象的时候，该对象对应的异步任务已经开始执行，或已经进入执行队列了。
• Future：Future只是代表未来某个时刻执行的代码片段，只有在开始调用时才开始执行。

相关联的点

JoinHanlder.join()方法和Future.await都是在当前线程下同步等待异步方法结束。
tokio::spawn()方法接收Future参数，并返回一个JoinHanlder对象。

写了一个小例子

use std::{sync::mpsc, thread, time::Duration};

use tokio::runtime::Runtime;

fn main() {
    let p = Person {
        name: "张三".into(),
        age: 19,
    };
    let (tx, rx) = mpsc::channel();

    let handler1 = std::thread::spawn(move || {
        println!("hanlder1 start run, and sleep 3s");
        thread::sleep(Duration::from_secs(3));
        println!("handler1 sleep completed!");
        match tx.send(p) {
            Ok(_) => println!("hanlder1 send success"),
            Err(err) => eprintln!("{err}"),
        }
    });
    let handler2 = std::thread::spawn(move || {
        println!("handler2 had run");
        match rx.recv() {
            Ok(_p) => println!("recv success"),
            Err(err) => eprintln!("{err}"),
        }
    });
    let f = async {
        println!("我是Future，需要等待调用才会执行");
        thread::sleep(Duration::from_secs(10));
        println!("Future执行结果");
    };
    println!("main thread will sleep 10s");
    thread::sleep(Duration::from_secs(10));
    let hander2_res = handler2.join();
    let hander1_res = handler1.join();
    if let Err(err) = hander2_res {
        eprintln!("hander2 run failed! {:?}", err);
        return;
    }
    if let Err(err) = hander1_res {
        eprintln!("handler1 run failed,{:?}", err);
        return;
    }
    println!("start run tokio thread");
    let rt = Runtime::new().expect("create tokio runtime failed!");
    rt.block_on(f);
    println!("completed!");
}

//send:在线程间移动所有权

//sync：在线程间可以共享只读的借用

struct Person {
    name: String,
    age: u8,
}