Task pool for Tokio Runtime
https://crates.io/crates/tokio-task-pool
A typical pattern
rust,ignore
loop {
let (socket, _) = listener.accept().await.unwrap();
tokio::spawn(async move {
process(socket).await;
});
}
is actually an anti-pattern which may break your production.
Why? Because this pattern behaves equally to an unbounded channel. If the producer has higher rate than consumers, it floods runtime with tasks and sooner or later causes memory overflow.
Use a pool of workers instead
Use task spawning but manually limit the number of active tasks with a semaphore
Use this crate which does the job out-of-the-box
Pool objects with safe spawn methods, which automatically limit number of tasks
Tasks can be automatically aborted if run timeout is set, global or per task
Simple spawning is pretty similar to tokio::spawn, but async because the producer must be blocked until there is an empty task slot in the pool:
```rust use std::time::Duration; use tokiotaskpool::Pool;
let pool = Pool::bounded(5) .withspawntimeout(Duration::fromsecs(5)) .withruntimeout(Duration::fromsecs(10)); pool.spawn(async move { // do some job }); ```
Refer to the crate documentation.