[−][src]Struct blocking_permit::DispatchPool
A specialized thread pool and queue for dispatching blocking (synchronous, long running) operations.
This pool is not an executor, has no waking facilities, etc. As
compared with other thread pools supporting spawn_dispatch
(here called
just dispatch
or dispatch_rx
), for example in tokio and async-std,
this pool has some unique features:
-
A configurable, fixed number of threads created before return from construction and terminated on
Drop::drop
. Consistent memory footprint. No warmup required. No per-task thread management overhead. -
Configurable panic handling policy: Either catches and logs dispatch panics, or aborts the process, on panic unwind.
-
Supports fixed (bounded) or unbounded queue length.
-
When the queue is bounded and becomes full,
DispatchPool::spawn
pops the oldest operation off the queue before pushing the newest passed operation, to ensure space while holding a lock. Then as a fallback it runs the old operation. Thus we enlist calling threads once the queue reaches limit, but operation order (at least from perspective of a single thread) is preserved.
Usage
By default, the pool uses an unbounded queue, with the assumption that resource/capacity is externally constrained. Once constructed, a fixed number of threads are spawned and the instance acts as a handle to the pool. This may be inexpensively cloned for additional handles to the same pool.
See DispatchPoolBuilder
for an extensive set of options.
With tokio's threaded runtime
One can schedule a clone of the DispatchPool
(handle) on each tokio
runtime thread (tokio's rt-threaded feature).
use blocking_permit::{ DispatchPool, register_dispatch_pool, deregister_dispatch_pool }; let pool = DispatchPool::builder().create(); let mut rt = tokio::runtime::Builder::new() .threaded_scheduler() .on_thread_start(move || { register_dispatch_pool(pool.clone()); }) .on_thread_stop(|| { deregister_dispatch_pool(); }) .build() .unwrap();
Implementations
impl DispatchPool
[src]
pub fn new() -> DispatchPool
[src]
Create new pool using defaults.
pub fn builder() -> DispatchPoolBuilder
[src]
Create a new builder for configuring a new pool.
pub fn spawn(&self, f: Box<dyn FnOnce() + Send>)
[src]
Enqueue a blocking operation to be executed.
This first attempts to send to the associated queue, which will always
succeed if unbounded, e.g. no DispatchPoolBuilder::queue_length
is set, the default. If however the queue is bounded and at capacity,
then this task will be pushed after taking the oldest task, which is
then run on the calling thread.
Trait Implementations
impl Clone for DispatchPool
[src]
fn clone(&self) -> DispatchPool
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl Debug for DispatchPool
[src]
impl Default for DispatchPool
[src]
Auto Trait Implementations
impl !RefUnwindSafe for DispatchPool
impl Send for DispatchPool
impl Sync for DispatchPool
impl Unpin for DispatchPool
impl !UnwindSafe for DispatchPool
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,