Struct entangled::ThreadPool

pub struct ThreadPool { /* fields omitted */ }

A thread pool for executing futures.

Drives given futures to completion.

Implementations

impl ThreadPool

pub fn new(descriptor: ThreadPoolDescriptor) -> Result<Self, Error>

Create a new ThreadPool. Thread pools can be freely cloned.

How to provide a custom handler

use entangled::*;

let descriptor = ThreadPoolDescriptor {
    num_threads: 0,
    start_handler: Some(Box::new(|index| {
        println!("Thread {} is starting", index);
    })),
    ..Default::default()
};

let pool = ThreadPool::new(descriptor).unwrap();

pub fn scope<'scope, S, R>(&self, s: S) -> Vec<R> where
    S: FnOnce(&mut Scope<'scope, R>) + 'scope + Send,
    R: Send + 'static, 

Creates a “fork-join” scope s and invokes the closure with a reference to s. This closure can then spawn futures into s. When the closure returns, it will block until all futures that have been spawned into s complete.

In general, spawned futures may access stack data in place that outlives the scope itself. Other data must be fully owned by the spawned future.

pub fn spawn<T>(
    &self,
    future: impl Future<Output = T> + Send + 'static
) -> Task<T> where
    T: Send + 'static, 

Spawns a static future onto the thread pool. The returned Task is a future. It can also be cancelled and “detached” allowing it to continue running without having to be polled by the end-user.

Trait Implementations

impl Clone for ThreadPool

fn clone(&self) -> ThreadPool

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ThreadPool

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

Formats the value using the given formatter.