如何重组结构，以免发生'Cannot borrow `x` as mutable more than once at a time'

Question

目前，我有一个AppState结构，它有两个字段：

pub struct AppState {
players: HashMap<String, PlayerValue>,
cars: HashMap<String, CarValue>,
}

我使用tokio实现了一个多线程服务器应用程序，它处理请求并通过更改AppState中的字段来响应请求。

例如：

// Process stop request
let mut app_state = app_state_clone.lock().await; // `app_state_clone` is  `Arc<Mutex<AppState>>`
app_state.stop_players().await?;
app_state.stop_cars().await?;
Ok(())

此代码按照预期进行编译和工作。然而，在这种情况下，我们首先等待app_state.stop_players()未来的完成，然后再次等待app_state.stop_cars()的完成。

然而，由于这两种方法都可以指向结构的不同部分，并且不会改变相同的字段，所以我认为我可以使用try_join!来同时等待任务。

// Process stop request
let mut app_state = app_state_clone.lock().await; // `app_state_clone` is  `Arc<Mutex<AppState>>`
let stop_players_f = app_state.stop_players();
let stop_cars_f = app_state.stop_cars();
try_join!(stop_players_f, stop_cars_f);
Ok(())

这将导致编译错误：

不能一次多次借用app_state作为可变

我已经找到了重组代码的方法来解决这个问题，并找到了以下SO答案：

let mut x = X { a: 1, b: 2 };
let a = &mut x.a;
let b = &mut x.b;

在这里，编译器可以看到a和b从不指向相同的数据，即使它们指向相同的结构内部。

受此启发，我想我可以按如下方式重组代码：

pub struct AppState {
players_state: PlayersState,
cars_state: CarsState,
}
pub struct PlayersState {
players: HashMap<String, PlayerValue>,
}
pub struct CarsState {
cars: HashMap<String, CarValue>,
}

服务器中的代码方法：

// Process stop request
let players_state = &mut app_state.players_state;
let cars_state = &mut app_state.cars_state;
let stop_players_f = players_state.stop_players();
let stop_cars_f = cars_state.stop_cars();
try_join!(stop_players_f, stop_cars_f);
Ok(())

然而，这只会导致同样的错误：

不能借用app_state作为一次多次可变

EDIT：这是完整的编译错误：

error[E0499]: cannot borrow `app_state` as mutable more than once at a time
--> crates/my-app/src/app.rs:1786:68
|
1785 | ...                   let players_state = &mut app_state.players_state;
|                                                --------- first mutable borrow occurs here
1786 | ...                    let cars_state = &mut app_state.cars_state;
|                                              ^^^^^^^^^ second mutable borrow occurs here
...
1791 | ...                    let stop_players_f = players_state.stop_players();
|                                              --------------------------- first borrow later used here

下面是PlayersState:的实现

impl PlayersState {
pub fn players(&self) -> &HashMap<String, PlayerValue> {
&self.players
}
pub fn players_mut(&mut self) -> &mut HashMap<String, PlayerValue> {
&mut self.players
}
pub async fn stop_players(&self) -> Result<(), StopPlayersError> {
for player in self.players.values() {
match player {
PlayerValue::MyOnePlayer(p) => {
p.stop().await?;
}
}
}
Ok(())
}
}

注意：虽然stop_players中的mut不是必需的，但在stop_cars函数中是必需的。

如果能对这个问题有更多的了解，我将不胜感激，因为我似乎不明白如何解决这个问题。

编辑：

以下代码代表再现错误的实际最小示例：

use std::collections::HashMap;
use tokio::try_join;
use tokio::sync::Mutex;
use std::sync::Arc;
pub struct App {
state: Arc<Mutex<AppState>>,
}
pub struct AppState {
players_state: PlayersState,
cars_state: CarsState,
}
pub enum PlayerValue {
MyOnePlayer(PlayerInner)
}
pub struct PlayerInner;
impl PlayerInner {
async fn stop(&self) -> Result<(), ()> { Ok(()) }
}
pub struct PlayersState {
players: HashMap<String, PlayerValue>,
}
impl PlayersState {
pub async fn stop_players(&self) -> Result<(), ()> {
for player in self.players.values() {
match player {
PlayerValue::MyOnePlayer(p) => {
p.stop().await?;
}
}
}
Ok(())
}
}
pub struct CarsState {
cars: HashMap<String, ()>,
}
impl CarsState {
async fn stop_cars(&mut self) -> Result<(), ()> { Ok(()) }
}
pub async fn check() -> Result<(), ()> {
// Init on app startup 
let state =  Arc::new(Mutex::new(AppState {
players_state: PlayersState {
players: vec![].into_iter().collect()
},
cars_state: CarsState {
cars: vec![].into_iter().collect()
},
}));


let app = App {
state
};


// This code will be executed when we process a request
// `app.state` is in the real 'code' a clone, because I have to use it in the request/response loop and UI loop

let mut app_state = app.state.lock().await;

let players_state = &mut app_state.players_state;
let cars_state = &mut app_state.cars_state;
let stop_players_f = players_state.stop_players();
let stop_cars_f = cars_state.stop_cars();
try_join!(stop_players_f, stop_cars_f);
Ok(())
}

Answer 1

最小化示例：

use std::sync::Mutex;
pub struct AppState {
players_state: (),
cars_state: (),
}
pub fn check() {
let state = Mutex::new(AppState {
players_state: (),
cars_state: (),
});
let mut app_state = state.lock().unwrap();
let players_state = &mut app_state.players_state;
let _cars_state = &mut app_state.cars_state;
println!("{:?}", players_state);   
}

Playground
这里我们使用的是标准同步Mutex，但无论使用什么同步原语，错误都基本相同。

---

此错误的原因是访问app_state上的属性必须通过MutexGuard的DerefMut实现。换句话说，有问题的部分实际上被降级为这样的东西：

let players_state = &mut DerefMut::deref_mut(&mut app_state).players_state;
let _cars_state = &mut DerefMut::deref_mut(&mut app_state).cars_state;

当涉及到借用检查时，DerefMut::deref_mut并不特殊——它需要&mut self，因此它假设实现可以以任何方式访问任何字段，从而使以前存在的对结构的任何引用无效。

然而，链接答案并没有遇到这个问题，因为我们直接使用了&mut X——在这种情况下，编译器能够推断借用的不相交性，并允许对不同字段的引用共存。

---

因此，为了获得相同的结果，您必须在借用其字段之前以某种方式将MutexGuard<AppState>转换为&mut AppState。幸运的是，如果我们不跨越函数边界(即，不试图向调用方返回任何内容(，这很容易，上面的代码就提示了如何做到这一点：我们可以简单地提取去伪装代码的公共部分：

let app_state: &mut AppState = DerefMut::deref_mut(&mut app_state);
let players_state = &mut app_state.players_state;
let _cars_state = &mut app_state.cars_state;

而且，由于deref_mut是解引用操作的实现，因此可以简化为：

let app_state = &mut *app_state;
let players_state = &mut app_state.players_state;
let _cars_state = &mut app_state.cars_state;

有了这个变化，示例编译了-操场。

Answer 2

也许这样的东西会有所帮助：

struct X {
a: i32,
b: i32
}
impl X {
fn split_mut(&mut self) -> (&mut i32, &mut i32) {
(&mut self.a, &mut self.b)
}
}
fn foo() {
let mut x = X { a: 13, b: 42 };
let (a, b) = x.split_mut();
}

但是，在您展示更多代码并指出编译器错误的确切来源之前，我将无法为您提供更多帮助。