周刊（第20期）：Rust并发安全相关的几个概念(下)

Sat, 25 Jun 2022 10:00:49 +0800

引言：本文介绍Rust并发安全相关的几个概念：Send、Sync、Arc，Mutex、RwLock等之间的联系。这是其中的下篇，主要介绍Arc，Mutex、RwLock这几个线程安全相关的类型。

Rust并发安全相关的几个概念（下） #

在上一节中，讲解了Send和Sync这两个线程安全相关的trait，在此基础上展开其它相关类型的讲解。

Rc #

Rc是Reference Counted（引用计数）的简写，在Rust中，这个数据结构用于实现单线程安全的对指针的引用计数。之所以这个数据结构只是单线程安全，是因为在定义中显式声明了并不实现Send和Sync这两个trait：

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !marker::Send for Rc<T> {}

#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> !marker::Sync for Rc<T> {}

个中原因，是因为Rc内部的实现中，使用了非原子的引用计数（non-atomic reference counting），因此就不能满足线程安全的条件了。如果要在多线程中使用引用计数，就要使用Arc这个类型：

Arc #

与Rc不同的是，Arc内部使用了原子操作来实现其引用计数，因此Arc是Atomically Reference Counted（原子引用计数）的简写，能被使用在多线程环境中，缺陷是原子操作的性能消耗会更大一些。

虽然Arc能被用在多线程环境中，并不意味着Arc<T>天然就实现了Send和Sync，来看看这两部分的声明：

#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: ?Sized + Sync + Send> Send for Arc<T> {}
#[stable(feature = "rust1", since = "1.0.0")]
unsafe impl<T: ?Sized + Sync + Send> Sync for Arc<T> {}

从声明可以看出：一个Arc<T>类型，当且仅当包裹（wrap）的类型T满足Sync和Send时才能被认为是满足Send和Sync的类型。来做一个实验：

#![feature(negative_impls)]
use std::sync::Arc;

#[derive(Debug)]
struct Foo {}
impl !Send for Foo {}

fn main() {
    let foo = Arc::new(Foo {});
    std::thread::spawn(move || {
        dbg!(foo);
    });
}

在以上的代码中，由于在第8行显示声明了Foo这个类型不满足Sync，所以这段代码编译不过，报错信息如下：

周刊（第19期）：Rust并发安全相关的几个概念(上)

Sun, 19 Jun 2022 10:42:40 +0800

引言：本文介绍Rust并发安全相关的几个概念：Send、Sync、Arc，Mutex、RwLock等之间的联系。这是其中的上篇，主要介绍Send、Sync这两个trait。

Rust并发安全相关的几个概念（上） #

Rust的所有权概念 #

在展开介绍并发相关的几个概念之前，有必要先了解一下Rust的所有权概念，Rust对值（value）的所有权有明确的限制：

一个值只能有一个owner。
可以同时存在同一个值的多个共享的非可变引用（immutable reference）。
但是只能存在一个值的可变引用（mutable reference）。

比如下面这段代码，user在创建线程之后，被移动（move）到两个不同的线程中：

fn main() {
    let user = User { name: "drogus".to_string() };

    let t1 = spawn(move || {
        println!("Hello from the first thread {}", user.name);
    });

    let t2 = spawn(move || {
        println!("Hello from the second thread {}", user.name);
    });

    t1.join().unwrap();
    t2.join().unwrap();
}

由于一个值只能有一个owner，所以编译器报错，报错信息如下：

error[E0382]: use of moved value: `user.name`
  --> src/main.rs:15:20
   |
11 |     let t1 = spawn(move || {
   |                    ------- value moved into closure here
12 |         println!("Hello from the first thread {}", user.name);
   |                                                    --------- variable moved due to use in closure
...
15 |     let t2 = spawn(move || {
   |                    ^^^^^^^ value used here after move
16 |         println!("Hello from the second thread {}", user.name);
   |                                                    --------- use occurs due to use in closure
   |
   = note: move occurs because `user.name` has type `String`, which does not implement the `Copy` trait

Send和Sync的约束作用 #

于是，如果一个类型会被多个线程所使用，是需要明确说明其共享属性的。Send和Sync这两个trait作用就在于此，注意到这两个trait都是std::marker，实现这两个trait并不需要对应实现什么方法，可以理解为这两个trait是类型的约束，编译器通过这些约束在编译时对类型进行检查。到目前为止，暂时不展开对两个概念的理解，先来看看两者是如何在类型检查中起约束作用的。

Rust on codedump notes