以下是根据提供的内容整理的nshare库完整使用示例，包含所有基础用法：

完整示例代码

// 主进程示例
use nshare::{SharedMemory, SharedVec, ProcessMutex, ProcessCondvar, RefMut};
use std::sync::Arc;
use std::thread;
use std::mem::size_of;
use std::collections::HashMap;

#[repr(C)]
#[derive(Debug, Clone, Copy)]
struct SharedData {
    counter: u32,
    flag: bool,
}

fn main() {
    // 1. 基础共享内存示例
    let mut shm = SharedMemory::create("my_shared_memory", 1024).unwrap();
    let data = b"Hello from main process!";
    shm.as_mut_slice()[..data.len()].copy_from_slice(data);

    // 2. 共享结构化数据
    let mut struct_shm = SharedMemory::create("structured_data", size_of::<SharedData>()).unwrap();
    let mut shared_data: RefMut<SharedData> = struct_shm.map_mut().unwrap();
    shared_data.counter = 100;
    shared_data.flag = false;

    // 3. 跨进程同步
    let sync_shm = SharedMemory::create("sync_example", 1024).unwrap();
    let mutex = Arc::new(ProcessMutex::new(&sync_shm).unwrap());
    let condvar = Arc::new(ProcessCondvar::new(&sync_shm).unwrap());

    let mutex_clone = Arc::clone(&mutex);
    let condvar_clone = Arc::clone(&condvar);

    thread::spawn(move || {
        let guard = mutex_clone.lock().unwrap();
        println!("[Thread] Got the lock");
        condvar_clone.notify_one();
    });

    let guard = mutex.lock().unwrap();
    condvar.wait(guard).unwrap();
    println!("[Main] Woke up after notification");

    // 4. 共享向量
    let mut vec = SharedVec::<i32>::create("shared_vector", 10).unwrap();
    vec.push(10);
    vec.push(20);
    vec.push(30);

    // 5. 共享复杂数据结构
    let complex_shm = SharedMemory::create("complex_data", 2048).unwrap();
    let mut map: RefMut<[u8; 2048]> = complex_shm.map_mut().unwrap();
    
    let complex_data = HashMap::from([("温度", 25), ("湿度", 60)]);
    let serialized = bincode::serialize(&complex_data).unwrap();
    map[..serialized.len()].copy_from_slice(&serialized);

    println!("Main process completed. Run child process to read shared data.");
}

// 子进程示例 (通常需要单独运行)
/*
use nshare::{SharedMemory, SharedVec, Ref, ProcessMutex, ProcessCondvar};

fn child_process() {
    // 1. 读取基础共享内存
    let shm = SharedMemory::open("my_shared_memory", 1024).unwrap();
    println!("Received: {:?}", &shm.as_slice()[..23]); // 假设知道长度是23

    // 2. 读取结构化数据
    let struct_shm = SharedMemory::open("structured_data", std::mem::size_of::<SharedData>()).unwrap();
    let data: Ref<SharedData> = struct_shm.map().unwrap();
    println!("Counter: {}, Flag: {}", data.counter, data.flag);

    // 3. 参与跨进程同步
    let sync_shm = SharedMemory::open("sync_example", 1024).unwrap();
    let mutex = ProcessMutex::new(&sync_shm).unwrap();
    let condvar = ProcessCondvar::new(&sync_shm).unwrap();
    
    let guard = mutex.lock().unwrap();
    println!("[Child] Got the lock");
    condvar.notify_one();

    // 4. 读取共享向量
    let vec = SharedVec::<i32>::open("shared_vector").unwrap();
    println!("Shared vector: {:?}", vec.iter().collect::<Vec<_>>());

    // 5. 读取复杂数据结构
    let complex_shm = SharedMemory::open("complex_data", 2048).unwrap();
    let map: Ref<[u8; 2048]> = complex_shm.map().unwrap();
    let deserialized: HashMap<String, i32> = bincode::deserialize(&map[..]).unwrap();
    println!("Complex data: {:?}", deserialized);
}
*/

示例说明

1. 主进程：

   • 创建并写入基础共享内存
   • 共享结构化数据(SharedData结构体)
   • 使用跨进程互斥锁和条件变量进行同步
   • 创建并填充共享向量
   • 序列化复杂数据(HashMap)到共享内存

2. 子进程(注释部分)：

   • 打开并读取主进程创建的共享内存
   • 读取结构化数据
   • 参与跨进程同步
   • 读取共享向量
   • 反序列化复杂数据

运行说明

1. 先运行主进程创建共享数据
2. 然后运行子进程(需要取消注释child_process函数并修改为main函数)
3. 确保两个进程使用相同的共享内存名称

注意事项

1. 共享数据结构必须使用#[repr(C)]保证内存布局
2. 实际使用时需要处理所有可能的错误(示例中为简洁使用unwrap)
3. 不同平台可能有不同的共享内存实现细节
4. 确保共享内存大小足够容纳所有数据