用Rust实现单例

1. 使用Arc + Mutex

在这个例子中，我们使用了 Arc （原子引用计数）和 Mutex （互斥锁）来实现线程安全的单例。通过 get_instance 方法，我们可以获取到单例实例，并对实例进行操作。

1. use std::sync::{Arc, Mutex};
3. struct Singleton {
4.     // 单例数据
5.     data: String,
6. }
8. impl Singleton {
9.     // 获取单例实例的方法
10.     fn get_instance() -> Arc<Mutex<Singleton>> {
11.         // 使用懒加载创建单例实例
12.         // 这里使用了 Arc 和 Mutex 来实现线程安全的单例
13.         // 只有第一次调用 get_instance 时会创建实例，之后都会返回已创建的实例
14.         static mut INSTANCE: Option>> = None;
15.         unsafe {
16.             INSTANCE
17.                 .get_or_insert_with(|| {
18.                     Arc::new(Mutex::new(Singleton {
19.                         data: String::from("Singleton instance"),
20.                     }))
21.                 })
22.                 .clone()
23.         }
24.     }
25. }
27. fn main() {
28.     // 获取单例实例
29.     let instance1 = Singleton::get_instance();
30.     let instance2 = Singleton::get_instance();
31.     // 修改单例数据
32.     {
33.         let mut instance = instance1.lock().unwrap();
34.         instance.data = String::from("Modified singleton instance");
35.     }
36.     // 输出单例数据
37.     {
38.         let instance = instance2.lock().unwrap();
39.         println!("{}", instance.data);
40.     }
41. }

复制代码

 
2. 使用lazy_static的懒加载

使用 lazy_static crate： lazy_static crate 是一个常用的 Rust crate，可以实现懒加载的全局静态变量。通过 lazy_static ，可以在需要时创建单例实例，并确保只有一个实例被创建：

1. use lazy_static::lazy_static;
2.    use std::sync::Mutex;
3.     struct Singleton {
4.        // 单例数据
5.        data: String,
6.    }
7.     lazy_static! {
8.        static ref INSTANCE: Mutex<Singleton> = Mutex::new(Singleton {
9.            data: String::from("Singleton instance"),
10.        });
11.    }
12.     fn main() {
13.        // 获取单例实例
14.        let instance = INSTANCE.lock().unwrap();
15.        println!("{}", instance.data);
16.    }

复制代码

3. 使用once_cell crate

使用 once_cell crate： once_cell crate 是另一个常用的 Rust crate，可以实现懒加载的全局静态变量。通过 once_cell ，可以在首次访问时创建单例实例，并确保只有一个实例被创建：

1. use once_cell::sync::Lazy;
2.     struct Singleton {
3.        // 单例数据
4.        data: String,
5.    }
6.     static INSTANCE: Lazy<Singleton> = Lazy::new(|| Singleton {
7.        data: String::from("Singleton instance"),
8.    });
9.     fn main() {
10.        // 获取单例实例
11.        let instance = INSTANCE.clone();
12.        println!("{}", instance.data);
13.    }

复制代码

4. 使用 Rc 和 RefCell

使用 Rc 和 RefCell ： Rc 是 Rust 标准库中的引用计数类型， RefCell 是一个提供内部可变性的类型。结合使用 Rc 和 RefCell ，可以实现简单的单例模式：

1. use std::rc::Rc;
2.    use std::cell::RefCell;
3.     struct Singleton {
4.        // 单例数据
5.        data: String,
6.    }
7.     fn main() {
8.        // 创建单例实例
9.        let instance = Rc::new(RefCell::new(Singleton {
10.            data: String::from("Singleton instance"),
11.        }));
12.         // 获取单例实例
13.        let borrowed_instance = instance.borrow();
14.        println!("{}", borrowed_instance.data);
15.    }   

复制代码

 
原文：https://blog.csdn.net/u013769320/article/details/132094193
 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！