Rust开发——Rust开发中thread_local

thread_local

thread_local 是一种非常有用的工具，特别适用于需要在每个线程中保持独立状态的情况。在很多情况下，它可以避免全局变量带来的并发问题，并且减少了锁的开销。在 Java 中，Spring 使用 ThreadLocal 来实现线程安全的事务管理。

在 Rust 中，thread_local 关键字同样提供了线程本地存储的能力。通过 thread_local 定义的变量，每个线程都拥有其独立的副本。这对于需要在线程级别保持状态的场景非常有用。使用 with 方法来访问 thread_local 变量确保了在线程中对其进行安全访问，因为它在 Rust 中实现了 Drop trait，当线程结束时会被正确释放。

thread_local 的使用方式：

use std::thread;
use std::cell::RefCell;

thread_local! {
    static F: RefCell<u32> = RefCell::new(0);
}

fn main() {
    // 启动两个线程
    let handle1 = thread::spawn(|| {
        // 在第一个线程中设置 F 的值为 1
        F.with(|f| {
            *f.borrow_mut() = 1;
            println!("Thread 1: F = {:?}", *f.borrow());
        });
    });

    let handle2 = thread::spawn(|| {
        // 在第二个线程中设置 F 的值为 2
        F.with(|f| {
            *f.borrow_mut() = 2;
            println!("Thread 2: F = {:?}", *f.borrow());
        });
    });

    // 等待两个线程结束
    handle1.join().unwrap();
    handle2.join().unwrap();

    // 最后在主线程获取 F 的值
    F.with(|f| {
        println!("Main Thread: F = {:?}", *f.borrow());
    });
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

这个示例展示了 thread_local 变量 F 在两个线程中的独立状态，并在主线程中获取了最终的值。RefCell 用于在运行时进行借用检查，确保线程安全地修改和访问 F。

在 Rust 中，thread_local 的使用可以确保线程间数据的隔离，避免了全局变量可能引发的竞态条件和锁开销。

所有权

在 Rust 中，确实存在对于引用的可见性和可变性方面的限制，这是语言为了确保内存安全性而采取的策略，以避免数据竞争和悬垂指针等问题。

Rust中的所有权系统确保每个值都有唯一的所有者，并通过借用机制允许在拥有所有权的情况下对值进行访问和操作。这里提到的引用类型 & 和 &mut 都是用于在不同情况下对值进行借用的工具。

在同一个作用域中，对于某个对象的引用，Rust 遵循以下规则：

1. 可变性：在给定作用域内，要么只能有一个可变引用（&mut），要么可以有多个不可变引用（&）。这是为了避免数据竞争（在多线程或并发情况下出现多个指针同时写入同一数据时可能引发的问题）。

2. 生命周期：引用的生命周期必须满足所有权的规则，即引用不能超出其所引用的对象的生命周期。

这种限制确保了在编译阶段就能够检测出可能导致悬垂指针或数据竞争的情况，从而确保了内存安全性。

虽然这些规则可能对于初学者来说有些复杂和严格，但它们是为了确保 Rust 代码在编译时就能够保证内存安全和线程安全。这样的做法带来的好处是，开发者在编写代码时更容易避免常见的内存错误，提高了代码的可靠性和安全性。

⽐如：

struct Person {
 name: String,
 age: usize,
}
fn main() {
 let person = Person { name: "Joe Biden".to_string(), age: 79 };
 let person_ref: &Person = &person;
 person_ref.age = 83;
}
1
2
3
4
5
6
7
8
9

编译失败，因为 person_ref 属于共享引⽤，并没有修改权限。

thread_local与所有权

thread_local 宏用于创建线程本地存储，允许每个线程都拥有其独立的副本，这与所有权概念有所不同。

所有权（Ownership）是 Rust 中的一个核心概念，它用于管理内存的分配和释放，确保在编译时避免出现数据竞争、悬垂指针和多线程安全问题。所有权规则强制确保每个值都只有一个所有者，并通过移动、借用和生命周期来管理值的传递和使用。

与所有权不同，thread_local 提供了一种在每个线程中创建独立数据的机制。它允许线程之间共享一些数据，但每个线程都有自己的数据副本，不同于所有权模型中严格的“单一所有者”规则。

举个例子，在使用 thread_local 宏时，你可以创建一个线程本地的变量，每个线程都有自己的这个变量的拷贝，而这个拷贝的所有权属于对应的线程。这并不会影响 Rust 所有权模型中的其他部分，因为这种线程本地存储的方式是 Rust 为了特定线程提供独立状态而设计的，与所有权模型中的借用、移动等规则不冲突。

thread_local 宏创建线程本地存储：

use std::thread;
use std::cell::RefCell;

thread_local! {
    static MY_THREAD_LOCAL: RefCell<u32> = RefCell::new(0);
}

fn main() {
    // 在每个线程中更改 thread_local 变量的值
    let handle1 = thread::spawn(|| {
        MY_THREAD_LOCAL.with(|f| {
            *f.borrow_mut() = 42;
            println!("Thread 1: My value = {:?}", *f.borrow());
        });
    });

    let handle2 = thread::spawn(|| {
        MY_THREAD_LOCAL.with(|f| {
            *f.borrow_mut() = 99;
            println!("Thread 2: My value = {:?}", *f.borrow());
        });
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

此示例中，MY_THREAD_LOCAL 是一个线程本地的 RefCell，每个线程可以独立访问并修改它的值，而不会产生数据竞争问题，因为每个线程都有自己的副本。

thread_local 提供了一种机制来创建每个线程独立的数据副本，与 Rust 的所有权模型并不矛盾，而是为了满足线程间数据共享和独立状态的需求。