面试题：Rust 延迟初始化原子技巧在复杂场景的应用

Question

假设你正在开发一个多线程的分布式系统，需要对一些全局共享资源进行延迟初始化，并且要确保初始化过程的原子性和线程安全性。请设计一个 Rust 代码示例，展示如何使用延迟初始化原子技巧来实现这一需求，同时要考虑资源的释放和错误处理。

Answer 1

use std::sync::{Arc, Once, OnceState};
use std::thread;
use std::fmt;

// 定义全局共享资源
struct SharedResource {
    data: String,
}

impl Drop for SharedResource {
    fn drop(&mut self) {
        println!("Dropping SharedResource: {}", self.data);
    }
}

impl fmt::Debug for SharedResource {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "SharedResource({})", self.data)
    }
}

// 全局变量，用于延迟初始化
static INIT: Once = Once::new();
static mut RESOURCE: Option<Arc<SharedResource>> = None;

fn get_shared_resource() -> Result<Arc<SharedResource>, &'static str> {
    // 确保初始化只发生一次
    unsafe {
        INIT.call_once(|| {
            match SharedResource::new() {
                Ok(resource) => {
                    RESOURCE = Some(Arc::new(resource));
                },
                Err(e) => {
                    panic!("Failed to initialize SharedResource: {}", e);
                }
            }
        });

        RESOURCE.as_ref().ok_or("SharedResource not initialized")
            .map(|r| r.clone())
    }
}

impl SharedResource {
    fn new() -> Result<SharedResource, &'static str> {
        // 模拟一些可能失败的初始化操作
        Ok(SharedResource {
            data: "Initial data".to_string(),
        })
    }
}

fn main() {
    let threads: Vec<_> = (0..10).map(|_| {
        thread::spawn(|| {
            match get_shared_resource() {
                Ok(resource) => {
                    println!("Thread got resource: {:?}", resource);
                },
                Err(e) => {
                    eprintln!("Error: {}", e);
                }
            }
        })
    }).collect();

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

解释：

1. SharedResource 结构体：定义了需要延迟初始化的全局共享资源，实现了 Drop 特征用于资源释放，fmt::Debug 用于调试输出。
2. INIT 和 RESOURCE：INIT 是 Once 类型，确保初始化只发生一次；RESOURCE 是 Option<Arc<SharedResource>> 类型，存储共享资源，使用 Arc 实现多线程安全的引用计数。
3. get_shared_resource 函数：使用 INIT.call_once 确保资源只初始化一次，并且在初始化失败时进行错误处理。unsafe 块用于访问和修改 static mut 变量 RESOURCE。
4. SharedResource::new 函数：模拟可能失败的初始化操作。
5. main 函数：创建多个线程，每个线程调用 get_shared_resource 来获取共享资源，展示延迟初始化和线程安全性。