Concurrency 防止并发执行
我想阻止异步调用的函数的并发执行。 函数从超服务调用,两个连接应导致一个连接等待另一个函数调用完成。我认为在其他线程/连接完成之前实现一个Future来阻止执行将解决这个问题。至于我的问题,我将未来存储在一个Concurrency 防止并发执行,concurrency,rust,async-await,hyper,Concurrency,Rust,Async Await,Hyper,我想阻止异步调用的函数的并发执行。 函数从超服务调用,两个连接应导致一个连接等待另一个函数调用完成。我认为在其他线程/连接完成之前实现一个Future来阻止执行将解决这个问题。至于我的问题,我将未来存储在一个互斥体中,但当我锁定互斥体以获取并等待锁时,它显然会抱怨互斥体守卫没有被发送。我不知道如何解决这个问题,或者我的方式是否糟糕 | 132 | let mut locks = LOCKS.lock().unwrap(); | ------
互斥体中
,但当我锁定互斥体以获取并等待锁时,它显然会抱怨互斥体守卫没有被发送。我不知道如何解决这个问题,或者我的方式是否糟糕
|
132 | let mut locks = LOCKS.lock().unwrap();
| --------- has type `std::sync::MutexGuard<'_, std::collections::HashMap<i64, hoster::hoster::LockFut>>`
...
136 | lock.await;
| ^^^^^^^^^^ await occurs here, with `mut locks` maybe used later
137 | }
| - `mut locks` is later dropped here
标准
互斥锁的防护是!确实发送
,因此它不能在等待
-s之间传送。对于这个任务,异步互斥通常是很好的事情。里面有一个,还有一个。他们的守卫是Send
,此时问题应该得到解决
但是我想更进一步地说,LockFut
解决了与异步互斥完全相同的问题。因此,对于这个特定的示例代码,可以显著简化为以下():
使用std::sync::Mutex作为StdMutex;
使用futures::lock::Mutex;
#[衍生(默认)]
结构状态{..}
类型SharedState=Arc;
懒惰的人!{
静态引用锁:StdMutex=Default::Default();
}
fn.非常感谢
lazy_static! {
static ref LOCKS: Mutex<HashMap<i64, LockFut>> = Mutex::new(HashMap::new());
}
struct LockState {
waker: Option<Waker>,
locked: bool
}
struct LockFut {
state: Arc<Mutex<LockState>>
}
impl Future for LockFut {
type Output = ();
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut state = self.state.lock().unwrap();
match state.locked {
false => {
Poll::Ready(())
},
true => {
state.waker = Some(cx.waker().clone());
Poll::Pending
}
}
}
}
impl LockFut {
fn new() -> LockFut {
LockFut {
state: Arc::new(Mutex::new(LockState {
locked: false,
waker: None
}))
}
}
pub fn release_lock(&mut self) {
let mut state = self.state.lock().unwrap();
state.locked = false;
if let Some(waker) = state.waker.take() {
waker.wake();
}
}
pub async fn lock<'a>(id: i64) {
let mut locks = LOCKS.lock().unwrap();
// Wait for existing lock to be unlocked or create a new lock
let lock = locks.entry(id).or_insert(LockFut::new());
// Wait for the potential lock to be released
lock.await;
}
pub fn unlock(id: i64) {
match LOCKS.lock().unwrap().get_mut(&id) {
Some(lock) => lock.release_lock(),
None => warn!("No lock found for: {}", id)
};
}
}
async fn is_concurrent(id: i64) {
should_not_be_concurrent().await;
}
async fn should_not_be_concurrent(id: i64) {
LockFut::lock(id).await;
// Do crazy stuff
LockFut::unlock(id);
}