类似于 Arc-RwLock 的组合..

旨在在线程间共享数据时简单直接地使用。

试图创建一个简单易用且无烦恼的 Arc-RwLock 组合，而不是担心速度快和精简。

• 克隆引用工作类似于 Arc
• 专为在线程间共享对象而设计，无需担心
• 锁定对象工作类似于 RwLock 的 write() 或 read()
• 如果没有获得锁，它会旋转几次然后排队
• miri 似乎很高兴，所以我相信它不会泄漏太多内存等。
• 要求将所有放入其中的内容都设置为 Send+Sync
• 不需要不断 .unwrap() 东西，它只会永久阻塞或崩溃

示例

use cura::Cura;
trait Foo:Send+Sync
{
    fn get(&self)->i32;
    fn set(&mut self,i:i32);
}
#[derive(Debug)]
struct FF{i:i32,};
struct BB{i:i32};

impl Foo for FF{
    fn get(&self)->i32{return self.i;}
    fn set(&mut self,i:i32){self.i=i;}
}

impl Foo for BB{
    fn get(&self)->i32{return self.i;}
    fn set(&mut self,i:i32){self.i=i;}
}

let t=FF{i:1};

// you can do straight "from_box" but currently its impossible to
// "alter" unsized types
let foo2:Cura<dyn Foo>=Cura::from_box(Box::new(FF{i:2}));
let foo:Cura<Box<dyn Foo>>=Cura::new(Box::new(t));
let a=foo.clone();
let b=foo.clone();

{
    assert_eq!(a.read().get(),1);
    {
        a.alter(|s|{
            s.set(2);
            Some(())
        });
    }
    {
        a.alter(|s|{ //this only works for Sized types
            *s=Box::new(BB{i:2});
            Some(())
        });
    }
    let lock=a.read();
    let v=lock;
    assert_eq!(v.get(),2)
}//lock dropped here
{
    (*b.write()).set(3); //lock dropped here i think 
}

assert_eq!((*a.read()).get(),3);