Struct LocalSpawnPool 

pub struct LocalSpawnPool(/* private fields */);

A pool of tasks to spawn futures and wait for them on a single thread.

It is inspired by and has almost the same functionality as tokio::task::LocalSet, but this standalone crate allows you to avoid importing the whole tokio crate if you don’t need it. Unlike the tokio::task::LocalSet, LocalSpawnPool doesn’t handle panics.

In some cases, it is necessary to run one or more futures that do not implement Send and thus are unsafe to send between threads. In these cases, a LocalSpawnPool may be used to schedule one or more !Send futures to run together on the same thread.

You can use the LocalSpawnPool::run_until function to run a future to completion on the LocalSpawnPool, returning its output (see LocalSpawnPool::run_until for more details). And you can use the LocalSpawnPool::spawn and spawn functions to spawn futures on the LocalSpawnPool. To wait for all the spawned futures to complete, await the LocalSpawnPool itself:

Awaiting the LocalSpawnPool

Example:

use local_spawn_pool::LocalSpawnPool;

async fn run() {
    let pool = LocalSpawnPool::new();
     
    pool.spawn(async {
        // This future will be spawned inside `pool`
         
        local_spawn_pool::spawn(async {
            // This future will be spawned inside `pool`
             
            local_spawn_pool::spawn(async {
                // This future will be spawned inside `pool`
            });
        });

        local_spawn_pool::spawn(async {
            // This future will be spawned inside `pool`
        });
    });

    pool.await; // Will wait for all the futures inside the local_spawn_pool to complete
}

Awaiting a LocalSpawnPool is !Send.

Implementations

impl LocalSpawnPool

pub fn new() -> Self

Returns a new LocalSpawnPool.

pub async fn run_until<F>(&self, future: F) -> F::Output

where F: Future + 'static,

Runs a future to completion on the LocalSpawnPool, returning its output.

This returns a future that runs the given future in a LocalSpawnPool, allowing it to call spawn to spawn additional !Send futures. Any futures spawned on the LocalSpawnPool will be driven in the background until the future passed to run_until completes. When the future passed to run_until finishes, any futures which have not completed will remain on the LocalSpawnPool, and will be driven on subsequent calls to run_until or when awaiting the LocalSpawnPool itself.

pub fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>

where F: Future + 'static,

Spawns a !Send task onto the LocalSpawnPool.

This task is guaranteed to be run on the current thread.

Unlike the free function spawn, this method may be used to spawn local tasks when the LocalSpawnPool is not running. The provided future will start running once the LocalSpawnPool is next started, even if you don’t await the returned JoinHandle.

Trait Implementations

impl Default for LocalSpawnPool

fn default() -> Self

Returns the “default value” for a type.

impl Future for LocalSpawnPool

See Awaiting the LocalSpawnPool.

type Output = ()

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.