rust学习二十.3、rust使用不安全代码访问静态变量

一、前言

1.1、为什么要使用不安全块访问可变静态变量

根据rust设计人的明确：静态变量是可以修改，以是在并发情况下是大概存在并发/并行时候的不一致题目（假如要修改)，这大概就不安全了。
以是，rust规定访问可变静态变量需要使用不安全代码块(unsafe块)。
 
1.2、比较静态变量和常量

1.常量与不可变静态变量的一个微妙的区别是静态变量中的值有一个固定的内存地点。使用这个值总是会访问相同的地点。
常量则允许在任何被用到的时候复制其数据，具体而言应该是内联了（在用到的地方替换举行替换)。
2.另一个区别在于静态变量可以是可变的。访问和修改可变静态变量都是不安全的
1.3、多线程修改静态变量

在多线程中，访问静态变量(写）必须使用互斥锁。其次已经不能使用Arc(原子引用计数指针）来存储它了，必须使用延迟锁指针(LazyLock)来保存，否则无法编译.
还有一种方式更加复杂，就是还是使用Arc，但是需要使用到OnceLock（一次性锁指针)。
LazyLock - 延时锁指针/延迟锁
延迟锁特性：

• 需要简朴的延迟初始化
  
• 初始化逻辑固定且不会失败的场景
  
• 可以使用 nightly Rust 的项目
  
• 性能要求较高的场景（因为少了一些运行时查抄）
  

OnceLock - 一次性锁指针/一次性锁

• 需要显式控制初始化机遇的场景
  
• 需要处理初始化失败的场景
  
• 需要在 stable Rust 中使用的项目- 对安全性要求较高的场景
  

二、示例

2.1、示例-单线程静态和多线程中的LazyLock

1. use std::sync::{Mutex,LazyLock};
2. use std::thread;
3. use std::io;
4. use std::io::Write;
6. //通常静态变量会定义在全局作用域中，并且通常是大写字母开头的常量命名规则。
7. static mut COUNTER: u32 = 0;
8. static mut ARC_COUNTER:LazyLock<Mutex<u32>> = LazyLock::new(|| Mutex::new(0));
9. static mut SIGN:u32 = 0;
11. //允许指向静态变量的共享引用，不要一直提示了
12. #[allow(static_mut_refs)]
13. fn main() {
14.     //1.0 演示单线程下unsafe访问全局静态变量
15.     access_static_in_singlethread();
16.    
17.     //2.0 演示局部静态变量 -- 在方法/函数，代码块内都可以定义static,只是作用范围不同而已
18.     define_partitional_static();
20.     //3.0 演示多线程下对全局变量的访问   
21.     print!("请输入线程数量:");  //注意print!宏不会刷新输出流,除非有换行符，所以需要手动刷新输出流
22.     std::io::stdout().flush().unwrap();
23.     let thread_qty = read_thread_qty();
24.     unsafe{
25.         change_static_in_parallel(thread_qty);
26.     }   
27.     unsafe {
28.         println!("主线程-ARC_COUNTER现在的值: {}",*ARC_COUNTER.lock().unwrap());
29.         println!("--- 预备.... 开始!!! ");
30.         //通知所有子线程开始执行
31.         SIGN=1;
32.         //在主线程中循环打印ARC_COUNTER的值，直到其值达到10
33.         while *ARC_COUNTER.lock().unwrap() < thread_qty {
34.             println!("主线程-ARC_COUNTER现在的值: {}",*ARC_COUNTER.lock().unwrap());
35.             thread::sleep(std::time::Duration::from_millis(5));
36.         }
37.         //打印最终的ARC_COUNTER的值
38.         println!("主线程-ARC_COUNTER最后的值: {}",*ARC_COUNTER.lock().unwrap());
39.     }
40. }
41. #[allow(static_mut_refs)]
42. fn access_static_in_singlethread() {
43.     unsafe {
44.         println!("COUNTER(开始前): {}",COUNTER);
45.     }
46.     let add_qty: u32 = 3;
47.     add_to_count(add_qty);
48.     unsafe {
49.         println!("COUNTER(+{}后): {}",add_qty,COUNTER);
50.     }
51. }
52. fn add_to_count(inc: u32) {
53.     unsafe {
54.         COUNTER += inc;
55.     }
56. }
58. /**
59. * 演示多线程下对全局变量的访问
60. */
61. #[allow(static_mut_refs)]
62. unsafe fn change_static_in_parallel(thread_qty:u32) {
63.     //这里仅仅是一个复制，还是不能修改COUNTER
64.     //利用懒惰指针+互斥锁
65.     let mut handles = vec![];
66.     for _ in 0..thread_qty {
67.         let handle = thread::spawn(|| {
68.             //等待主线程通知开始执行子线程任务，否则可能有的很快就跑完了，导致主线程还没开始就结束了
69.             while SIGN==0 {
70.                 thread::sleep(std::time::Duration::from_millis(50));
71.             }
72.             let mut num=ARC_COUNTER.lock().unwrap();
73.             *num += 1;
74.             println!("----子线程{:?}+1得到{}", thread::current().id(),*num);
75.         });
76.         handles.push(handle);
77.     }
78.     //此处不要join,因为它要等待SIGN=1后才执行，且就算SIGN=1，也会被主线程阻塞
79. }
81. fn define_partitional_static() {
82.     //但如果你愿意，也可以定义一个局部静态变量。
83.     static HELLO_WORLD: &str = "Hello, world!";
84.     println!("{}", HELLO_WORLD);
85. }
87. fn  read_thread_qty() -> u32 {
88.     let mut gts=String::new();
89.         io::stdin().read_line(&mut gts).expect("读取失败");
90.         let gts: u32=gts.trim().parse().expect("请输入一个数字");
91.     return gts;
92. }

复制代码

代码中有两个例子：
1.界说平常的静态变量，并在单个线程中修改它
2.界说可变静态变量，在多线程中修改
输出结果：

输入线程数后，继承执行：

证实了，在多线程中，简直可以修改静态变量。
2.2、示例-多线程中的OnceLock

再来一个OnceLock的例子：

1. use std::io;
2. use std::io::Write;
3. use std::sync::{Arc, Mutex, OnceLock};
4. use std::thread;
6. //通常静态变量会定义在全局作用域中，并且通常是大写字母开头的常量命名规则。
7. static ARC_AGE: OnceLock<Arc<Mutex<u32>>> = OnceLock::new();
8. static mut SIGN: u32 = 0;
10. //允许指向静态变量的共享引用，不要一直提示了
11. #[allow(static_mut_refs)]
12. fn main() {
13.     ARC_AGE.get_or_init(|| Arc::new(Mutex::new(18))); // 初始年龄设为18
14.     print!("请输入线程数量:"); //注意print!宏不会刷新输出流,除非有换行符，所以需要手动刷新输出流
15.     std::io::stdout().flush().unwrap();
16.     let thread_qty = read_thread_qty();
17.     // 重置SIGN为0，准备执行新的示例
18.     println!("\n现在开始演示ARC_AGE的并行修改:");
20.     // 执行新的示例
21.     change_static_in_parallel2(thread_qty);
23.     let age = ARC_AGE.get().unwrap();
24.     println!("主线程-ARC_AGE现在的值: {}", *age.lock().unwrap());
25.     println!("--- 预备.... 开始!!! ");
27.     unsafe {
28.         SIGN = 1;
29.     }
31.     // 在主线程中循环打印ARC_AGE的值，直到其值达到目标值
32.     let target_age = 18 + thread_qty;
33.     while *age.lock().unwrap() < target_age {
34.         println!("主线程-ARC_AGE现在的值: {}", *age.lock().unwrap());
35.         thread::sleep(std::time::Duration::from_millis(5));
36.     }
37.     println!("主线程-ARC_AGE最后的值: {}", *age.lock().unwrap());
38. }
40. /**
41. * 使用Arc演示多线程下对全局变量的访问
42. */
43. fn change_static_in_parallel2(thread_qty: u32) {
44.     let age = ARC_AGE.get().unwrap().clone();
45.     let mut handles = vec![];
47.     for _ in 0..thread_qty {
48.         let age = age.clone();
49.         let handle = thread::spawn(move || {
50.             //等待主线程通知开始执行子线程任务
51.             unsafe {
52.                 while SIGN == 0 {
53.                     thread::sleep(std::time::Duration::from_millis(50));
54.                 }
55.             }
56.             let mut current_age = age.lock().unwrap();
57.             *current_age += 1;
58.             println!(
59.                 "----子线程{:?}将年龄+1得到{}",
60.                 thread::current().id(),
61.                 *current_age
62.             );
63.         });
64.         handles.push(handle);
65.     }
66.     //此处不要join,因为它要等待SIGN=1后才执行，且就算SIGN=1，也会被主线程阻塞
67. }
69. fn read_thread_qty() -> u32 {
70.     let mut gts = String::new();
71.     io::stdin().read_line(&mut gts).expect("读取失败");
72.     let gts: u32 = gts.trim().parse().expect("请输入一个数字");
73.     return gts;
74. }

复制代码

执行结果如下：

需要留意的是，OnceLock不需要在安全代码块中，这一点和LazyLock很不同。
三、小结

• 静态变量是一个好东西,那个语言都少不了
  
• 但是假如要在多线程中修改静态变量，则大概需要使用不安全代码访问(LazyLock),也大概不需要（OnceLock)
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。