Rust暴力破解脚本：如何设置线程数并利用多核心实现最优性能？

一、确保线程运行在不同核心上 #

Rust标准库没有直接提供核心亲和性控制的API，你可以通过第三方库手动绑定线程，或者用自动调度的并行库简化操作：

1. 手动绑定线程到指定核心（使用core_affinity）

这个库允许你直接将线程绑定到特定核心，避免操作系统跨核心调度线程。

先在Cargo.toml添加依赖：

[dependencies]
core_affinity = "0.8"

示例代码：

use core_affinity::CoreId;
use std::thread;

fn main() {
    // 获取系统所有可用逻辑核心列表
    let core_ids = core_affinity::get_core_ids().unwrap();
    let total_cores = core_ids.len();

    // 为每个核心创建线程并绑定
    for core_id in core_ids {
        thread::spawn(move || {
            // 将当前线程绑定到指定核心
            if core_affinity::set_for_current(core_id) {
                println!("线程已绑定到核心 {}", core_id.id);
            }
            // 执行当前核心负责的子任务
            run_brute_force(core_id.id, total_cores);
        });
    }

    // 等待所有线程完成（实际场景可使用JoinHandle管理）
    loop {
        thread::sleep(std::time::Duration::from_secs(1));
    }
}

fn run_brute_force(core_num: usize, total_cores: usize) {
    // 拆分2^80的任务区间，每个核心处理一部分
    let total_tasks = 1u128 << 80;
    let chunk_size = total_tasks / total_cores as u128;
    let start = core_num as u128 * chunk_size;
    let end = if core_num == total_cores - 1 { total_tasks } else { (core_num + 1) as u128 * chunk_size };

    // 替换为你的暴力破解核心逻辑
    for i in start..end {
        if check_candidate(i) {
            println!("找到匹配项: {}", i);
            std::process::exit(0);
        }
    }
}

fn check_candidate(_value: u128) -> bool {
    // 替换为实际校验逻辑
    false
}

2. 使用自动并行库（推荐用rayon）

rayon会自动根据系统核心数创建线程池，将任务调度到不同核心，无需手动绑定，代码更简洁，适合CPU密集型任务。

添加依赖：

[dependencies]
rayon = "1.7"
num_cpus = "1.16"

示例代码：

use rayon::prelude::*;

fn main() {
    let total_tasks = 1u128 << 80;
    let total_cores = num_cpus::get();
    let chunk_size = total_tasks / total_cores as u128;

    // 生成任务区间并并行处理
    (0..total_cores).into_par_iter().for_each(|core_num| {
        let start = core_num as u128 * chunk_size;
        let end = if core_num == total_cores - 1 { total_tasks } else { (core_num + 1) as u128 * chunk_size };
        run_brute_force_range(start, end);
    });
}

fn run_brute_force_range(start: u128, end: u128) {
    for i in start..end {
        if check_candidate(i) {
            println!("找到匹配项: {}", i);
            std::process::exit(0);
        }
    }
}

fn check_candidate(_value: u128) -> bool {
    // 替换为实际校验逻辑
    false
}

二、判断是否已无可用核心 #

1. 代码层面直接获取核心数
   使用num_cpus::get()或core_affinity::get_core_ids().unwrap().len()，可以得到系统的逻辑核心总数（包含超线程核心）。当你创建的线程数等于这个数值时，就已经用尽了所有可并行的核心资源，再增加线程只会带来上下文切换开销，无法提升计算速度。

2. 运行时辅助判断
   对于CPU密集型任务，当所有核心满载时，系统CPU使用率会维持在100%，此时再添加线程不会加快整体计算速度，反而可能因为调度损耗变慢。你可以通过系统监控工具辅助判断，但代码层面以核心数作为线程数上限是最可靠的方式。

注意事项 #

• 超线程核心：逻辑核心数是物理核心两倍时，超线程对CPU密集型任务的加速效果有限（通常10%-30%），可根据实际测试结果选择是否使用全部逻辑核心。
• 任务均衡：确保每个线程的任务量尽量平均，避免出现部分线程提前完成、其余线程仍在运行的情况，影响整体效率。

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