advance/global-variable

[giscus[bot]]

advance/global-variable

https://course.rs/advance/global-variable.html

[zd08135]

lazy_static 就是语言设计的bug，居然是靠社区处理的。

[LoserJL]

这个语言就是一个蹩脚的产物

[mztlive]

我倒是一直想问， 既然全局变量那么多问题，而且Rust也不推荐使用。 那是有什么方案可以做到变量既不用全局，也可以全局使用的。

比如说: fn main 里面创建，然后一层层的传递到其他函数去? 最后随着main函数的结束而结束？

[AuTsing]

是因为他是全局，所以才那么多问题，变量不全局，那怎么全局使用呢？你上面说的 main 里面创建，然后一层层传递给其他函数去，那都是针对单线程而言的，多线程编程呢？还能这么玩吗？那安全性就无法保证了。

[small-white0-0]

main中的局部变量，非要多线程共享的话，可以使用智能指针Arc吧。

不过在main里面定义一个局部变量结合共享指针和使用全局变量，个人感觉两者是半斤八两吧。

个人理解：
全局变量最大的问题就是全局都可以访问一个变量，导致任何涉及该变量的函数输出会受到外部状态的影响，更难以测试，bug更难以发现和修复。
而使用main的局部变量，使用参数传入，一定程度上可以解决函数输入不能完全决定输出的问题，但是与此带来的问题就是如果是一个嵌套很深的函数需要这个变量，中间函数都不需要这个变量，那么这个参数传递成本就很高了。如果是多线程使用Arc, 还需要封装，参数传递成本更高了。

只能说，按需使用。就如 unsafe 一样，真正需要的时候，就直接使用。毕竟提供这个功能肯定是因为有这个确切的需要，存在只能这么做的情况。:)

[sunfu12]

我运行“标准库中的 OnceCell”代码失败了，提示：

Compiling test_rust v0.1.0 (/myproject/test_rust)
error[E0554]: #![feature] may not be used on the stable release channel
--> src/main.rs:1:12
|
1 | #![feature(once_cell)]
| ^^^^^^^^^

For more information about this error, try rustc --explain E0554.

这是为什么呢？怎么解决？

[xianfuxing]

rust nightly 版才支持

[bvhcr]

全局ID生成器 这个例子在atomic加载、累加的步骤 是不是用SeqCst更好？

[tjw123hh]

没用多线程应该没关系

[cctga]

单个 Atomic 对象操作不需要关心内存顺序，内存顺序是多个对象时才需要考虑的

[yuhaya]

1.63版新增关于全局静态变量的特性可以完全替代lazy_static了

[ADkun]

https://blog.rust-lang.org/2022/08/11/Rust-1.63.0.html#const-mutex-rwlock-condvar-initialization

[cxw620]

多线程共享的要用 Arc 包裹吗

[Jevon617]

还是无法通过函数创建全局变量吧

[lnb-wxqy]

fn generate_id()->usize{
// 检查两次溢出，否则直接加一可能导致溢出
let current_val = GLOBAL_ID_COUNTER.load(Ordering::Relaxed);
if current_val > MAX_ID{
panic!("Factory ids overflowed");
}
let next_id = GLOBAL_ID_COUNTER.fetch_add(1, Ordering::Relaxed);
if next_id > MAX_ID{
panic!("Factory ids overflowed");
}
next_id
}

这个代码有点问题，fetch_add 方法返回的是前值，current_val 和next_id的值是一样的。应该是在fetch_add之后再通过load方法获取值后返回：
...
GLOBAL_ID_COUNTER.fetch_add(1, Ordering::Relaxed);
let next_id = GLOBAL_ID_COUNTER.load(Ordering::Relaxed);

[iamtaojin]

取得current_val 是为了验证当前值是否已经溢出
fetch_add 就是获取当前值并加1操作了

[lnb-wxqy]

lazy_static! 宏和Box::new 更推荐使用哪个呢？why？

[mattwhatsup]

太好了，本章节没有扩充前就读完了，我真是个大聪明。。😂

[guorui22]

使用标准库中的 std::sync::Once
在 Rust 标准库中提供 std::sync::Once ，是一个多线程安全的类型，可以用于确保在多线程环境中代码仅运行一次。使用std::sync::Once的方法如下：
1. 创建一个std::sync::Once类型的变量，并初始化为std::sync::Once::new()。
2. 使用call_once方法调用代码，确保它只运行一次。
use std::sync::Once;
use std::thread;

static INIT: Once = Once::new();
static mut LOGGER: Option = None;

struct Logger;

impl Logger {
fn new() -> Logger {
Logger {}
}
fn log(&self, message: String) {
println!("{}", message)
}
}

fn initialize_logger() {
unsafe {
LOGGER = Some(Logger::new());
println!("初始化一次！！！")
}
}

fn get_logger() -> &'static Logger {
INIT.call_once(|| initialize_logger());
unsafe {
LOGGER.as_ref().unwrap()
}
}

fn main() {
// 子线程中调用
let handle = thread::spawn(|| {
let logger = get_logger();
logger.log("thread message".to_string());
});

// 主线程调用
let logger = get_logger();
logger.log("some message".to_string());

let logger2 = get_logger();
logger2.log("other message".to_string());

handle.join().unwrap();

}
运行结果如下：
初始化一次！！！
some message
other message
thread message
可以看到，初始化一次！！！... 在多个线程中使用也只被打印了一次。

[yangkkkk]

越来越觉得rust在国内用不起来了

[zoloadang]

何以见得？

[Saltedf]

https://stackoverflow.com/questions/27791532/how-do-i-create-a-global-mutable-singleton

[iscas-zac]

现在 std::lazy 好像用不了了，最后一部分要改用 use once_cell::sync::OnceCell;

[zhwei820]

std once cell changed:

它被移到了std::cell（现在名为LazyCell）。
这发生在PR #98165 - once cell renamings中。

https://doc.rust-lang.org/core/cell/struct.LazyCell.html

#![feature(lazy_cell)]

use std::cell::LazyCell;

let lazy: LazyCell<i32> = LazyCell::new(|| {
    println!("initializing");
    92
});
println!("ready");
println!("{}", *lazy);
println!("{}", *lazy);

// Prints:
//   ready
//   initializing
//   92
//   92

[zhwei820]

use once_cell::sync::OnceCell; 用这个更好

[Xiaobaishushu25]

rust1.7版本标准库加入了OnceCell和OnceLock，可以取代lazy_static和once_cell等库，但是我遇到一个问题，我之前自己试着这样写没有报错,可以正常运行：

use std::cell::{OnceCell};
    #[derive(Debug)]
    struct Op{
        text:String,
    }
    impl Op {
        fn new()->Self{
            Op{
                text:"hello".to_string()
            }
        }
    }
    #[test]
    fn test_std_onceCell_static_op(){
        static mut cell:OnceCell<Op> = OnceCell::new();
        unsafe {
            cell.get_or_init(||{
                Op::new()
            });
            let option = cell.get();
            println!("{:?}",option);
            let handle = thread::spawn(|| {
                let option1 = cell.get_mut().unwrap();
                println!("{:?}", cell.get().unwrap());
            });
            handle.join().unwrap();
        }
    }

但是我这样写：

    #[test]
    fn test_error(){
        static CACHE: OnceCell<Vec<i32>> = OnceCell::new();
        fn get_data() -> &'static Vec<i32> {
            CACHE.get_or_init(|| {
                let data = vec![1, 2, 3, 4, 5];
                println!("Initializing cache");
                data
            })
        }
        let data = get_data();
        println!("Data: {:?}", data);

        let data = get_data();
        println!("Data: {:?}", data);
    }

在static CACHE: OnceCell<Vec> = OnceCell::new();这里就直接报错：error[E0277]: std::cell::OnceCell<Vec<i32>> cannot be shared between threads safely，说是因为the trait Sync is not implemented for std::cell::OnceCell<Vec<i32>>，于是我又验证了一下：

   use std::cell::{OnceCell};
    struct Op{
        text:String,
    }
    fn is_sync<T:Sync>(){}
    #[test]
    fn check_trait(){
        is_sync::<String>();
        is_sync::<Vec<i32>>();
        is_sync::<OnceCell<Op>>(); //error[E0277]: `std::cell::OnceCell<check_trait::Op>` cannot be shared between threads safely
        // is_sync::<OnceCell<String>>();
        // is_sync::<OnceCell<Vec<i32>>>();
    }

发现这里is_sync::<OnceCell>();也报错了，说明OnceCell与OnceCell<Vec>一样都没有实现Sync特征，那为什么第一段代码可以正常运行呢？希望有大佬解答我的疑惑

[small-white0-0]

@Xiaobaishushu25
你的第一段代码把static mut cell:OnceCell<Op> = OnceCell::new();去掉mut,也会报错的。
static 要求类型要实现sync, static mut 则没有这个要求。

因为全局变量基本意味着一定被多线程争抢。static 对于简单类型的变量来说，就是只读的，那么肯定是线程安全的；对于复杂类型变量，考虑有内部可变性的存在，就要通过Sync来告诉编译器自己是否保证了线程安全，对于RefCell这种就可以通过Sync去排除。而static mut 则是没有阻止不安全行为的能力，被认为是unsafe的，自然也就没有必要检查是否实现Sync了。

两者的区别可以看看参考手册。
https://doc.rust-lang.org/reference/items/static-items.html

[Xiaobaishushu25]

明白了，非常感谢大佬解惑。

[duanyuluo]

最后这个例子中，Logger::log()方法，不是线程安全的吧？应该会出现一条log msg被中断的可能性。

[yansq]

常量可以在任意作用域进行定义，其生命周期贯穿整个程序的生命周期。编译时编译器会尽可能将其内联到代码中，所以在不同地方对同一常量的引用并不能保证引用到相同的内存地址

请问“编译器会尽可能将其内联到代码中”应该如何理解？

[cctga]

嗯，我觉得是两方面，一方面是表达式会先计算出结果，另一方面是会把所以常量都收集，然后大家一起使用
一个🌰：

fn main() {
    let a = 1;
    let b = a;
    const c: i32 = 1;
    const d: i32 = c;
    
    println!("a: {:p}", &a);
    println!("b: {:p}", &b);
    println!("c: {:p}", &c);
    println!("d: {:p}", &d);
}

这里的 i32 会使用 Copy trait，但是检查 c 和 d 的地址你会发现它们是一样的

[tjw123hh]

OnceCell和OnceLock（即文中的SyncOnceCell）已在1.70.0转为稳定

[ftanda-go]

这鬼东西设计的这么复杂

[upWooStream]

这语言越搞越复杂，一堆三方库给填坑，到底是还是一堆基础特性都不稳定，其他语言最基本的一些东西都得整花活儿。

[guorui22]

需要

…

------------------&nbsp;原始邮件&nbsp;------------------ 发件人: ***@***.***&gt;; 发送时间: 2023年11月2日(星期四) 上午10:40 收件人: ***@***.***&gt;; 抄送: ***@***.***&gt;; ***@***.***&gt;; 主题: Re: [sunface/rust-course] advance/global-variable (Discussion #728) 多线程共享的要用 Arc 包裹吗 — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***&gt;

[guorui22]

需要

…

------------------ 原始邮件 ------------------ 发件人: ***@***.***&gt;; 发送时间: 2023年11月2日(星期四) 上午10:40 收件人: ***@***.***&gt;; 抄送: ***@***.***&gt;; ***@***.***&gt;; 主题: Re: [sunface/rust-course] advance/global-variable (Discussion #728) 多线程共享的要用 Arc 包裹吗 — Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you commented.Message ID: ***@***.***&gt;

[shenghui0779]

Axum中，数据库(连接池)实例，用 State 共享，还是 OnceCell ？

[yuhaya]

Onecell放全局，业务稍微复杂点用state会导致方法参数混乱不够简洁，重构起来也麻烦

[shenghui0779]

有道理

[cxw620]

OnceLock / LazyLock 放全局, 套一层 Arc 或者 ArcSwap

[jinmingzhuo]

官方教程的Object-Oriented Programming Features of Rust这章没有吗？

[lzh-marble]

版本1.80+标准库有解决方案了std::sync::LazyLock，可以替代lazy_static

use std::sync::LazyLock;

// n.b. static items do not call [`Drop`] on program termination, so this won't be deallocated.
// this is fine, as the OS can deallocate the terminated program faster than we can free memory
// but tools like valgrind might report "memory leaks" as it isn't obvious this is intentional.
static DEEP_THOUGHT: LazyLock<String> = LazyLock::new(|| {
    // M3 Ultra takes about 16 million years in --release config
    another_crate::great_question()
});

// The `String` is built, stored in the `LazyLock`, and returned as `&String`.
let _ = &*DEEP_THOUGHT;
// The `String` is retrieved from the `LazyLock` and returned as `&String`.
let _ = &*DEEP_THOUGHT;

[Xiaobaishushu25]

版本1.80+标准库有解决方案了std::sync::LazyLock。

use std::sync::LazyLock;

// n.b. static items do not call [`Drop`] on program termination, so this won't be deallocated.
// this is fine, as the OS can deallocate the terminated program faster than we can free memory
// but tools like valgrind might report "memory leaks" as it isn't obvious this is intentional.
static DEEP_THOUGHT: LazyLock<String> = LazyLock::new(|| {
    // M3 Ultra takes about 16 million years in --release config
    another_crate::great_question()
});

// The `String` is built, stored in the `LazyLock`, and returned as `&String`.
let _ = &*DEEP_THOUGHT;
// The `String` is retrieved from the `LazyLock` and returned as `&String`.
let _ = &*DEEP_THOUGHT;

LazyLock 和 OnceLock 有什么区别呢，我看好像都是延迟初始化的作用.

[lzh-marble]

LazyLock定义时就需要传入初始化方法，而OnceLock需要在函数或闭包中调用初始化方法。
LazyLock用起来比较简单方便。而OnceLock能满足更多场景，比如OnceLock在作为静态变量时可以获取函数内的局部变量，也可以根据条件的不同进行不同的初始化。

[binliexc]

我现在的版本是rustc 1.80.0，现在已经可以通过LazyLock和OnceLock设置静态变量了

[cctga]

和常量相同，定义静态变量的时候必须赋值为在编译期就可以计算出的值(常量表达式/数学表达式)，不能是运行时才能计算出的值(如函数)

以及下面的示例是不是矛盾了，这个 new 不就是函数嘛

static REQUEST_RECV: AtomicUsize  = AtomicUsize::new(0);