面试题：Rust中并行性能优化之线程池使用

使用thread - pool库创建线程池并并行处理任务：

首先，在Cargo.toml文件中添加thread - pool依赖：

[dependencies]
thread - pool = "0.1.9"

然后编写代码如下：

use thread_pool::ThreadPool;

// 定义一个计算密集型函数
fn compute_intensive_task(x: i32) -> i32 {
    // 简单示例，实际计算密集型任务会有更复杂逻辑
    (0..x).sum()
}

fn main() {
    let pool = ThreadPool::new(4).unwrap();

    let tasks: Vec<_> = (0..10).map(|i| {
        pool.execute(move || {
            let result = compute_intensive_task(i);
            println!("Task {} result: {}", i, result);
        })
    }).collect();

    // 等待所有任务完成
    for task in tasks {
        task.join().unwrap();
    }
}

共享资源访问问题及解决办法：

问题：当多个线程访问共享资源时，可能会出现数据竞争问题，导致程序出现未定义行为。例如，多个线程同时读写同一个变量，会导致数据不一致。

解决办法：

互斥锁（Mutex）：使用std::sync::Mutex来保护共享资源。线程在访问共享资源前需要先获取锁，访问结束后释放锁。例如：

use std::sync::{Mutex, Arc};
use thread_pool::ThreadPool;

fn main() {
    let shared_data = Arc::new(Mutex::new(0));
    let pool = ThreadPool::new(4).unwrap();

    for _ in 0..10 {
        let shared_data = shared_data.clone();
        pool.execute(move || {
            let mut data = shared_data.lock().unwrap();
            *data += 1;
            println!("Shared data: {}", *data);
        });
    }
}

读写锁（RwLock）：如果共享资源的读操作远多于写操作，可以使用std::sync::RwLock。多个线程可以同时获取读锁进行读取操作，但写操作需要获取写锁，且获取写锁时其他线程不能持有读锁或写锁。例如：

use std::sync::{RwLock, Arc};
use thread_pool::ThreadPool;

fn main() {
    let shared_data = Arc::new(RwLock::new(0));
    let pool = ThreadPool::new(4).unwrap();

    for _ in 0..5 {
        let shared_data = shared_data.clone();
        pool.execute(move || {
            let data = shared_data.read().unwrap();
            println!("Read shared data: {}", *data);
        });
    }

    for _ in 0..2 {
        let shared_data = shared_data.clone();
        pool.execute(move || {
            let mut data = shared_data.write().unwrap();
            *data += 1;
            println!("Write shared data: {}", *data);
        });
    }
}

实际应用中，还需根据具体场景选择合适的同步原语，以确保线程安全和程序性能。

星途面试题库

面试题：Rust中并行性能优化之线程池使用

知识考点

面试题答案