×

如何在Rust中合理使用全局变量

作者:Terry2021.08.04来源:Web前端之家浏览:18511评论:0
关键词:jsRust

500.jpg

在 Rust 中声明和使用全局变量可能很棘手。通常对于这种语言,Rust 通过强制我们非常明确来确保健壮性。

在本文中,我将讨论 Rust 编译器想要让我们避免的陷阱。然后我将向您展示适用于不同场景的最佳解决方案。

概述

在 Rust 中实现全局状态有很多选择。如果您赶时间,这里是我的建议的快速概述。

QQ截图20210804090258.jpg

您可以通过以下链接跳转到本文的特定部分:

  • 没有全局变量:重构为 Arc / RC

  • 编译时初始化的全局变量:const T / static T

  • 使用外部库来轻松进行运行时初始化的全局变量:lazy_static / once_cell

  • 实现你自己的运行时初始化:std::sync::Once + static mut T

  • 单线程运行时初始化的特例:thread_local

在 Rust 中使用全局变量的首次尝试

让我们从如何不使用全局变量的示例开始。假设我想将程序的开始时间存储在一个全局字符串中。后来,我想从多个线程访问该值。

Rust 初学者可能很想像 Rust 中的任何其他变量一样声明一个全局变量,使用let. 完整的程序可能如下所示:

use chrono::Utc;let START_TIME = Utc::now().to_string();pub fn main() {
    let thread_1 = std::thread::spawn(||{
        println!("Started {}, called thread 1 {}", START_TIME.as_ref().unwrap(), Utc::now());
    });
    let thread_2 = std::thread::spawn(||{
        println!("Started {}, called thread 2 {}", START_TIME.as_ref().unwrap(), Utc::now());
    });
    // Join threads and panic on error to show what went wrong
    thread_1.join().unwrap();
    thread_2.join().unwrap();}


这是 Rust 的无效语法。该let关键字不能在全球范围内使用。我们只能使用staticor const。后者声明了一个真正的常量,而不是一个变量。只static给我们一个全局变量。

这背后的原因是let在运行时在堆栈上分配一个变量。请注意,在堆上分配时仍然如此,如let t = Box::new();. 在生成的机器代码中,仍然有一个指向存储在堆栈中的堆的指针。

全局变量存储在程序的数据段中。它们有一个在执行过程中不会改变的固定地址。因此,代码段可以包含常量地址,并且根本不需要堆栈空间。

好的,所以我们可以理解为什么我们需要不同的语法。Rust 作为一种现代系统编程语言,希望对内存管理非常明确。

让我们再试一次static

use chrono::Utc;static START_TIME: String = Utc::now().to_string();pub fn main() {
    // ...}

编译器还不满意:

error[E0015]: calls in statics are limited to constant functions, tuple structs and tuple variants --> src/main.rs:3:24
  |3 | static start: String = Utc::now().to_string();
  |                        ^^^^^^^^^^^^^^^^^^^^^^

嗯,所以不能在运行时计算静态变量的初始化值。那么也许只是让它未初始化?

use chrono::Utc;static START_TIME;pub fn main() {
    // ...}

这会产生一个新的错误:

Compiling playground v0.0.1 (/playground)error: free static item without body --> src/main.rs:21:1
  |3 | static START_TIME;
  | ^^^^^^^^^^^^^^^^^-
  |                  |
  |                  help: provide a definition for the static: `= <expr>;`

所以这也行不通!在任何用户代码运行之前,所有静态值都必须完全初始化且有效。

如果您从另一种语言(例如 JavaScript 或 Python)转向 Rust,这可能看起来是不必要的限制。但是任何 C++ 大师都可以告诉您有关静态初始化顺序失败的故事,如果我们不小心,这可能会导致未定义的初始化顺序。

例如,想象这样的事情:

static A: u32 = foo();static B: u32 = foo();static C: u32 = A + B;fn foo() -> u32 {
    C + 1}fn main() {
    println!("A: {} B: {} C: {}", A, B, C);}

在此代码片段中,由于循环依赖,没有安全的初始化顺序。

如果是不关心安全性的 C++,结果将是A: 1 B: 1 C: 2. 它在任何代码运行之前进行零初始化,然后在每个编译单元内从上到下定义顺序。

至少它定义了结果是什么。然而,当静态变量来自不同的.cpp文件,因此不同的编译单元时,“惨败”就开始了。那么顺序是未定义的,通常取决于编译命令行中文件的顺序。

在 Rust 中,零初始化不是一回事。毕竟,零对于许多类型都是无效值,例如Box. 此外,在 Rust 中,我们不接受奇怪的排序问题。只要我们远离unsafe,编译器应该只允许我们编写健全的代码。这就是编译器阻止我们使用简单的运行时初始化的原因。

但是我可以通过使用None相当于空指针的来规避初始化吗?至少这都是符合 Rust 类型系统的。我当然可以将初始化移动到主函数的顶部,对吗?

static mut START_TIME: Option<String> = None;pub fn main() {
    START_TIME = Some(Utc::now().to_string());
    // ...}

啊,好吧,我们得到的错误是……

error[E0133]: use of mutable static is unsafe and requires unsafe function or block  --> src/main.rs:24:5
  |6 |     START_TIME = Some(Utc::now().to_string());
  |     ^^^^^^^^^^ use of mutable static
  |
  = note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior

在这一点上,我可以将它包装在一个unsafe{...}块中,它会起作用。有时,这是一种有效的策略。也许是为了测试代码的其余部分是否按预期工作。但这不是我想向您展示的惯用解决方案。因此,让我们探索编译器保证安全的解决方案。

重构示例

您可能已经注意到这个例子根本不需要全局变量。通常情况下,如果我们能想到一个没有全局变量的解决方案,我们应该避免它们。

这里的想法是将声明放在 main 函数中:

pub fn main() {
    let start_time = Utc::now().to_string();
    let thread_1 = std::thread::spawn(||{
        println!("Started {}, called thread 1 {}", &start_time, Utc::now());
    });
    let thread_2 = std::thread::spawn(||{
        println!("Started {}, called thread 2 {}", &start_time, Utc::now());
    });
    // Join threads and panic on error to show what went wrong
    thread_1.join().unwrap();
    thread_2.join().unwrap();}

唯一的问题是借用检查器:

error[E0373]: closure may outlive the current function, but it borrows `start_time`, which is owned by the current function  --> src/main.rs:42:39
   |42 |     let thread_1 = std::thread::spawn(||{
   |                                       ^^ may outlive borrowed value `start_time`43 |         println!("Started {}, called thread 1 {}", &start_time, Utc::now());
   |                                                     ---------- `start_time` is borrowed here   |note: function requires argument type to outlive `'static`

这个错误并不明显。编译器告诉我们,产生的线程可能比 value 存活的时间长start_time,它位于 main 函数的堆栈帧中。

从技术上讲,我们可以看到这是不可能的。线程被加入,因此主线程不会在子线程完成之前退出。

但是编译器不够聪明,无法找出这种特殊情况。通常,当产生一个新线程时,提供的闭包只能借用具有静态生命周期的项目。换句话说,借用的值必须在整个程序生命周期内都有效。

对于任何刚刚学习 Rust 的人来说,这可能是您想要接触全局变量的地方。但至少有两种解决方案比这更容易。最简单的方法是克隆字符串值,然后将字符串的所有权移动到闭包中。当然,这需要额外的分配和一些额外的内存。但在这种情况下,它只是一个短字符串,对性能没有任何影响。

但是,如果要共享的对象要大得多呢?如果您不想克隆它,请将其包装在引用计数智能指针后面。Rc是单线程引用计数类型。Arc是原子版本,可以安全地在线程之间共享值。

所以,为了满足编译器,我们可以使用Arc如下:

/* Final Solution */pub fn main() {
    let start_time = Arc::new(Utc::now().to_string());
    // This clones the Arc pointer, not the String behind it
    let cloned_start_time = start_time.clone();
    let thread_1 = std::thread::spawn(move ||{
        println!("Started {}, called thread 1 {}", cloned_start_time, Utc::now());
    });
    let thread_2 = std::thread::spawn(move ||{
        println!("Started {}, called thread 2 {}", start_time, Utc::now());
    });
    // Join threads and panic on error to show what went wrong
    thread_1.join().unwrap();
    thread_2.join().unwrap();}

这是关于如何在线程之间共享状态同时避免全局变量的快速概述。除了到目前为止我向您展示的内容之外,您可能还需要内部可变性来修改共享状态。内部可变性的全面覆盖超出了本文的范围。但在这个特定的例子中,我会选择Arc<Mutex<String>>将线程安全的内部可变性添加到start_time.

在编译时已知全局变量值时

根据我的经验,全局状态最常见的用例不是变量而是常量。在 Rust 中,它们有两种风格:

  • 常量值,用 定义const。这些由编译器内联。内部可变性是不允许的。

  • 静态变量,用static. 它们在数据段中接收一个固定的空间。内部可变性是可能的。

它们都可以用编译时常量初始化。这些可以是简单的值,例如42"hello world"。或者它可能是一个涉及其他几个编译时常量和标记为 的函数的表达式const。只要我们避免循环依赖。(您可以在The Rust Reference 中找到有关常量表达式的更多详细信息。)

use std::sync::atomic::AtomicU64;use std::sync::{Arc,Mutex};static COUNTER: AtomicU64 = AtomicU64::new(TI_BYTE);const GI_BYTE: u64 = 1024 * 1024 * 1024;const TI_BYTE: u64 = 1024 * GI_BYTE;

通常,const是更好的选择——除非你需要内部可变性,或者你特别想避免内联。

如果您需要内部可变性,有几种选择。对于大多数原语,std::sync::atomic 中有一个相应的原子变体可用。它们提供了一个干净的 API 来自动加载、存储和更新值。

在没有原子的情况下,通常的选择是锁。Rust 的标准库提供了读写锁( RwLock) 和互斥锁( Mutex)。

但是,如果您需要在运行时计算值,或者需要堆分配,则conststatic没有帮助。

Rust 中带有运行时初始化的单线程全局变量

我编写的大多数应用程序只有一个线程。在这种情况下,不需要锁定机制。

但是,我们不应该static mut直接使用并将访问包装在 中unsafe,因为只有一个线程。这样,我们最终可能会出现严重的内存损坏。

例如,从全局变量中不安全地借用可能会同时给我们多个可变引用。然后我们可以使用它们中的一个来迭代一个向量,另一个来从同一个向量中删除值。然后迭代器可以超出有效的内存边界,安全 Rust 可以防止潜在的崩溃。

但是标准库有一种方法可以“全局”存储值,以便在单个线程内进行安全访问。我说的是线程本地。在存在多个线程的情况下,每个线程都会获得一个独立的变量副本。但在我们的例子中,只有一个线程,只有一个副本。

线程局部变量是用thread_local!宏创建的。访问它们需要使用闭包,如以下示例所示:

use chrono::Utc;thread_local!(static GLOBAL_DATA: String = Utc::now().to_string());fn main() {
    GLOBAL_DATA.with(|text| {
        println!("{}", *text);
    });}

这不是所有解决方案中最简单的。但它允许我们执行任意初始化代码,这些代码将在第一次访问值时及时运行。

线程局部变量在内部可变性方面非常出色。与所有其他解决方案不同,它不需要Sync。这允许使用RefCell进行内部可变性,从而避免了Mutex的锁定开销。

线程局部变量的绝对性能高度依赖于平台。但是我在自己的 PC 上做了一些快速测试,将它与依赖锁的内部可变性进行比较,发现它快了 10 倍。我不希望结果会在任何平台上翻转,但如果您非常关心性能,请确保运行您自己的基准测试。

这是如何使用RefCell内部可变性的示例:

thread_local!(static GLOBAL_DATA: RefCell<String> = RefCell::new(Utc::now().to_string()));fn main() {
    GLOBAL_DATA.with(|text| {
        println!("Global string is {}", *text.borrow());
    });
    GLOBAL_DATA.with(|text| {
        *text.borrow_mut() = Utc::now().to_string();
    });
    GLOBAL_DATA.with(|text| {
        println!("Global string is {}", *text.borrow());
    });}

附带说明一下,即使 WebAssembly 中的线程与 x86_64 平台上的线程不同,这种带thread_local!+ 的模式RefCell在编译 Rust 以在浏览器中运行时也适用。在这种情况下,使用对多线程代码安全的方法将是矫枉过正。

关于线程局部变量的一个警告是它们的实现取决于平台。通常,您不会注意到这一点,但请注意,因此删除语义是平台相关的。

尽管如此,多线程全局变量的解决方案显然也适用于单线程情况。没有内部可变性,这些似乎和线程局部变量一样快。

那么接下来让我们来看看。

带运行时初始化的多线程全局变量

对于具有运行时初始化的安全全局变量,标准库目前没有很好的解决方案。但是,使用std::sync::Once unsafe,如果您知道自己在做什么,则可以构建安全使用的东西。

官方文档中的示例[https://doc.rust-lang.org/std/sync/struct.Once.html#examples-1]是一个很好的起点。如果您还需要内部可变性,则必须将该方法与读写锁或互斥锁相结合。这可能是这样的:

static mut STD_ONCE_COUNTER: Option<Mutex<String>> = None;static INIT: Once = Once::new();fn global_string<'a>() -> &'a Mutex<String> {
    INIT.call_once(|| {
        // Since this access is inside a call_once, before any other accesses, it is safe
        unsafe {
            *STD_ONCE_COUNTER.borrow_mut() = Some(Mutex::new(Utc::now().to_string()));
        }
    });
    // As long as this function is the only place with access to the static variable,
    // giving out a read-only borrow here is safe because it is guaranteed no more mutable
    // references will exist at this point or in the future.
    unsafe { STD_ONCE_COUNTER.as_ref().unwrap() }}pub fn main() {
    println!("Global string is {}", *global_string().lock().unwrap());
    *global_string().lock().unwrap() = Utc::now().to_string();
    println!("Global string is {}", *global_string().lock().unwrap());}

如果您正在寻找更简单的东西,我强烈推荐两个板条箱中的一个,我将在下一节中讨论。

在 Rust 中管理全局变量的外部库

基于流行度和个人品味,我想推荐两个我认为是 Rust 中简单全局变量的最佳选择的库,截至 2021 年。

一旦 Cell目前被考虑用于标准库。(请参阅此跟踪问题[https://github.com/rust-lang/rust/issues/74465]。)如果您使用的是夜间编译器,您已经可以通过添加#![feature(once_cell)]到项目的main.rs.

这是once_cell在稳定编译器上使用的示例,具有额外的依赖项:

use once_cell::sync::Lazy;static GLOBAL_DATA: Lazy<String> = Lazy::new(||Utc::now().to_string());fn main() {
    println!("{}", *GLOBAL_DATA);}

最后,还有Lazy Static,它是目前最流行的用于初始化全局变量的 crate。它使用带有小语法扩展 ( static ref)的宏来定义全局变量。

这里又是同一个例子,从once_cellto翻译过来lazy_static

#[macro_use]extern crate lazy_static;lazy_static!(
    static ref GLOBAL_DATA: String = Utc::now().to_string(););fn main() {
    println!("{}", *GLOBAL_DATA);}

once_cell和之间的决定lazy_static基本上归结为您更喜欢哪种语法。
此外,两者都支持内部可变性。只需将 包裹String在 aMutex或 中RwLock

结论

这些都是我所知道的在 Rust 中实现全局变量的所有(明智的)方法。我希望它更简单。但是全局状态本质上是复杂的。结合 Rust 的内存安全保证,一个简单的包罗万象的解决方案似乎是不可能的。但我希望这篇文章能帮助您了解过多的可用选项。

一般来说,Rust 社区倾向于为用户提供最大的权力——这使得事情变得更加复杂。

您的支持是我们创作的动力!
温馨提示:本文作者系Terry ,经Web前端之家编辑修改或补充,转载请注明出处和本文链接:
https://jiangweishan.com/article/js20210804a3.html

网友评论文明上网理性发言 已有0人参与

发表评论: