Rust在Linux中的并发处理_运维文库_资讯中心

发布时间:2026-04-27 10:06:19

阅读量:3

Rust在Linux中的并发处理非常强大且灵活，主要依赖于其标准库中提供的各种并发原语。以下是一些关键概念和示例代码，帮助你理解如何在Rust中处理并发。

基本并发原语

线程（Threads）： Rust通过std::thread模块提供了创建和管理线程的功能。

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("这是新线程!");
    });

    handle.join().unwrap();
}

共享内存与互斥锁（Mutex）：使用Mutex确保多个线程安全地访问共享数据。

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

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

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

    println!("计数器值: {}", *counter.lock().unwrap());
}

线程间通信（Channels）：使用mpsc模块创建多生产者单消费者（MPSC）通道进行线程间通信。

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

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

    thread::spawn(move || {
        tx.send("hello").unwrap();
    });

    let message = rx.recv().unwrap();
    println!("Received: {}", message);
}

高级并发原语

原子操作（Atomic Operations）：使用std::sync::atomic模块进行低级别的原子操作。

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

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

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            counter.fetch_add(1, Ordering::SeqCst);
        });
        handles.push(handle);
    }

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

    println!("计数器值: {}", counter.load(Ordering::SeqCst));
}

读写锁（RwLock）：使用std::sync::RwLock允许多个读取者同时访问数据，但只允许一个写入者。

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

fn main() {
    let data = Arc::new(RwLock::new(0));
    let mut handles = vec![];

    for i in 0..10 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let mut num = data.write().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

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

    println!("数据值: {}", *data.read().unwrap());
}