用Option<…>作为静态变量来存储单例对象的原始全局指针，用get_or_insert_with方法来初始化单例对象
    最严谨的方法是用 Arc> 或者Arc>来持有单例对象；如果不需要单例对象的可变引用，直接用Arc即可；如果是单线程程序，Arc可以可用Rc替代

    1. use std::sync::Arc;
    2. use std::sync::Mutex;
    4. struct Point {
    5.     pub x: u32,
    6.     pub y: u32,
    7. }
    9. impl Point {
    10.     pub fn get_instance() -> Arc<Mutex<Point>> {
    11.         // 全局变量作为Option类型，get_or_insert_with在判断自己是否为None时，
    12.         // 也可能有多线程竞争的问题，最安全的方法是给Option也套一个锁。
    13.         // 可以使用第三方库once_cell实现更简单的写法
    14.         static mut POINT: Option<Arc<Mutex<Point>>> = None;
    15.         unsafe {
    16.             // Rust中使用可变静态变量都是unsafe的
    17.             POINT.get_or_insert_with(|| {
    18.                 // 初始化单例对象的代码
    19.                 Arc::new(Mutex::new(Point {x: 0, y: 0}))
    20.             }).clone()
    21.         }
    22.     }
    23. }

    once_cell提供了unsync::OnceCell和sync::OnceCell这两种Cell（字面意思，前者用于单线程，后者用于多线程），用来存储堆上的信息，并且具有最多只能赋值一次的特性

    1. use std::{env, io};
    3. use once_cell::sync::OnceCell;
    5. #[derive(Debug)]
    6. pub struct Logger {
    7.     // ...
    8. }
    9. static INSTANCE: OnceCell<Logger> = OnceCell::new();
    11. impl Logger {
    12.     pub fn global() -> &'static Logger {
    13.         INSTANCE.get().expect("logger is not initialized")
    14.     }
    16.     fn from_cli(args: env::Args) -> Result<Logger, std::io::Error> {
    17.        // ...
    18.     }
    19. }
    21. fn main() {
    22.     let logger = Logger::from_cli(env::args()).unwrap();
    23.     INSTANCE.set(logger).unwrap();
    24.     // 之后就统一使用`Logger::global()`
    25. }

    延迟创建方式

    1. use std::{sync::Mutex, collections::HashMap};
    2. use once_cell::sync::Lazy;
    4. static GLOBAL_DATA: Lazy<Mutex<HashMap<i32, String>>> = Lazy::new(|| {
    5.     let mut m = HashMap::new();
    6.     m.insert(13, "Spica".to_string());
    7.     m.insert(74, "Hoyten".to_string());
    8.     Mutex::new(m)
    9. });
    11. fn main() {
    12.     println!("{:?}", GLOBAL_DATA.lock().unwrap());
    13. }