Rayon是Rust的数据并行库。它非常轻量级，可以很容易地将顺序计算转换为并行计算。它还可以避免数据竞争。

Rayon使将顺序迭代器转换为并行迭代器变得非常简单：通常，你只需将 foo.iter() 调用更改为 foo.par_iter()，Rayon就会完成其余的工作：

use rayon::prelude::*;
fn sum_of_squares(input: &[i32]) -> i32 {
    input.par_iter() // <-- just change that!
         .map(|&i| i * i)
         .sum()
}

并行迭代器负责决定如何将数据划分为任务；它将动态适应以获得最大性能。

Rayon 是一个 Rust 的数据并行库，让你可以非常方便地将代码“并行化”，充分利用多核 CPU。

它的核心目标是：

“使数据并行像普通迭代一样易用。”

Rayon 是 Rust 中最流行、最安全的并行库之一。

Rayon 的核心能力

Rayon 主要提供两个核心功能：

1.并行迭代器（Parallel Iterators）

代替 .iter() 或 .into_iter()，你可以用 .par_iter()，并行执行：

use rayon::prelude::*;

let nums = vec![1, 2, 3, 4, 5];

let sum: i32 = nums.par_iter().map(|x| x * 2).sum();  // 并行 map + sum

和 .iter() 一样的 API，但自动分布任务给多个线程。

2.任务并行（spawn / join）

Rayon 也允许你写任务并行逻辑：

use rayon::join;

let (a, b) = join(
    || expensive_computation_1(),
    || expensive_computation_2(),
);

等价于在两个线程中并行运行两个任务，并等两者都完成。

常用 API 示例

并行 map：

let squares: Vec<i32> = (1..1000).into_par_iter()
    .map(|x| x * x)
    .collect();

并行 filter：

let even: Vec<i32> = vec![1, 2, 3, 4, 5, 6].par_iter()
    .filter(|x| *x % 2 == 0)
    .cloned()
    .collect();

并行 reduce（自定义归约）：

let result = vec![1, 2, 3, 4, 5].par_iter()
    .cloned()
    .reduce(|| 0, |a, b| a + b);

.par_chunks(n)：并行切片

let data = vec![1u8; 1024 * 1024];

data.par_chunks(4096).for_each(|chunk| {
    // 每个线程处理一个 chunk
});

Rayon 的线程池

• Rayon 内部会自动使用一个 线程池（默认线程数 = CPU 核心数）。
• 你也可以用 ThreadPoolBuilder 来自定义线程池大小、名字、行为等。

示例：

use rayon::ThreadPoolBuilder;

let pool = ThreadPoolBuilder::new()
    .num_threads(4)
    .build()
    .unwrap();

pool.install(|| {
    // 在这个线程池里运行任务
});

Rayon 的安全性

Rayon 是 数据并行（data parallelism），不是任务并行库如 tokio。
但它的最大特点是：

所有并行代码 在编译时保证线程安全，不会发生数据竞争！

这归功于 Rust 本身的 Send + Sync + Borrow Checker。

什么时候用 Rayon？

适合场景包括：

Rayon vs tokio

最小示例：并行求平方和

use rayon::prelude::*;

fn main() {
    let sum: i32 = (1..1_000_000)
        .into_par_iter()
        .map(|x| x * x)
        .sum();

    println!("平方和: {}", sum);
}