目前，我有一个AppState struct ，它有两个字段:
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()future 的完成，然后再次等待app_state.stop_cars()的完成.
然而，由于这两种方法都可以指向 struct 的不同部分，并且不会改变相同的字段，所以我认为可以使用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(())
这将导致编译错误:
不能一次多次borrow
app_state作为可变变量
我一直在寻找重新组织代码的方法来修复这个问题，并找到了以下answer个:
let mut x = X { a: 1, b: 2 };
let a = &mut x.a;
let b = &mut x.b;
在这里，编译器可以看到
a和b从不指向相同的数据，即使它们确实指向相同的 struct 内部.
受此启发，我认为我可以按如下方式重新构建代码:
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(())
然而，这只会导致相同的错误:
不能一次多次borrow
app_state作为可变变量
编辑:以下是完整的编译错误:
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函数中是必需的.
如果能对这个问题有更多的见解，我将不胜感激，因为我似乎不知道如何才能解决这个问题.
EDIT:个
以下代码表示重现错误的实际最小示例:
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(())
}