面试题：Rust多线程进度报告中原子操作的优化

优化思路

减少不必要的原子操作：
- 分析每个原子操作，看是否有些操作可以合并。例如，如果多个线程都在对任务进度的不同部分进行更新，但主线程只关心总体进度，那么可以在子线程中先进行局部计算，最后再通过一次原子操作更新总体进度。
- 避免在不必要的地方使用原子类型。如果某个变量只在单个线程内使用，就不需要使用原子类型。
使用更高效的原子类型：
- Rust的std::sync::atomic模块提供了多种原子类型，如AtomicUsize、AtomicI32等。根据实际需求选择最合适的类型。例如，如果任务进度是一个非负整数，AtomicUsize可能是更好的选择，因为它在64位系统上可以利用64位的原子操作指令，而AtomicI32只利用32位指令（假设系统是64位）。
采用无锁数据结构：
- 考虑使用无锁数据结构，如crossbeam::queue::MsQueue（多生产者单消费者队列）或crossbeam::deque::MsDeque（多生产者多消费者双端队列）。这些数据结构可以在多线程环境下高效地进行数据的入队和出队操作，并且不需要传统的锁机制，从而减少线程竞争。如果任务进度更新可以通过队列的方式处理，就可以利用这些无锁数据结构。
使用线程本地存储（TLS）：
- 对于一些辅助数据，可以使用线程本地存储。每个线程都有自己独立的副本，避免了多线程之间对这些数据的竞争。例如，每个线程在更新任务进度时可能需要一些临时的缓存数据，将这些数据存储在线程本地存储中，可以提高性能。

Rust代码示例

减少不必要的原子操作：

use std::sync::{Arc, Mutex};
use std::thread;

// 假设这是任务进度结构体
struct TaskProgress {
    total: usize,
    completed: usize,
}

fn main() {
    let progress = Arc::new(Mutex::new(TaskProgress { total: 0, completed: 0 }));
    let mut handles = vec![];

    for _ in 0..10 {
        let progress_clone = Arc::clone(&progress);
        handles.push(thread::spawn(move || {
            // 子线程局部计算
            let mut local_completed = 0;
            for _ in 0..100 {
                local_completed += 1;
            }
            let mut guard = progress_clone.lock().unwrap();
            guard.total += 100;
            guard.completed += local_completed;
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    let guard = progress.lock().unwrap();
    println!("Total: {}, Completed: {}", guard.total, guard.completed);
}

使用更高效的原子类型：

use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;

fn main() {
    let progress = AtomicUsize::new(0);
    let mut handles = vec![];

    for _ in 0..10 {
        let progress_clone = progress.clone();
        handles.push(thread::spawn(move || {
            for _ in 0..100 {
                progress_clone.fetch_add(1, Ordering::Relaxed);
            }
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Progress: {}", progress.load(Ordering::Relaxed));
}

采用无锁数据结构（以crossbeam::queue::MsQueue为例）：

use crossbeam::queue::MsQueue;
use std::thread;

fn main() {
    let queue = MsQueue::new();
    let mut handles = vec![];

    for _ in 0..10 {
        let queue_clone = queue.clone();
        handles.push(thread::spawn(move || {
            for i in 0..100 {
                queue_clone.push(i);
            }
        }));
    }

    let mut total = 0;
    while let Some(val) = queue.pop() {
        total += val;
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Total from queue: {}", total);
}

使用线程本地存储：

use std::thread;
use thread_local::ThreadLocal;

static LOCAL_COUNTER: ThreadLocal<usize> = ThreadLocal::new();

fn main() {
    let mut handles = vec![];

    for _ in 0..10 {
        handles.push(thread::spawn(|| {
            let mut local_count = LOCAL_COUNTER.get_or(|| 0);
            for _ in 0..100 {
                *local_count += 1;
            }
            LOCAL_COUNTER.set(local_count);
        }));
    }

    for handle in handles {
        handle.join().unwrap();
    }

    let total: usize = LOCAL_COUNTER.iter().sum();
    println!("Total from TLS: {}", total);
}

星途面试题库

面试题：Rust多线程进度报告中原子操作的优化

知识考点

面试题答案

优化思路

Rust代码示例