在 Rust 中，并发执行异步操作可以显著提升程序性能。本文将深入探讨两种常见的并发策略：多线程和 Futures 联合。

多线程概述

线程本质上是 CPU 执行的一段软件代码序列。我们可以将其理解为一个运行进程的容器。多线程允许我们同时运行多个任务，从而提高程序性能，但同时也引入了复杂性。

创建和管理线程

使用 std::thread::spawn 函数可以创建新的线程：

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 1..100 {
            println!("{} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
}

这段代码创建了一个新的线程，并在其中执行一个循环，打印数字并休眠。主线程也执行一个类似的循环。thread::sleep 函数用于模拟线程的执行延迟，以便观察线程切换的效果。

Join 线程

主线程结束时，所有子线程都会被强制关闭，无论它们是否已完成任务。为了确保子线程完成，我们可以使用 JoinHandle 将子线程的返回值绑定到一个变量，并使用 join 方法等待子线程完成。

fn main(){
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("{} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("{} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().expect("error joining");
}

这段代码中，我们使用 join 方法等待子线程完成，确保主线程不会在子线程执行完毕前退出。

Join 线程的位置

join 方法的位置至关重要。如果将 join 方法放在主线程循环之前，主线程将等待子线程完成才能执行。

fn main(){
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("{} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });
    handle.join().expect("error joining");

    for i in 1..5 {
        println!("{} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
}

从 JoinHandle 获取返回值

我们可以通过 JoinHandle 获取子线程的返回值。例如，以下代码创建了两个子线程，并获取它们的返回值进行计算。

fn main(){
    let handle_1 = thread::spawn(|| {
        for i in 1..10 {
            println!("{} from the spawned thread 1!", i);
            thread::sleep(Duration::from_millis(1));
        }
        return 100
    });

    let handle_2 = thread::spawn(|| {
        for i in 1..10 {
            println!("{} from the spawned thread 2!", i);
            thread::sleep(Duration::from_millis(1));
        }
        return 200
    });
    let result_1 = handle_1.join().expect("error joining");
    let result_2 = handle_2.join().expect("error joining");

    println!("final result: {} from the main thread!", result_1 + result_2);

}

使用 move 关键字

如果闭包需要获取外部变量的所有权，可以使用 move 关键字。

fn main(){
    let v = vec![1, 2, 3];

    let handle = thread::spawn(move || {
        println!("vector: {:?}", v);
    });

    handle.join().expect("error joining");
}

异步操作与多线程

使用 tokio::spawn 创建异步线程

tokio::spawn 函数可以用来创建异步线程。

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

use tokio;

#[tokio::main]
async fn main() {
    let spawn_1 = tokio::spawn(async {
        for i in 1..5 {
            println!("{} from the thread 1!", i);
            thread::sleep(Duration::from_millis(1));
        }  
    });

    let spawn_2 = tokio::spawn(async {
        for i in 1..5 {
            println!("{} from the thread 2!", i);
            thread::sleep(Duration::from_millis(1));
        }  
    });

  spawn_1.await.expect("error awaiting");
  spawn_2.await.expect("error awaiting");
}

这段代码创建了两个异步线程，每个线程都执行一个循环，打印数字并休眠。

异步线程执行位置

tokio::spawn 创建的异步任务可能在当前线程或其他线程上执行，具体取决于运行时的配置。默认情况下，tokio 会使用 rt-multi-thread 特性，这意味着会自动启用多线程。

Futures 联合

顺序执行 Futures

异步函数返回 Future 类型，可以使用 await 获取结果。以下代码演示了顺序执行两个异步函数。

#[tokio::main]
async fn main() {
    let start = Instant::now();

    let future_1 = async_operation(1);
    let future_2 = async_operation(2);
    future_1.await;
    future_2.await;

    println!("{}: {:?}", "futures: ", start.elapsed());

}


async fn async_operation(thread: i8) {
    for i in 1..5 {
        println!("{} from the operation {}!", i, thread);
        // 模拟 IO 等待
        tokio::time::sleep(Duration::from_millis(400)).await;
        // 模拟 CPU 工作负载
        thread::sleep(Duration::from_millis(100));
    }
}

这段代码中，async_operation 函数模拟了异步操作，包括 IO 等待和 CPU 工作负载。主线程依次执行两个异步函数。

并发执行 Futures

为了并发执行异步操作，可以使用 futures::future::join_all 将多个 Future 联合起来，并使用 await 等待它们全部完成。

#[tokio::main]
async fn main() {
    let start = Instant::now();

    let future_1 = async_operation(1);
    let future_2 = async_operation(2);
    join_all([future_1, future_2]).await;

    println!("{}: {:?}", "futures: ", start.elapsed());

}

这段代码中，我们使用 join_all 将两个异步函数联合起来，并使用 await 等待它们全部完成。

总结

多线程 vs Futures 联合

多线程和 Futures 联合都是并发执行异步操作的有效方法，但它们之间存在一些关键区别：

• 多线程通常会使用多个物理线程，而 Futures 联合通常会在单个线程上执行。
• 多线程更适合执行长时间运行、独立、内存密集型或 CPU 密集型任务。
• Futures 联合更适合执行短时间运行、依赖于 IO 操作或无需返回值的任务。

选择合适的并发策略

在选择并发策略时，需要考虑以下因素：

• 任务的类型和复杂度
• 任务之间的依赖关系
• 资源的可用性和限制

希望本文能够帮助您更好地理解 Rust 中的并发编程，并选择合适的策略来提高您的程序性能。