jxl-threadpool：高性能、轻量级的Rust线程池库

介绍

jxl-threadpool是一个Rust实现的轻量级线程池库，专注于高性能任务调度与管理。它提供了简单易用的API来执行并行任务，适合需要高效利用多核CPU的场景。

主要特性

• 轻量级实现，低开销
• 高性能任务调度
• 支持任务返回值获取
• 可配置的线程数量
• 线程安全的任务队列

完整示例代码

下面是一个综合使用jxl-threadpool各种功能的完整示例：

use jxl_threadpool::ThreadPool;
use jxl_threadpool::ThreadPoolBuilder;
use std::time::Duration;

fn main() {
    // 1. 基本线程池使用
    basic_threadpool_usage();
    
    // 2. 获取任务返回值
    future_result_example();
    
    // 3. 并行数据处理
    parallel_data_processing();
    
    // 4. 高级配置示例
    advanced_configuration();
}

// 基本线程池使用示例
fn basic_threadpool_usage() {
    println!("=== 基本线程池使用示例 ===");
    
    // 创建包含4个工作线程的线程池
    let pool = ThreadPool::new(4).unwrap();
    
    // 提交多个任务
    for i in 0..5 {
        pool.execute(move || {
            println!("任务{}在线程{:?}中执行", i, std::thread::current().id());
            std::thread::sleep(Duration::from_millis(100));
        });
    }
    
    // 等待所有任务完成
    pool.join();
    println!("所有基本任务已完成\n");
}

// 获取任务返回值示例
fn future_result_example() {
    println!("=== 获取任务返回值示例 ===");
    
    let pool = ThreadPool::new(2).unwrap();
    
    // 提交多个返回值的任务
    let futures = (0..3).map(|i| {
        pool.execute_future(move || {
            println!("计算任务{}开始", i);
            std::thread::sleep(Duration::from_millis(200));
            i * i // 返回平方值
        })
    }).collect::<Vec<_>>();
    
    // 获取所有任务结果
    for (i, future) in futures.into_iter().enumerate() {
        let result = future.wait().unwrap();
        println!("任务{}的结果: {}", i, result);
    }
    println!("所有返回值任务已完成\n");
}

// 并行数据处理示例
fn parallel_data_processing() {
    println!("=== 并行数据处理示例 ===");
    
    let data = (0..20).collect::<Vec<_>>();
    println!("原始数据: {:?}", data);
    
    // 使用CPU核心数创建线程池
    let pool = ThreadPool::new(num_cpus::get()).unwrap();
    
    // 将数据分块处理
    let chunk_size = 5;
    let mut futures = Vec::new();
    
    for chunk in data.chunks(chunk_size) {
        let chunk = chunk.to_vec(); // 获取数据所有权
        let future = pool.execute_future(move || {
            // 模拟耗时处理
            std::thread::sleep(Duration::from_millis(100));
            chunk.into_iter().map(|x| x * x).collect::<Vec<_>>() // 计算平方
        });
        futures.push(future);
    }
    
    // 收集所有结果
    let results: Vec<i32> = futures.into_iter()
        .flat_map(|f| f.wait().unwrap())
        .collect();
    
    println!("处理后的数据: {:?}\n", results);
}

// 高级配置示例
fn advanced_configuration() {
    println!("=== 高级配置示例 ===");
    
    // 使用ThreadPoolBuilder进行高级配置
    let pool = ThreadPoolBuilder::new()
        .num_threads(3) // 设置3个线程
        .thread_name("custom-worker".into()) // 自定义线程名称
        .build()
        .unwrap();
    
    // 提交任务
    let future = pool.execute_future(|| {
        // 模拟可能失败的操作
        if rand::random() {
            Ok("操作成功")
        } else {
            Err("操作失败")
        }
    });
    
    // 处理可能失败的任务
    match future.wait() {
        Ok(result) => println!("任务成功: {}", result),
        Err(e) => println!("任务失败: {:?}", e),
    };
    
    println!("高级配置示例完成\n");
}

性能建议

1. 根据CPU核心数设置合适的线程数量
2. 避免在任务中执行阻塞操作（考虑使用异步版本）
3. 大任务可以拆分为小任务提高并行度

jxl-threadpool是一个简单高效的线程池解决方案，适合大多数需要并行处理的Rust应用场景。