我有一个结构体不是Send，因为它包含Rc。假设Arc的开销太大，所以我想继续使用Rc。我仍然想偶尔在线程之间使用Send这个结构体，但只有当我可以验证Rc具有strong_count 1和weak_count 0时。
下面是我脑海中的抽象概念（希望是安全的）：

mod my_struct {
    use std::rc::Rc;

    #[derive(Debug)]
    pub struct MyStruct {
        reference_counted: Rc<String>,
        // more fields...
    }

    impl MyStruct {
        pub fn new() -> Self {
            MyStruct {
                reference_counted: Rc::new("test".to_string())
            }
        }

        pub fn pack_for_sending(self) -> Result<Sendable, Self> {
            if Rc::strong_count(&self.reference_counted) == 1 &&
               Rc::weak_count(&self.reference_counted) == 0
            {
                Ok(Sendable(self))
            } else {
                Err(self)
            }
        }

        // There are more methods, some may clone the `Rc`!
    }

    /// `Send`able wrapper for `MyStruct` that does not allow you to access it,
    /// only unpack it.
    pub struct Sendable(MyStruct);

    // Safety: `MyStruct` is not `Send` because of `Rc`. `Sendable` can be
    //         only created when the `Rc` has strong count 1 and weak count 0.
    unsafe impl Send for Sendable {}

    impl Sendable {
        /// Retrieve the inner `MyStruct`, making it not-sendable again.
        pub fn unpack(self) -> MyStruct {
            self.0
        }
    }
}

use crate::my_struct::MyStruct;

fn main() {
    let handle = std::thread::spawn(|| {
        let my_struct = MyStruct::new();
        dbg!(&my_struct);

        // Do something with `my_struct`, but at the end the inner `Rc` should
        // not be shared with anybody.

        my_struct.pack_for_sending().expect("Some Rc was still shared!")
    });

    let my_struct = handle.join().unwrap().unpack();
    dbg!(&my_struct);
}

我在Rust playground上做了一个演示。
它起作用了。我的问题是，它真的安全吗？
我知道Rc只由一个拥有者拥有，没有人可以在我的控制下改变它，因为它不能被其他线程访问，我们将它 Package 到Sendable中，这不允许访问包含的值。
但是在一些疯狂的世界里，Rc可能会在内部使用线程本地存储，这将是不安全的...所以我能保证我能做到这一点吗？
我知道我必须非常小心，不要引入一些额外的原因，使MyStruct不是Send。