Method try_enroll_many

src/thread_pool.rs:827–874

Creates multiple memberships for the thread pool.

(&'static self, n: usize)

        self.with_worker(|worker| worker.join(a, b))
    }

    /// Creates a scope onto which non-static work can be spawned.
    ///
    /// See also: [`Worker::scope`] and [`scope`].
    #[inline(always)]
    pub fn scope<'env, F, T>(&'static self, f: F) -> T
    where
        F: for<'scope> FnOnce(&'scope Scope<'scope, 'env>) -> T,
    {
        self.with_worker(|worker| worker.scope(f))
    }

    /// Runs the same closure on several threads, and returns a vector of
    /// results.
    ///
    /// See also: [`Worker::broadcast`] and [`broadcast`]. If you don't care
    /// about getting results back, you may want to use
    /// [`ThreadPool::spawn_broadcast`] instead.
    #[inline(always)]
    pub fn broadcast<F, T>(&'static self, f: F) -> Vec<T>
    where
        F: for<'w> Fn(Broadcast<'w>) -> T + Sync,
        T: Send,
    {
        self.with_worker(|worker| worker.broadcast(f))
    }

    /// Runs the same closure on sevearl threads, without waiting for them to
    /// complete.
    ///
    /// See also: [`Worker::spawn_broadcast`] and [`spawn_broadcast`]. If you
    /// care about getting results back, you may want to use
    /// [`ThreadPool::broadcast`] instead.
    #[inline(always)]
    pub fn spawn_broadcast<F>(&'static self, f: F)
    where
        F: for<'w> Fn(Broadcast<'w>) + Send + Sync + 'static,
    {
        self.with_worker(|worker| worker.spawn_broadcast(f));
    }
}

// -----------------------------------------------------------------------------
// Worker registration

/// Represents membership in a thread-pool.
///
/// Provided by [`ThreadPool::enroll`].
pub struct Membership {
    /// The thread pool the worker is registered with.
    thread_pool: &'static ThreadPool,