【Rust】互斥锁Mutex以及读写锁RwLock

介绍

在 Rust 中，避免资源调用冲突的常用方法是使用 std::sync 模块中的互斥锁Mutex和读写锁RwLock。这些锁提供了一种安全的机制来保护共享资源，确保在并发环境中不会发生数据竞争。

使用 Mutex

Mutex 是一种互斥锁，确保一次只有一个线程可以访问共享资源。它在 Rust 的标准库中定义在 std::sync 模块中。
以下是一个使用 Mutex 的示例：

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

fn main() {
    // 创建一个互斥锁，初始值为 0
    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!("Result: {}", *counter.lock().unwrap());
}

在这个示例中

创建互斥锁：使用 Mutex::new 创建一个互斥锁，保护一个初始值为 0 的计数器。
共享所有权：使用 Arc（原子引用计数）来共享互斥锁的所有权，使多个线程能够访问同一个锁。
线程操作：每个线程尝试增加计数器的值。在访问计数器时，线程首先使用 lock 方法获取互斥锁，确保没有其他线程同时访问。
自动解锁：lock 方法返回一个 MutexGuard，它在作用域结束时自动解锁，确保资源安全释放。

使用 RwLock

RwLock是一种读写锁，允许多个读者同时访问，但写者访问时必须独占。它也在 std::sync 模块中定义。

下面是一个使用 RwLock 的示例：

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

fn main() {
    // 创建一个读写锁，初始值为 0
    let counter = Arc::new(RwLock::new(0));

    // 创建多个读线程和一个写线程
    let mut handles = vec![];

    // 读线程
    for _ in 0..5 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let num = counter.read().unwrap();
            println!("Read: {}", *num);
        });
        handles.push(handle);
    }

    // 写线程
    {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.write().unwrap();
            *num += 10;
            println!("Written: {}", *num);
        });
        handles.push(handle);
    }

    // 等待所有线程完成
    for handle in handles {
        handle.join().unwrap();
    }
}

在这个示例中

创建读写锁：使用 RwLock::new 创建一个读写锁，保护一个初始值为 0 的计数器。
共享所有权：使用 Arc 来共享读写锁的所有权，使多个线程能够访问同一个锁。
读线程：读线程使用 read 方法获取读锁，可以同时有多个读线程访问共享资源。
写线程：写线程使用 write 方法获取写锁，确保写操作是独占的。
自动解锁：read 和 write 方法分别返回 RwLockReadGuard 和 RwLockWriteGuard，它们在作用域结束时自动解锁，确保资源安全释放。

总结

在 Rust 中，可以通过 Mutex和 RwLock 来保护共享资源，避免资源调用冲突。这两种锁机制都提供了安全的并发编程支持：

• Mutex：适用于需要独占访问资源的场景。
• RwLock：适用于读操作多于写操作的场景，允许多个读者同时访问。

使用这些锁可以确保数据的一致性和安全性，有效避免数据竞争。