[−][src]Struct tokio::runtime::Builder
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
extern crate tokio; extern crate tokio_timer; use std::time::Duration; use tokio::runtime::Builder; use tokio_timer::clock::Clock; fn main() { // build Runtime let mut runtime = Builder::new() .blocking_threads(4) .clock(Clock::system()) .core_threads(4) .keep_alive(Some(Duration::from_secs(60))) .name_prefix("my-custom-name-") .stack_size(3 * 1024 * 1024) .build() .unwrap(); // use runtime ... }
Methods
impl Builder
[src]
pub fn new() -> Builder
[src]
Returns a new runtime builder initialized with default configuration values.
Configuration methods can be chained on the return value.
ⓘImportant traits for &'_ mut Wpub fn clock(&mut self, clock: Clock) -> &mut Self
[src]
Set the Clock
instance that will be used by the runtime.
ⓘImportant traits for &'_ mut Wpub fn panic_handler<F>(&mut self, f: F) -> &mut Self where
F: Fn(Box<dyn Any + Send>) + Send + Sync + 'static,
[src]
F: Fn(Box<dyn Any + Send>) + Send + Sync + 'static,
Sets a callback to handle panics in futures.
The callback is triggered when a panic during a future bubbles up to
Tokio. By default Tokio catches these panics, and they will be ignored.
The parameter passed to this callback is the same error value returned
from std::panic::catch_unwind()
. To abort the process on panics, use
std::panic::resume_unwind()
in this callback as shown below.
Examples
let mut rt = runtime::Builder::new() .panic_handler(|err| std::panic::resume_unwind(err)) .build() .unwrap();
ⓘImportant traits for &'_ mut Wpub fn core_threads(&mut self, val: usize) -> &mut Self
[src]
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 &'_ mut Wpub fn blocking_threads(&mut self, val: usize) -> &mut Self
[src]
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 &'_ mut Wpub fn keep_alive(&mut self, val: Option<Duration>) -> &mut Self
[src]
Set the worker thread keep alive duration for threads in the Runtime
's
thread pool.
If set, a worker thread will wait for up to the specified duration for work, at which point the thread will shutdown. When work becomes available, a new thread will eventually be spawned to replace the one that shut down.
When the value is None
, the thread will wait for work forever.
The default value is None
.
Examples
use std::time::Duration; let mut rt = runtime::Builder::new() .keep_alive(Some(Duration::from_secs(30))) .build();
ⓘImportant traits for &'_ mut Wpub fn name_prefix<S: Into<String>>(&mut self, val: S) -> &mut Self
[src]
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 &'_ mut Wpub fn stack_size(&mut self, val: usize) -> &mut Self
[src]
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();
ⓘImportant traits for &'_ mut Wpub fn after_start<F>(&mut self, f: F) -> &mut Self where
F: Fn() + Send + Sync + 'static,
[src]
F: Fn() + Send + Sync + 'static,
Execute function f
after each thread is started but before it starts
doing work.
This is intended for bookkeeping and monitoring use cases.
Examples
let thread_pool = runtime::Builder::new() .after_start(|| { println!("thread started"); }) .build();
ⓘImportant traits for &'_ mut Wpub fn before_stop<F>(&mut self, f: F) -> &mut Self where
F: Fn() + Send + Sync + 'static,
[src]
F: Fn() + Send + Sync + 'static,
Execute function f
before each thread stops.
This is intended for bookkeeping and monitoring use cases.
Examples
let thread_pool = runtime::Builder::new() .before_stop(|| { println!("thread stopping"); }) .build();
pub fn build(&mut self) -> Result<Runtime>
[src]
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
Auto Trait Implementations
impl !Send for Builder
impl Unpin for Builder
impl !Sync for Builder
impl !UnwindSafe for Builder
impl !RefUnwindSafe for Builder
Blanket Implementations
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for 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>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
ⓘImportant traits for &'_ mut Wfn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,