Struct tokio::runtime::Builder

pub struct Builder { /* fields omitted */ }

Builds Tokio Runtime with custom configuration values.

Methods can be chained in order to set the configuration values. The Runtime is constructed by calling build.

New instances of Builder are obtained via Builder::new.

See function level documentation for details on the various configuration settings.

Examples

// create and configure ThreadPool
let mut threadpool_builder = tokio_threadpool::Builder::new();
threadpool_builder
    .name_prefix("my-runtime-worker-")
    .pool_size(4);

// build Runtime
let runtime = Builder::new()
    .threadpool_builder(threadpool_builder)
    .build();
// ... call runtime.run(...)

Methods

impl Builder

pub fn new() -> Builder

Returns a new runtime builder initialized with default configuration values.

Configuration methods can be chained on the return value.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn clock(&mut self, clock: Clock) -> &mut Self

Set the Clock instance that will be used by the runtime.

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn core_threads(&mut self, val: usize) -> &mut Self

Set the maximum number of worker threads for the Runtime's thread pool.

This must be a number between 1 and 32,768 though it is advised to keep this value on the smaller side.

The default value is the number of cores available to the system.

Examples

let mut rt = runtime::Builder::new()
    .core_threads(4)
    .build()
    .unwrap();

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn blocking_threads(&mut self, val: usize) -> &mut Self

Set the maximum number of concurrent blocking sections in the Runtime's thread pool.

When the maximum concurrent blocking calls is reached, any further calls to blocking will return NotReady and the task is notified once previously in-flight calls to blocking return.

This must be a number between 1 and 32,768 though it is advised to keep this value on the smaller side.

The default value is 100.

Examples

let mut rt = runtime::Builder::new()
    .blocking_threads(200)
    .build();

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn name_prefix<S: Into<String>>(&mut self, val: S) -> &mut Self

Set name prefix of threads spawned by the Runtime's thread pool.

Thread name prefix is used for generating thread names. For example, if prefix is my-pool-, then threads in the pool will get names like my-pool-1 etc.

The default prefix is "tokio-runtime-worker-".

Examples

let mut rt = runtime::Builder::new()
    .name_prefix("my-pool-")
    .build();

Important traits for &'a mut R

impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn stack_size(&mut self, val: usize) -> &mut Self

Set the stack size (in bytes) for worker threads.

The actual stack size may be greater than this value if the platform specifies minimal stack size.

The default stack size for spawned threads is 2 MiB, though this particular stack size is subject to change in the future.

Examples

let mut rt = runtime::Builder::new()
    .stack_size(32 * 1024)
    .build();

pub fn build(&mut self) -> Result<Runtime>

Create the configured Runtime.

The returned ThreadPool instance is ready to spawn tasks.

Examples

let runtime = Builder::new().build().unwrap();
// ... call runtime.run(...)

Trait Implementations

impl Debug for Builder

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

Formats the value using the given formatter.