This function definition seems highly problematic. async fn get_num(&mut self, … `&mut self` requires exclusive access to the entire `NumberPool`, and `async` requires keeping that exclusive access for the entire duration of the async operation. This seems like a bottleneck that can completely kill parallelism. Can you use more fine-grained locking and interior mutability? Make it `async fn get_num(&self, …` and then multiple `get_num` operations could run at the same time, interleaved, and you won't need `NumberPool` in a lock. Alternatively, can you make it `fn get_num(&mut self, …) -> impl Future + 'static`? That would allow you to release lock on `self` _before_ starting to await the future, so the locking would be synchronous and hopefully relatively quick. The catch is the future has to be independent of `self`'s loan, so it needs `async move` and `Arc`, etc., no temporary references crossing into `async move {}` block.