无畏并发: Rust Mutex的基本使用

并发是很多编程语言避不开的一块主要内容,主打一个无畏并发的Rust自然也面临这样的挑战。Rust中的Mutex提供了强大的同步原语,确保共享数据的线程安全,这篇文章中,我们会探讨Mutex的使用,从基础的用法到一些高阶内容。
在这里插入图片描述


1. Rust中的互斥锁

Mutex作为Rust中的一种互斥锁,它一次只允许一个线程访问共享资源。

  • 提供了一种同步可变数据访问的机制,防止数据竞争、确保线程安全;

  • 位于Rust标准库std::sync::Mutex中,支持对共享可变状态的安全并发访问。

  • 互斥锁允许一个线程在访问共享数据时获取锁,而其他线程必须等待该线程释放锁后才能访问共享数据,从而确保数据的安全性和一致性。


2. 基本用法体验

下面以使用Mutex保护共享数据为例演示Mutex的基础用法。

use std::{sync::Mutex, thread};
fn main() {
    let counter = Mutex::new(0);

    let handle = thread::spawn(move || {
        let mut value = counter.lock().unwrap();
        *value += 1;
    });

    handle.join().expect("thread panicked!");

    let value = counter.lock().unwrap();
    println!("Counter:{}", *value);
}

这段代码演示了Mutex的基本用法,但它是无法通过编译的,尽管如此,这里还是对上述代码进行解释一下:

  1. let counter = Mutex::new(0);

    • 在这行代码中,创建了一个名为 counterMutex,其中包含一个整数值初始为 0。这个 Mutex 将用于保护共享的整数值,以确保线程安全访问。
  2. let handle = thread::spawn(move || { ... });

    • 使用 thread::spawn 创建一个新线程,并在该线程中执行一个闭包。这个闭包中的内容将在新线程中运行。
    • move 关键字用于将 counter 的所有权转移给闭包,确保闭包可以在新线程中使用 counter
  3. let mut val = counter.lock().unwrap();

    • 在闭包中,通过调用 lock() 方法获取 counter 的锁,并使用 unwrap() 处理可能的锁获取失败的情况。这里的 val 是一个 MutexGuard,它允许我们安全地访问被 Mutex 保护的数据。
  4. *val += 1;

    • 在获取了 counter 的锁之后,对共享数据进行递增操作。
  5. handle.join().expect("thread panicked!");

    • 等待新线程执行完毕。join() 方法会阻塞当前线程,直到新线程执行完毕。
    • 如果新线程发生了 panic,expect() 方法会打印指定的错误信息。
  6. let val = counter.lock().unwrap();

    • 在主线程中,再次获取 counter 的锁,以确保安全地访问共享数据。
  7. println!("Counter:{}", *val);

    • 打印最终的共享数据值。

那么问题来了,为什么无法通过编译:

  • 在这段代码在编译阶段会出现 borrow of moved value 的错误,因为我们在 thread::spawn 的闭包中移动了 counter,而后又在闭包外部尝试再次使用它。

  • 为了解决这个问题,我们需要使用 Arc (原子引用计数) 来在多线程之间安全地共享 counter

use std::{
    sync::{Arc, Mutex},
    thread,
};
fn main() {
    let counter = Arc::new(Mutex::new(0));

    let counter_clone = Arc::clone(&counter);
    let handle = thread::spawn(move || {
        let mut value = counter_clone.lock().unwrap();
        *value += 1;
    });

    match handle.join() {
        Ok(_) => {
            let value = counter.lock().unwrap();
            println!("Counter: {}", *value);
        }
        Err(_) => {
            println!("Thread panicked!");
        }
    }
}

修复之后的代码中,使用了Arcmutex进行了调整,通过使用 Arc 来创建一个引用计数的 Mutex,并在闭包中使用 Arc 的克隆。这样可以确保在多线程环境中安全地共享 counter,避免了 borrow of moved value 的问题。同时使用match表达式进一步对错误进行了处理。


3. 多个锁的使用

有时,我们可能需要独立保护多个共享资源。 Rust 允许您使用多个锁来实现这一点:

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

fn main() {
    let cnt1 = Arc::new(Mutex::new(0));
    let cnt2 = Arc::new(Mutex::new(0));

    let cnt1_clone = Arc::clone(&cnt1);
    let handle1 = thread::spawn(move || {
        let mut value = cnt1_clone.lock().unwrap();
        *value += 1;
    });

    let cnt2_clone = Arc::clone(&cnt2);
    let handle2 = thread::spawn(move || {
        let mut value2 = cnt2_clone.lock().unwrap();
        *value2 += 1;
    });

    match handle1.join() {
        Ok(_) => {
            let value1 = cnt1.lock().unwrap();
            println!("cnt1:{}", *value1);
        }
        Err(_) => {
            println!("Thread panicked!");
        }
    }

    match handle2.join() {
        Ok(_) => {
            let value2 = cnt2.lock().unwrap();
            println!("cnt2:{}", *value2);
        }
        Err(_) => {
            println!("Thread panicked!");
        }
    }
}

这段代码演示了如何使用 ArcMutex 在 Rust 中实现多线程并发访问共享数据:

  1. 首先,通过 use 关键字引入了需要使用的标准库中的一些模块,包括 ArcMutexthread

  2. main 函数中,创建了两个计数器 cnt1cnt2,它们分别被包装在 ArcMutex 中。这样做是为了确保在多线程环境中安全地访问这两个计数器。

  3. 使用 Arc::clone(&cnt1)Arc::clone(&cnt2) 创建了两个 Arc 的克隆,分别赋值给 cnt1_clonecnt2_clone。这样做是为了将计数器的所有权移动到新的线程中。

  4. 通过 thread::spawn 创建了两个线程 handle1handle2,分别对 cnt1_clonecnt2_clone 所指向的计数器进行操作。在每个线程中,首先获取了计数器的锁,然后对计数器的值进行加一操作。

  5. 使用 handle1.join()handle2.join() 分别等待两个线程的执行结果。如果线程执行成功,就获取相应计数器的锁并打印计数器的值;如果线程执行失败(比如发生了 panic),则打印出相应的错误信息。


  • 23
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

代号0408

轻轻一点,暖心房

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值