What is the best way to create and use a struct with only one instantiation in the system? Yes, this is necessary, it is the OpenGL subsystem, and making multiple copies of this and passing it around everywhere would add confusion, rather than relieve it.

在系统中只有一个实例化的情况下创建和使用结构的最佳方式是什么？是的，这是必要的，它是OpenGL子系统，制作多个副本并到处传递它会增加混乱，而不是减轻它。

The singleton needs to be as efficient as possible. It doesn't seem possible to store an arbitrary object on the static area, as it contains a Vec with a destructor. The second option is to store an (unsafe) pointer on the static area, pointing to a heap allocated singleton. What is the most convenient and safest way to do this, while keeping syntax terse?

单身人士需要尽可能地高效。似乎不可能在静态区域中存储任意对象，因为它包含带有析构函数的VEC。第二种选择是在静态区域上存储一个(不安全的)指针，该指针指向分配了单例的堆。要做到这一点，同时保持语法简洁，最方便、最安全的方法是什么？

优秀答案推荐

Non-answer answer

Avoid global state in general. Instead, construct the object somewhere early (perhaps in main), then pass mutable references to that object into the places that need it. This will usually make your code easier to reason about and doesn't require as much bending over backwards.

总体上避免全球状态。相反，在早期构造对象(可能在Main中)，然后将对该对象的可变引用传递到需要它的位置。这通常会使您的代码更容易推理，并且不需要太多的后退。

Look hard at yourself in the mirror before deciding that you want global mutable variables. There are rare cases where it's useful, so that's why it's worth knowing how to do.

在决定需要全局可变变量之前，请仔细看看镜子中的自己。在极少数情况下，它是有用的，所以这就是为什么它值得知道如何做的原因。

Still want to make one...?

还想做一个吗...？

Tips

In the following solutions:

在以下解决方案中：

• If you remove the Mutex then you have a global singleton without any mutability.


• You can also use a RwLock instead of a Mutex to allow multiple concurrent readers.

Using lazy-static

The lazy-static crate can take away some of the drudgery of manually creating a singleton. Here is a global mutable vector:

懒惰的静态板条箱可以省去一些手动创建单件对象的繁琐工作。下面是一个全局可变向量：

use lazy_static::lazy_static; // 1.4.0
use std::sync::Mutex;

lazy_static! {
    static ref ARRAY: Mutex<Vec<u8>> = Mutex::new(vec![]);
}

fn do_a_call() {
    ARRAY.lock().unwrap().push(1);
}

fn main() {
    do_a_call();
    do_a_call();
    do_a_call();

    println!("called {}", ARRAY.lock().unwrap().len());
}

Using once_cell

The once_cell crate can take away some of the drudgery of manually creating a singleton. Here is a global mutable vector:

Once_cell板条箱可以省去一些手工创建单例的繁琐工作。下面是一个全局可变向量：

use once_cell::sync::Lazy; // 1.3.1
use std::sync::Mutex;

static ARRAY: Lazy<Mutex<Vec<u8>>> = Lazy::new(|| Mutex::new(vec![]));

fn do_a_call() {
    ARRAY.lock().unwrap().push(1);
}

fn main() {
    do_a_call();
    do_a_call();
    do_a_call();

    println!("called {}", ARRAY.lock().unwrap().len());
}

Using std::sync::LazyLock

The standard library is in the process of adding once_cell's functionality, currently called LazyLock:

标准库正在添加once_cell的功能，目前名为LazyLock：

#![feature(once_cell)] // 1.67.0-nightly
use std::sync::{LazyLock, Mutex};

static ARRAY: LazyLock<Mutex<Vec<u8>>> = LazyLock::new(|| Mutex::new(vec![]));

fn do_a_call() {
    ARRAY.lock().unwrap().push(1);
}

fn main() {
    do_a_call();
    do_a_call();
    do_a_call();

    println!("called {}", ARRAY.lock().unwrap().len());
}

Using std::sync::OnceLock

LazyLock is still unstable, but OnceLock was stabilized as of Rust 1.70.0. You can use it to get dependency-free implementation on stable:

LazyLock仍然不稳定，但OnceLock在Rust 1.70.0版本中已经稳定下来。您可以使用它在STRISE上获得无依赖实现：

use std::sync::{OnceLock, Mutex};

fn array() -> &'static Mutex<Vec<u8>> {
    static ARRAY: OnceLock<Mutex<Vec<u8>>> = OnceLock::new();
    ARRAY.get_or_init(|| Mutex::new(vec![]))
}

fn do_a_call() {
    array().lock().unwrap().push(1);
}

fn main() {
    do_a_call();
    do_a_call();
    do_a_call();

    println!("called {}", array().lock().unwrap().len());
}

A special case: atomics

If you only need to track an integer value, you can directly use an atomic:

如果只需要跟踪整数值，可以直接使用原子：

use std::sync::atomic::{AtomicUsize, Ordering};

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

fn do_a_call() {
    CALL_COUNT.fetch_add(1, Ordering::SeqCst);
}

fn main() {
    do_a_call();
    do_a_call();
    do_a_call();

    println!("called {}", CALL_COUNT.load(Ordering::SeqCst));
}

Manual, dependency-free implementation

There are several existing implementation of statics, such as the Rust 1.0 implementation of stdin. This is the same idea adapted to modern Rust, such as the use of MaybeUninit to avoid allocations and unnecessary indirection. You should also look at the modern implementation of io::Lazy. I've commented inline with what each line does.

有几种现有的静态实现，例如标准输入的Rust 1.0实现。这是适用于现代Rust的相同思想，例如使用MaybeUninit来避免分配和不必要的间接。您还应该看看io：：Lazy的现代实现。我已经对每一行做了内联注释。

use std::sync::{Mutex, Once};
use std::time::Duration;
use std::{mem::MaybeUninit, thread};

struct SingletonReader {
    // Since we will be used in many threads, we need to protect
    // concurrent access
    inner: Mutex<u8>,
}

fn singleton() -> &'static SingletonReader {
    // Create an uninitialized static
    static mut SINGLETON: MaybeUninit<SingletonReader> = MaybeUninit::uninit();
    static ONCE: Once = Once::new();

    unsafe {
        ONCE.call_once(|| {
            // Make it
            let singleton = SingletonReader {
                inner: Mutex::new(0),
            };
            // Store it to the static var, i.e. initialize it
            SINGLETON.write(singleton);
        });

        // Now we give out a shared reference to the data, which is safe to use
        // concurrently.
        SINGLETON.assume_init_ref()
    }
}

fn main() {
    // Let's use the singleton in a few threads
    let threads: Vec<_> = (0..10)
        .map(|i| {
            thread::spawn(move || {
                thread::sleep(Duration::from_millis(i * 10));
                let s = singleton();
                let mut data = s.inner.lock().unwrap();
                *data = i as u8;
            })
        })
        .collect();

    // And let's check the singleton every so often
    for _ in 0u8..20 {
        thread::sleep(Duration::from_millis(5));

        let s = singleton();
        let data = s.inner.lock().unwrap();
        println!("It is: {}", *data);
    }

    for thread in threads.into_iter() {
        thread.join().unwrap();
    }
}

This prints out:

这将打印出来：

It is: 0
It is: 1
It is: 1
It is: 2
It is: 2
It is: 3
It is: 3
It is: 4
It is: 4
It is: 5
It is: 5
It is: 6
It is: 6
It is: 7
It is: 7
It is: 8
It is: 8
It is: 9
It is: 9
It is: 9

This code compiles with Rust 1.55.0.

此代码使用Rust 1.55.0进行编译。

All of this work is what lazy-static or once_cell do for you.

所有这些工作都是Lazy-Static或Once_cell为您做的。

The meaning of "global"

Please note that you can still use normal Rust scoping and module-level privacy to control access to a static or lazy_static variable. This means that you can declare it in a module or even inside of a function and it won't be accessible outside of that module / function. This is good for controlling access:

请注意，您仍然可以使用普通的Rust作用域和模块级别的隐私来控制对静态变量或LAZY_STATIC变量的访问。这意味着您可以在模块中或甚至在函数内部声明它，并且它将不能在该模块/函数外部访问。这对控制访问很有好处：

use lazy_static::lazy_static; // 1.2.0

fn only_here() {
    lazy_static! {
        static ref NAME: String = String::from("hello, world!");
    }
    
    println!("{}", &*NAME);
}

fn not_here() {
    println!("{}", &*NAME);
}

error[E0425]: cannot find value `NAME` in this scope
  --> src/lib.rs:12:22
   |
12 |     println!("{}", &*NAME);
   |                      ^^^^ not found in this scope

However, the variable is still global in that there's one instance of it that exists across the entire program.

但是，该变量仍然是全局的，因为它的一个实例存在于整个程序中。

Starting with Rust 1.63, it can be easier to work with global mutable singletons, although it's still preferable to avoid global variables in most cases.

从Rust 1.63开始，可以更容易地使用全局可变单例，尽管在大多数情况下避免全局变量仍然是可取的。

Now that Mutex::new is const, you can use global static Mutex locks without needing lazy initialization:

既然Mutex：：New是常量，您就可以使用全局静态Mutex锁，而无需延迟初始化：

use std::sync::Mutex;

static GLOBAL_DATA: Mutex<Vec<i32>> = Mutex::new(Vec::new());

fn main() {
    GLOBAL_DATA.lock().unwrap().push(42);
    println!("{:?}", GLOBAL_DATA.lock().unwrap());
}

Note that this also depends on the fact that Vec::new is const. If you need to use non-const functions to set up your singleton, you could wrap your data in an Option, and initially set it to None. This lets you use data structures like Hashset which currently cannot be used in a const context:

请注意，这还取决于VEC：：New是常量这一事实。如果您需要使用非常量函数来设置Singleton，您可以将数据包装在一个选项中，并将其初始设置为None。这允许您使用当前不能在常量上下文中使用的数据结构，如Hashset：

use std::sync::Mutex;
use std::collections::HashSet;

static GLOBAL_DATA: Mutex<Option<HashSet<i32>>> = Mutex::new(None);

fn main() {
    *GLOBAL_DATA.lock().unwrap() = Some(HashSet::from([42]));
    println!("V2: {:?}", GLOBAL_DATA.lock().unwrap());
}

Alternatively, you could use an RwLock, instead of a Mutex, since RwLock::new is also const as of Rust 1.63. This would make it possible to read the data from multiple threads simultaneously.

或者，您也可以使用RavLock，而不是Mutex，因为Rust 1.63版本中的RavLock：：New也是常量。这将使从多个线程同时读取数据成为可能。

If you need to initialize with non-const functions and you'd prefer not to use an Option, you could use a crate like once_cell or lazy-static for lazy initialization as explained in Shepmaster's answer.

如果您需要使用非常数函数进行初始化，并且您不希望使用选项，则可以使用像once_cell或lazy-static这样的板条箱来进行延迟初始化，如谢普马斯特的回答所解释的那样。

From What Not To Do In Rust

在Rust中不能做的事情

To recap: instead of using interior mutability where an object changes
its internal state, consider using a pattern where you promote new
state to be current and current consumers of the old state will
continue to hold on to it by putting an Arc into an RwLock.

use std::sync::{Arc, RwLock};

#[derive(Default)]
struct Config {
    pub debug_mode: bool,
}

impl Config {
    pub fn current() -> Arc<Config> {
        CURRENT_CONFIG.with(|c| c.read().unwrap().clone())
    }
    pub fn make_current(self) {
        CURRENT_CONFIG.with(|c| *c.write().unwrap() = Arc::new(self))
    }
}

thread_local! {
    static CURRENT_CONFIG: RwLock<Arc<Config>> = RwLock::new(Default::default());
}

fn main() {
    Config { debug_mode: true }.make_current();
    if Config::current().debug_mode {
        // do something
    }
}

If you are on nightly, you can use LazyLock.

如果你是晚上开机，你可以使用LazyLock。

It more or less does what the crates once_cell and lazy_sync do. Those two crates are very common, so there's a good chance they might already by in your Cargo.lock dependency tree. But if you prefer to be a bit more "adventurous" and go with LazyLock, be prepered that it (as everything in nightly) might be a subject to change before it gets to stable.

它或多或少完成了板条箱Once_cell和lazy_sync所做的工作。这两个箱子非常常见，因此它们很可能已经存在于您的Cargo.lock依赖关系树中。但是，如果你更喜欢“冒险”一点，选择LazyLock，那么请注意，在它稳定之前，它(就像晚上的一切一样)可能会发生变化。

(Note: Up until recently std::sync::LazyLock used to be named std::lazy::SyncLazy but was recently renamed.)

(注意：直到最近，Std：：Sync：：LazyLock还被命名为Std：：Lazy：：SyncLazy，但最近被重新命名。)

Use SpinLock for global access.

使用自旋锁进行全局访问。

#[derive(Default)]
struct ThreadRegistry {
    pub enabled_for_new_threads: bool,
    threads: Option<HashMap<u32, *const Tls>>,
}

impl ThreadRegistry {
    fn threads(&mut self) -> &mut HashMap<u32, *const Tls> {
        self.threads.get_or_insert_with(HashMap::new)
    }
}

static THREAD_REGISTRY: SpinLock<ThreadRegistry> = SpinLock::new(Default::default());

fn func_1() {
    let thread_registry = THREAD_REGISTRY.lock();  // Immutable access
    if thread_registry.enabled_for_new_threads {
    }
}

fn func_2() {
    let mut thread_registry = THREAD_REGISTRY.lock();  // Mutable access
    thread_registry.threads().insert(
        // ...
    );
}

If you want mutable state(NOT Singleton), see What Not to Do in Rust for more descriptions.

如果您想要可变状态(而不是Singleton)，请参阅在Rust中不能做什么以获得更多描述。

Hope it's helpful.

希望能对你有所帮助。

A bit late to the party, but here's how I worked around this issue (rust 1.66-nightly):

参加派对有点晚了，但以下是我如何解决这个问题的方法(铁锈1.66-每晚)：

#![feature(const_size_of_val)]
#![feature(const_ptr_write)]

static mut GLOBAL_LAZY_MUT: StructThatIsNotSyncNorSend = unsafe {
    // Copied from MaybeUninit::zeroed() with minor modifications, see below
    let mut u = MaybeUninit::uninit();

    let bytes = mem::size_of_val(&u);
    write_bytes(u.as_ptr() as *const u8 as *mut u8, 0xA5, bytes); //Trick the compiler check that verifies pointers and references are not null.

    u.assume_init()
};

(...)

fn main() {
    unsafe {
        let mut v = StructThatIsNotSyncNorSend::new();
        mem::swap(&mut GLOBAL_LAZY_MUT, &mut v);
        mem::forget(v);
    }
  
}

Beware that this code is unbelievably unsafe, and can easily end up being UB if not handled correctly.

请注意，此代码非常不安全，如果处理不当，很容易导致UB。

You now have a !Send !Sync value as a global static, without the protection of a Mutex. If you access it from multiple threads, even if just for reading, it's UB. If you don't initialize it the way shown, it's UB, because it calls Drop on an actually unitialized value.

现在，您拥有了一个！Send！Sync值作为全局静态变量，而不需要互斥体的保护。如果您从多个线程访问它，即使只是为了读取，它也是UB。如果您没有按照所示的方式对它进行初始化，那么它就是UB，因为它在一个实际的单元化值上调用Drop。

You just convinced the rust compiler that something that is UB is not UB. You just convinced that putting a !Sync and !Send in a global static is fine.

您刚刚说服了铁锈编译器，UB不是UB。您刚刚确信放入一个！Sync和！Send in一个全局静态变量是可以的。

If unsure, don't use this snippet.

如果不确定，请不要使用此代码段。

Besides the 3rd-party crates, the alternative is to wrap your custom type (e.g. struct) within std::sync::Mutex.

除了第三方板条箱，另一种方法是将您的自定义类型(例如，struct)包装在std：：sync：：Mutex中。

• The Mutex protects the instance of the custom type in concurrent accesses of multi-threading usage scenario


• The caller successfully getting the lock from Mutex can modify the content of the custom type.

Here's the code example :

以下是代码示例：

use std::sync::Mutex;

#[derive(Debug)]
struct Rectangle {
    width :u16,
    height:u16,
}

static GLOBAL_COUNTER_2: Mutex<Rectangle> = 
    Mutex::new(
        Rectangle{width:100u16, height:125u16}
    );

fn  global_var_demo()
{
    if let Ok(mut value) = GLOBAL_COUNTER_2.lock() {
        value.width += 7;
        value.height = value.height >> 1;
    }
    if let Ok(value) = GLOBAL_COUNTER_2.lock() {
        // request the reference without moving the ownership
        assert_eq!(value.width, 107u16);
        println!("new value in GLOBAL_COUNTER_2: {:?}", value);
    }
}

My limited solution is to define a struct instead of a global mutable one. To use that struct, external code needs to call init() but we disallow calling init() more than once by using an AtomicBoolean (for multithreading usage).

我有限的解决方案是定义一个结构体，而不是一个全局可变结构体。要使用该结构体，外部代码需要调用init（），但我们不允许通过使用AtomicBoolean（用于多线程）多次调用init（）。

static INITIATED: AtomicBool = AtomicBool::new(false);

struct Singleton {
  ...
}

impl Singleton {
  pub fn init() -> Self {
    if INITIATED.load(Ordering::Relaxed) {
      panic!("Cannot initiate more than once")
    } else {
      INITIATED.store(true, Ordering::Relaxed);

      Singleton {
        ...
      }
    }
  }
}

fn main() {
  let singleton = Singleton::init();
  
  // panic here
  // let another_one = Singleton::init();
  ...
}