面试题：Rust高级栈内存优化技巧与并发编程

解决方法

原子操作：
- 使用Rust标准库中的std::sync::atomic模块。对于简单类型（如i32）的共享数据读写，可以使用原子类型。例如，AtomicI32，它提供了原子的读、写、修改等操作，避免了数据竞争。
线程本地存储（TLS）：
- 当每个线程需要自己独立的数据副本，且该数据不需要在不同线程间共享时，可以使用线程本地存储。Rust通过thread_local!宏来实现。这减少了对共享数据的竞争，同时也优化了栈内存使用，因为每个线程有自己独立的副本。
读写锁（RwLock）：
- 如果共享数据的读操作远远多于写操作，可以使用读写锁。读操作可以并发执行，而写操作会独占锁，防止其他读写操作。在Rust中，可以使用std::sync::RwLock。
通道（channel）：
- 通过通道进行线程间通信，避免直接对共享数据进行读写。一个线程可以发送数据到通道，另一个线程从通道接收数据，这种方式有助于解耦线程间的直接数据交互，减少资源争用。

代码框架示例

原子操作示例：

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

fn main() {
    let shared_data = AtomicI32::new(0);

    let handles: Vec<_> = (0..10).map(|_| {
        let data = shared_data.clone();
        thread::spawn(move || {
            for _ in 0..100 {
                data.fetch_add(1, Ordering::SeqCst);
            }
        })
    }).collect();

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

    println!("Final value: {}", shared_data.load(Ordering::SeqCst));
}

线程本地存储示例：

thread_local! {
    static LOCAL_DATA: i32 = 0;
}

fn main() {
    let handles: Vec<_> = (0..10).map(|_| {
        thread::spawn(move || {
            LOCAL_DATA.with(|data| {
                *data.borrow_mut() += 1;
                println!("Thread local data: {}", *data.borrow());
            });
        })
    }).collect();

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

读写锁示例：

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

fn main() {
    let shared_data = Arc::new(RwLock::new(String::from("Initial data")));

    let read_handles: Vec<_> = (0..10).map(|_| {
        let data = shared_data.clone();
        thread::spawn(move || {
            let read_lock = data.read().unwrap();
            println!("Read data: {}", read_lock);
        })
    }).collect();

    let write_handle = thread::spawn(move || {
        let mut write_lock = shared_data.write().unwrap();
        *write_lock = String::from("Updated data");
    });

    for handle in read_handles {
        handle.join().unwrap();
    }
    write_handle.join().unwrap();
}

通道示例：

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    let send_handle = thread::spawn(move || {
        for i in 0..10 {
            tx.send(i).unwrap();
        }
    });

    let recv_handle = thread::spawn(move || {
        for received in rx {
            println!("Received: {}", received);
        }
    });

    send_handle.join().unwrap();
    recv_handle.join().unwrap();
}

星途面试题库

面试题：Rust高级栈内存优化技巧与并发编程

知识考点

面试题答案

解决方法

代码框架示例