Struct CurrentThreadRuntime 

pub struct CurrentThreadRuntime { /* private fields */ }

A current thread runtime allows callers to much more explicitly drive Vortex futures than with a Tokio runtime.

The current thread runtime will do no work unless block_on is called. In other words, the default behavior is single-threaded with code running on the thread that called block_on.

It’s also possible to clone the runtime onto other threads, each of which can call block_on to drive work on that thread. Each thread shares the same underlying executor with the same set of tasks, allowing work to be driven in parallel.

For automatic driving of work, a CurrentThreadWorkerPool can be created from the runtime by calling new_pool. The returned pool can be configured with the desired number of worker threads that will drive work on behalf of the runtime.

Implementations

impl CurrentThreadRuntime

pub fn new() -> Self

Create a new current thread runtime.

pub fn new_pool(&self) -> CurrentThreadWorkerPool

Create a new worker pool for driving the runtime in the background.

This pool can be used to offload work from the current thread to a set of worker threads that will drive the runtime’s executor.

By default, the pool has no worker threads; the caller must set the desired number of worker threads using the set_workers method on the returned pool.

pub fn block_on_stream_thread_safe<F, S, R>( &self, f: F, ) -> ThreadSafeIterator<R>

where F: FnOnce(Handle) -> S, S: Stream<Item = R> + Send + 'static, R: Send + 'static,

Returns an iterator wrapper around a stream, blocking the current thread for each item.

Multi-threaded Usage

To drive the iterator from multiple threads, simply clone it and call next() on each clone. Results on each thread are ordered with respect to the stream, but there is no ordering guarantee between threads.

Trait Implementations

impl BlockingRuntime for CurrentThreadRuntime

type BlockingIterator<'a, R: 'a> = CurrentThreadIterator<'a, R>

Associated type for the blocking iterator returned by block_on_stream.

fn handle(&self) -> Handle

Returns a handle to the runtime.

fn block_on<Fut, R>(&self, fut: Fut) -> R

where Fut: Future<Output = R>,

Runs a future to completion on the runtime, blocking the current thread until it completes.

fn block_on_stream<'a, S, R>(&self, stream: S) -> Self::BlockingIterator<'a, R>

where S: Stream<Item = R> + Send + 'a, R: Send + 'a,

Returns an iterator wrapper around a stream, blocking the current thread for each item.

impl Clone for CurrentThreadRuntime

fn clone(&self) -> CurrentThreadRuntime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for CurrentThreadRuntime

fn default() -> CurrentThreadRuntime

Returns the “default value” for a type.