# use keepcalm::*;
fn use_shared(shared: SharedMut<String>) {
    shared.read();
}

let shared = SharedMut::new("123".to_string());
use_shared(shared);
let shared = SharedMut::new_mutex("123".to_string());
use_shared(shared);

管理同步原语的毒化状态也是一个挑战。如果在你持有锁时发生 panic!，Rust 会毒化 Mutex 或 RwLock。

SharedMut 类型允许您在构造时指定一个 PoisonPolicy。默认情况下，如果同步原语被毒化，SharedMut 将在访问时引发 panic!。这可以被配置为忽略毒化。

# use keepcalm::*;
let shared = SharedMut::new_with_policy("123".to_string(), PoisonPolicy::Ignore);

Shared

默认的 Shared 对象类似于 Rust 的 std::sync::Arc，但增加了投影功能。对象也可以作为 Mutex 构建，或者是一个 SharedMut 的只读视图。

请注意，由于这种灵活性，Shared 对象比传统的 std::sync::Arc 要复杂一些，因为所有访问都必须通过 Shared::read 访问器来完成。

实验性：全局变量

注意：这需要 --feature global_experimental 标志

虽然 static 全局变量在 Rust 中可能经常是一种反模式，但此库还提供易于使用的替代方案，这些方案与 Shared 和 SharedMut 类型兼容。

可以使用 SharedGlobal 创建全局 Shared 引用。

# use keepcalm::*;
# #[cfg(feature="global_experimental")]
static GLOBAL: SharedGlobal<usize> = SharedGlobal::new(1);

# #[cfg(feature="global_experimental")]
fn use_global() {
    assert_eq!(GLOBAL.read(), 1);

    // ... or ...

    let shared: Shared<usize> = GLOBAL.shared();
    assert_eq!(shared.read(), 1);
}

同样，可以使用 SharedGlobalMut 创建全局 SharedMut 引用。

# use keepcalm::*;
# #[cfg(feature="global_experimental")]
static GLOBAL: SharedGlobalMut<usize> = SharedGlobalMut::new(1);

# #[cfg(feature="global_experimental")]
fn use_global() {
    *GLOBAL.write() = 12;
    assert_eq!(GLOBAL.read(), 12);

    // ... or ...

    let shared: SharedMut<usize> = GLOBAL.shared_mut();
    *shared.write() = 12;
    assert_eq!(shared.read(), 12);
}

SharedGlobal 和 SharedGlobalMut 都提供了一个 new_lazy 构造函数，允许初始化在首次访问时延迟。

# use keepcalm::*;
# use std::collections::HashMap;
# #[cfg(feature="global_experimental")]
static GLOBAL_LAZY: SharedGlobalMut<HashMap<&str, usize>> =
    SharedGlobalMut::new_lazy(|| HashMap::from_iter([("a", 1), ("b", 2)]));

实验性：异步

注意：这需要 --feature async_experimental 标志

这非常实验性，可能存在安全性和/或性能问题！

Shared 和 SharedMut 类型支持一个 read_async 和 write_async 方法，该方法将使用异步运行时的 spawn_blocking 方法（或等效方法）来阻塞。使用 make_spawner 创建一个 Spawner 并将其传递给适当的锁定方法。

# use keepcalm::*;
# #[cfg(feature="global_experimental")]
static SPAWNER: Spawner = make_spawner!(tokio::task::spawn_blocking);

# #[cfg(feature="global_experimental")]
async fn get_locked_value(shared: Shared<usize>) -> usize {
    *shared.read_async(&SPAWNER).await
}

# #[cfg(feature="global_experimental")]
{
    let shared = Shared::new(1);
    get_locked_value(shared);
}

投影

`Shared` 和 `SharedMut` 都允许对底层类型的 投影。投影可以用来选择类型的子集，或者将类型转换为特质。`project!` 和 `project_cast!` 宏可以简化此代码。

注意，投影始终与根对象相关联！如果投影被锁定，根对象也会被锁定。

转换

# use keepcalm::*;
let shared = SharedMut::new("123".to_string());
let shared_asref: SharedMut<dyn AsRef<str>> = shared.project(project_cast!(x: String => dyn AsRef<str>));

结构体/元组的子集

# use keepcalm::*;
#[derive(Default)]
struct Foo {
    tuple: (String, usize)
}

let shared = SharedMut::new(Foo::default());
let shared_string: SharedMut<String> = shared.project(project!(x: Foo, x.tuple.0));

*shared_string.write() += "hello, world";
assert_eq!(shared.read().tuple.0, "hello, world");
assert_eq!(*shared_string.read(), "hello, world");

非固定大小类型

`Shared` 和 `SharedMut` 都支持非固定大小类型，但由于语言当前的限制（详见 std::ops::CoerceUnsized），您需要以特殊方式构建它们。

支持非固定大小特质，但您需要在共享类型中指定 Send + Sync，或者使用 project_cast! 对象

# use keepcalm::*;

// In this form, `Send + Sync` are visible in the shared type
let boxed: Box<dyn AsRef<str> + Send + Sync> = Box::new("123".to_string());
let shared: SharedMut<dyn AsRef<str> + Send + Sync> = SharedMut::from_box(boxed);

// In this form, `Send + Sync` are erased via projection
let shared = SharedMut::new("123".to_string());
let shared_asref: SharedMut<dyn AsRef<str>> = shared.project(project_cast!(x: String => dyn AsRef<str>));

使用盒子支持非固定大小切片

# use keepcalm::*;
let boxed: Box<[i32]> = Box::new([1, 2, 3]);
let shared: SharedMut<[i32]> = SharedMut::from_box(boxed);