Rust 多线程编程|并发设计需要掌握前置知识点

说明

建议有一定基础的同学阅读,用 捡装备的方式 阅读,扩展知识深度。

本文章内容为学习笔记,《Rust原子和锁》;

要有一定的Rust实践经验的同学才能很好的理解其中的内容。

Rust 多线程编程|并发设计需要掌握的知识点

最简单的多线程基础类型

  • static 属于整个程序,不属于单个进程。

  • leaking box::leak, Box 将永远存在,没有所有者,只要程序运行,任何线程都可以借用它。

  • reference counted 引用计数 Rc ,仅限于单个线程中,如果涉及多个线程,则需要使用多线程版本的 Arc。

语言本身提供的借用规则,引用(借用),可变应用,能保证单线程数据安全,但当多线程场景,它们就完全失去了作用;

Tip: 有一个逃生口,就是 内部可变性(interior mutability)。

内部可变类型

约定

引用称为 不可变(immutable)可变(mutable) 对于并发程序描述会变得混乱和不准确,

更准确的术语是 共享(shared)独占(exclusive)

记住两个约定名词:

  1. 独占 &mut T 保证它是 T 的唯一独占借用

  2. 共享 &T 可以复制并与他人共享


标准库提供的内部可变类型

UnsafeCell

它是内部可变性的原始构建块,很少直接使用,而是包装在另一种通过有限接口提供安全性的类型中;

下面的 Cell 、 Mutex,所有具有内部可变性的类型,都建立在 UnsafeCell 之上。

它的 get() 方法只是提供一个指向它包装的值的原始指针,它只能在 unsafe 块中有意义地使用。

Cell

Cell<T> 简单地包装了 T ,但允许通过共享引用进行更改; 只能在单线程内使用, 它将值复制出来(如果 T 为 Copy ),或将其整体替换为另一个值。

RefCell

RefCell 不仅包含 T ,而且还包含一个计数器,用于跟踪任何未完成的借用。

Tip: Cell 和 RefCell 只适合单进程。

可多线程内部可变

RwLock

它是 RefCell 的并发版本,它会阻塞当前线程——使其进入睡眠状态,同时等待冲突借用消失;

在其他线程处理完数据后,我们只需要耐心等待轮到我们处理数据;

它带有两种守卫类型,一种用于读,一种用于写: RwLockReadGuard 和 RwLockWriteGuard ;

RwLockReadGuard 仅实现 Deref ,使其表现得像对受保护数据的共享引用;

RwLockWriteGuard 后者还实现 DerefMut ,表现得像独占引用。

Mutex

与 RwLock 很相似,但只允许独占借用。

它的 lock() 方法返回一个称为 MutexGuard 的特殊类型。这个守卫代表我们已经锁定互斥锁的保证。

MutexGuard 的行为类似于通过 DerefMut 特征的独占引用,使我们能够独占访问互斥锁保护的数据。

use std::sync::Mutex;

fn main() {
    let n = Mutex::new(0);
    thread::scope(|s| {
        for _ in 0..10 {
            s.spawn(|| {
                // 得到 MutexGuard
                let mut guard = n.lock().unwrap();
                for _ in 0..100 {
                    *guard += 1;
                }
            });
        } // 循环结束,自动解锁 MutexGuard
    });
    assert_eq!(n.into_inner().unwrap(), 1000);
}

Atomics

原子类型表示 Cell 的并发版本, 它们通过让我们把值作为一个整体复制进去,而不是让我们直接借用内容来避免未定义行为;

与 Cell 不同的是,它们不能是任意大小;

任何 T 都没有通用的 Atomic 类型,只有 AtomicU32 和 AtomicPtr 等 特定的原子类型。

哪些可用取决于平台,因为它们需要处理器的支持以避免数据竞争。

原子类型

先要知道 Rust 使用的是 SendSync 特征来判断是否能够安全的跨线程:

  • Send 所有权可以转移到另一个线程。

  • Sync 可以与另一个线程共享。

Tip: 所有原始类型都默认实现了 Send 和 Sync (i32 、bool 和 str 等)

两个特征都是自动特征,字段全为 SendSync 的 struct 本身也是 SendSync

Tip: 原始指针*const T*mut T 既不是 Send 也不是 Sync

不想实现 SendSync特征, 给类型加一个未实现该特征的类型即可,这里提供了:


// 行时实际上并不存在。它是零大小的类型,不占用空间

std::marker::PhantomData<T>

struct  X {

 handle: i32,

 _not_sync: PhantomData<Cell<()>>,

}

等待: 停放和条件变量

线程停放(Thread Praking)

线程停放可通过 park() 函数获得。

Tip: 等待来自另一个线程的通知的一种方法称为线程停放(Thread parking)。线程可以自行停放(park),使其进入睡眠状态,从而停止消耗任何 CPU 周期。然后另一个线程可以取消停放的线程,将其从睡眠中唤醒。


fn  main() {
    let  queue  =  Mutex::new(VecDeque::new());
    thread::scope(|s| {
        // 消费线程
        let  t  =  s.spawn(||  loop {
             let  item  =  queue.lock().unwrap().pop_front();
             if  let  Some(item) =  item {
                dbg!(item); // 有数据则消费
            } else {
                thread::park(); // 无则停放
            }
        });

        // 生产线程
        for  i  in  0.. {
            queue.lock().unwrap().push_back(i);
            t.thread().unpark(); // 取消停放
            thread::sleep(Duration::from_secs(1));
        }

    });
}

条件变量 Condvar

有两个基本操作:等待 和 通知。


use std::sync::Condvar;

let queue = Mutex::new(VecDeque::new());
let not_empty = Condvar::new();

thread::scope(|s| {
    s.spawn(|| {
        loop {
            let mut q = queue.lock().unwrap();
            let item = loop {
                if let Some(item) = q.pop_front() {
                    break item;
                } else {
                    q = not_empty.wait(q).unwrap();
                }
            };
            drop(q);
            dbg!(item);
        }
    });

    for i in 0.. {
        queue.lock().unwrap().push_back(i);
        not_empty.notify_one();
        thread::sleep(Duration::from_secs(1));
    }
});

说明

本文章内容为 学习《Rust原子和锁》 笔记,Rust原子和锁;

要有一定的Rust实践经验的同学才能很好的理解其中的内容,不建议初学者阅读。

本作品采用《CC 协议》,转载必须注明作者和本文链接
实干兴邦、力争上游
讨论数量: 0
(= ̄ω ̄=)··· 暂无内容!

讨论应以学习和精进为目的。请勿发布不友善或者负能量的内容,与人为善,比聪明更重要!
未填写
文章
40
粉丝
13
喜欢
77
收藏
67
排名:292
访问:3.3 万
私信
所有博文
社区赞助商