Via 由 [ ] 提供

共享内存

在消息传递之外,还存在一种广为人知的并发模型,那就是共享内存。其实如果不能共享内存,消息传递也是不能在不同的线程间传递消息,也谈不上在不同的线程间等待和通知了。共享内存是这一切得以发生的基础。如果查看源码,你会发现消息传递的内部实现就是借用了共享内存机制。相对于消息传递而言,共享内存会有更多的竞争,但是不用进行多次拷贝,在某些情况下,也需要考虑使用这种方式来处理。在Rust中,能共享内存的情况,主要体现在下面两个方面:

static

Rust语言中也存在static变量,其生命周期是整个应用程序,并且在内存中某个固定地址处只存在一份实例。所有线程都能够访问到它。这种方式也是最简单和直接的共享方式。几乎大多数语言都存在这种机制。下面简单看一下Rust中多个线程访问static变量的用法:

use std::thread;

static VAR: i32 = 5;

fn main() {
    // 创建一个新线程
    let new_thread = thread::spawn(move|| {
        println!("static value in new thread: {}", VAR);
    });

    // 等待新线程先运行
    new_thread.join().unwrap();
    println!("static value in main thread: {}", VAR);
}

运行结果:

static value in new thread: 5
static value in main thread: 5

VAR这个static变量在各线程中可以直接使用,非常方便。当然上面只是读取,那么要修改也是很简单的:

use std::thread;

static mut VAR: i32 = 5;

fn main() {
    // 创建一个新线程
    let new_thread = thread::spawn(move|| {
        unsafe {
            println!("static value in new thread: {}", VAR);
            VAR = VAR + 1;
        }
    });

    // 等待新线程先运行
    new_thread.join().unwrap();
    unsafe {
        println!("static value in main thread: {}", VAR);
    }
}

运行结果:

static value in new thread: 5
static value in main thread: 6

从结果来看VAR的值变了,从代码上来看,除了在VAR变量前面加了mut关键字外,更加明显的是在使用VAR的地方都添加了unsafe代码块。为什么?所有的线程都能访问VAR,且它是可以被修改的,自然就是不安全的。上面的代码比较简单,同一时间只会有一个线程读写VAR,不会有什么问题,所以用unsafe来标记就可以。如果是更多的线程,还是请使用接下来要介绍的同步机制来处理。

static如此,那const呢? const会在编译时内联到代码中,所以不会存在某个固定的内存地址上,也不存在可以修改的情况,并不是内存共享的。

由于现代操作系统的设计,线程寄生于进程,可以共享进程的资源,如果要在各个线程中共享一个变量,那么除了上面的static,还有就是把变量保存在堆上了。当然Rust也不例外,遵从这一设计。只是我们知道Rust在安全性上肯定又会做一些考量,从而在语言设计和使用上稍有不同。

为了在堆上分配空间,Rust提供了std::boxed::Box,由于堆的特点,存活时间比较长,所以除了我们这个地方介绍的线程间共享外,还有其他的用处,此处不详细说明,若不甚了解,请学习或回顾堆、栈与Box章节的介绍。下面我们来看一下如何在多个线程间访问Box创建的变量:

use std::thread;
use std::sync::Arc;

fn main() {
    let var : Arc<i32> = Arc::new(5);
    let share_var = var.clone();

    // 创建一个新线程
    let new_thread = thread::spawn(move|| {
        println!("share value in new thread: {}, address: {:p}", share_var, &*share_var);
    });

    // 等待新建线程先执行
    new_thread.join().unwrap();
    println!("share value in main thread: {}, address: {:p}", var, &*var);
}

运行结果:

share value in new thread: 5, address: 0x2825070
share value in main thread: 5, address: 0x2825070

你可能会觉得很奇怪,上面怎么没有看到Box创建的变量啊,这明明就是Arc的使用呀?Box创建的变量要想在多个线程中安全使用,我们还需要实现很多功能才行,需要是Sync,而Arc正是利用Box来实现的一个通过引用计数来共享状态的包裹类。下面引用一段Arc::new的源码即可看出它是通过Box来实现的:

pub fn new(data: T) -> Arc<T> {
    // Start the weak pointer count as 1 which is the weak pointer that's
    // held by all the strong pointers (kinda), see std/rc.rs for more info
    let x: Box<_> = box ArcInner {
        strong: atomic::AtomicUsize::new(1),
        weak: atomic::AtomicUsize::new(1),
        data: data,
    };
    Arc { _ptr: unsafe { NonZero::new(Box::into_raw(x)) } }
}

通过上面的运行结果,我们也可以发现新建线程和主线程中打印的address是一样的,说明状态确实是在同一个内存地址处。

如果Box在堆上分配的资源仅在一个线程中使用,那么释放时,就非常简单,使用完,及时释放即可。如果是要在多个线程中使用,就需要面临两个关键问题:

  1. 资源何时释放?
  2. 线程如何安全的并发修改和读取?

由于上面两个问题的存在,这就是为什么我们不能直接用Box变量在线程中共享的原因,可以看出来,共享内存比消息传递机制似乎要复杂许多。Rust用了引用计数的方式来解决第一个问题,在标准库中提供了两个包裹类,除了上面一个用于多线程的std::sync::Arc之外,还有一个不能用于多线程的std::rc::Rc。在使用时,可以根据需要进行选择。如果你一不小心把std::rc::Rc用于多线程中,编译器会毫不客气地纠正你的。

关于上面的第二个问题,Rust语言及标准库提供了一系列的同步手段来解决。下面的章节我们将详细讲解这些方式和用法。

上一篇: 消息传递 下一篇: 同步