编译器说数据不能在线程之间安全地共享，即使数据包装在互斥锁中

Posted 2023-02-23

【中文标题】编译器说数据不能在线程之间安全地共享，即使数据包装在互斥锁中

【英文标题】：Compiler says that data cannot be shared between threads safely even though the data is wrapped within a Mutex

【发布时间】：2019-03-18 23:12:32

【问题描述】：

我正在使用 Rocket，它有一个 State，它传递给 HTTP 请求。这个结构包含一个Mutex<DatastoreInstance>，它提供对 SQLite 数据库的访问权限，并使用互斥锁锁定以确保读写安全。

pub struct DatastoreInstance 
    conn: Connection,

DatastoreInstance 结构看起来像这样，只有一个 SQLite 连接一切正常，但我还想在这个结构中添加一个事务对象：

pub struct DatastoreInstance 
    conn: Connection,
    events_transaction: Transaction,

这没有编译，因为Transaction 对象需要引用一个Connection 对象，该对象应该有它知道的生命周期。 我正在使用的 rusqlite 中的 Connection 和 Transaction 对象定义如下：

pub struct Connection 
    db: RefCell<InnerConnection>,
    cache: StatementCache,
    path: Option<PathBuf>,


pub struct Transaction<'conn> 
    conn: &'conn Connection,
    drop_behavior: DropBehavior,

为了解决生命周期问题，我必须添加这些生命周期参数才能使其正常工作：

pub struct DatastoreInstance<'a> 
    conn: Connection,
    events_transaction: Transaction<'a>,

根据我对生命周期和互斥锁的理解，这是结果，应该可以工作，但现在我收到一个编译器错误告诉我：

`std::cell::RefCell<lru_cache::LruCache<std::string::String, rusqlite::raw_statement::RawStatement>>` cannot be shared between threads safely
    |                                                                                                            
    = help: within `rusqlite::Connection`, the trait `std::marker::Sync` is not implemented for `std::cell::RefCell<lru_cache::LruCache<std::string::String, rusqlite::raw_statement::RawStatement>>`
    = note: required because it appears within the type `rusqlite::cache::StatementCache`                        
    = note: required because it appears within the type `rusqlite::Connection`                                   
    = note: required because of the requirements on the impl of `std::marker::Send` for `&rusqlite::Connection`  
    = note: required because it appears within the type `datastore::DatastoreInstance<'_>`                       
    = note: required because of the requirements on the impl of `std::marker::Send` for `std::sync::Mutex<datastore::DatastoreInstance<'_>>`
    = note: required because it appears within the type `endpoints::ServerState<'_>`                             
    = note: required by `rocket::State`

根据我对互斥体的理解，这段代码应该是有效的，因为整个 DatastoreInstance 结构被包裹在一个 Mutex 中，这应该保证一次只有一个线程引用这个对象。

我错过了什么？

为什么编译器在Transaction 引用的Connection 内而不是单独在Connection 内引用后发现RefCell 不再安全？

我对互斥锁的工作原理有什么不好的理解吗？我的生命周期是否无效并且以某种方式破坏了读/写安全？将Connection 和Transaction 放在同一个结构中的设计是否会破坏读/写安全性？我是否需要以某种方式重新设计我的数据结构以确保安全？还是我只是遗漏了一些非常明显的东西？

【问题讨论】：

您没有包含足够的代码来提供更多帮助。比如这个RefCell在哪里，你说的Mutex在哪里？见minimal reproducible example。

您的代码中的Connection 类型是指this 吗？

@PeterHall 正如我所说并显示在错误消息中，我在我的州使用 Mutex。在将 Transaction 添加到结构之前，编译器没有抱怨 Connection 对象中的 RefCell 无法安全共享。问题具体是为什么编译器在事务中引用的 Connection 中而不是仅在 Connection 中之后不再发现 RefCell 是安全的。我将开始尝试制作一个最小、完整且可验证的示例，但这需要一些时间。

@PeterHall 是的，这正是我所引用的 Connection 对象，我应该添加更多相关信息。

【参考方案1】：

Mutex 仅是 Send 或 Sync if the value it contains is itself Send：

impl<T: ?Sized + Send> Send for Mutex<T>    
impl<T: ?Sized + Send> Sync for Mutex<T>

&T 只是 Send when T is Sync:

impl<'a, T> Send for &'a T
where
    T: Sync + ?Sized, 

还有一个RefCell is never Sync

impl<T> !Sync for RefCell<T>
where
    T: ?Sized, 

如错误消息所述，您的事务包含对RefCell 的引用。有一个互斥锁并不重要，跨线程共享它本质上不是内存安全的。一个简单的复制：

use std::cell::RefCell, sync::Mutex;

struct Connection(RefCell<i32>);
struct Transaction<'a>(&'a Connection);

fn is_send<T: Send>(_: T) 

fn main() 
    let c = Connection(RefCell::new(42));
    let t = Transaction(&c);
    let m = Mutex::new(t);

    is_send(m);

error[E0277]: `std::cell::RefCell<i32>` cannot be shared between threads safely
  --> src/main.rs:13:5
   |
13 |     is_send(m);
   |     ^^^^^^^ `std::cell::RefCell<i32>` cannot be shared between threads safely
   |
   = help: within `Connection`, the trait `std::marker::Sync` is not implemented for `std::cell::RefCell<i32>`
   = note: required because it appears within the type `Connection`
   = note: required because of the requirements on the impl of `std::marker::Send` for `&Connection`
   = note: required because it appears within the type `Transaction<'_>`
   = note: required because of the requirements on the impl of `std::marker::Send` for `std::sync::Mutex<Transaction<'_>>`
note: required by `is_send`
  --> src/main.rs:6:1
   |
6  | fn is_send<T: Send>(_: T) 
   | ^^^^^^^^^^^^^^^^^^^^^^^^^

为什么编译器在 Connection 内引用 Transaction 而不是仅仅在 Connection 内引用后发现 RefCell 不再安全？

RefCell 很好，这是对RefCell 的引用。

在同一个结构中包含Connection 和Transaction 的设计是否是一个糟糕的设计[...] 我是否需要重新设计我的数据结构

是的。

How to store rusqlite Connection and Statement objects in the same struct in Rust? Why can't I store a value and a reference to that value in the same struct?

【讨论】：

"如果 Mutex 包含的值本身就是 Send，则 Mutex 仅是 Send 或 Sync" 这很有意义，好点。我已经测试了您的解决方案并且它有效，但是我仍然很难为我的案例提出一个好的替代设计（但这实际上是一件好事，因为它迫使我安全地设计它并质疑我以前使用参考的坏习惯在互斥体中）。我正在考虑使用一个单独的数据库线程，http 服务器工作线程将请求发送到该线程。这是有道理的，因为 SQLite 数据库最好一次只能从一个线程访问。

@JohanBjäreholt 越来越接近“演员”般的模型，这是一种众所周知且受人尊敬的模式。在这种情况下似乎非常合理。线程之间通信的通道应该很合适，或者您可以研究迁移到像 Actix 这样的全面演员框架。