Struct tokio_util::task::LocalPoolHandle

pub struct LocalPoolHandle { /* private fields */ }

This is supported on crate feature rt only.

A handle to a local pool, used for spawning !Send tasks.

Implementations

impl LocalPoolHandle

pub fn new(pool_size: usize) -> LocalPoolHandle

Create a new pool of threads to handle !Send tasks. Spawn tasks onto this pool via LocalPoolHandle::spawn_pinned.

Panics

Panics if the pool size is less than one.

pub fn spawn_pinned<F, Fut>(&self, create_task: F) -> JoinHandle<Fut::Output> where
    F: FnOnce() -> Fut,
    F: Send + 'static,
    Fut: Future + 'static,
    Fut::Output: Send + 'static, 

Spawn a task onto a worker thread and pin it there so it can’t be moved off of the thread. Note that the future is not Send, but the FnOnce which creates it is.

Examples

use std::rc::Rc;
use tokio_util::task::LocalPoolHandle;

#[tokio::main]
async fn main() {
    // Create the local pool
    let pool = LocalPoolHandle::new(1);

    // Spawn a !Send future onto the pool and await it
    let output = pool
        .spawn_pinned(|| {
            // Rc is !Send + !Sync
            let local_data = Rc::new("test");

            // This future holds an Rc, so it is !Send
            async move { local_data.to_string() }
        })
        .await
        .unwrap();

    assert_eq!(output, "test");
}

Trait Implementations

impl Clone for LocalPoolHandle

fn clone(&self) -> LocalPoolHandle

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LocalPoolHandle

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.