Struct otter::prelude::thread::Builder 1.0.0[−][src]
pub struct Builder { /* fields omitted */ }
Expand description
Thread factory, which can be used in order to configure the properties of a new thread.
Methods can be chained on it in order to configure it.
The two configurations available are:
name
: specifies an associated name for the threadstack_size
: specifies the desired stack size for the thread
The spawn
method will take ownership of the builder and create an
io::Result
to the thread handle with the given configuration.
The thread::spawn
free function uses a Builder
with default
configuration and unwrap
s its return value.
You may want to use spawn
instead of thread::spawn
, when you want
to recover from a failure to launch a thread, indeed the free function will
panic where the Builder
method will return a io::Result
.
Examples
use std::thread; let builder = thread::Builder::new(); let handler = builder.spawn(|| { // thread code }).unwrap(); handler.join().unwrap();
Implementations
Generates the base configuration for spawning a thread, from which configuration methods can be chained.
Examples
use std::thread; let builder = thread::Builder::new() .name("foo".into()) .stack_size(32 * 1024); let handler = builder.spawn(|| { // thread code }).unwrap(); handler.join().unwrap();
Names the thread-to-be. Currently the name is used for identification only in panic messages.
The name must not contain null bytes (\0
).
For more information about named threads, see this module-level documentation.
Examples
use std::thread; let builder = thread::Builder::new() .name("foo".into()); let handler = builder.spawn(|| { assert_eq!(thread::current().name(), Some("foo")) }).unwrap(); handler.join().unwrap();
Sets the size of the stack (in bytes) for the new thread.
The actual stack size may be greater than this value if the platform specifies a minimal stack size.
For more information about the stack size for threads, see this module-level documentation.
Examples
use std::thread; let builder = thread::Builder::new().stack_size(32 * 1024);
Spawns a new thread by taking ownership of the Builder
, and returns an
io::Result
to its JoinHandle
.
The spawned thread may outlive the caller (unless the caller thread is the main thread; the whole process is terminated when the main thread finishes). The join handle can be used to block on termination of the child thread, including recovering its panics.
For a more complete documentation see thread::spawn
.
Errors
Unlike the spawn
free function, this method yields an
io::Result
to capture any failure to create the thread at
the OS level.
Panics
Panics if a thread name was set and it contained null bytes.
Examples
use std::thread; let builder = thread::Builder::new(); let handler = builder.spawn(|| { // thread code }).unwrap(); handler.join().unwrap();
pub unsafe fn spawn_unchecked<'a, F, T>(
self,
f: F
) -> Result<JoinHandle<T>, Error> where
F: FnOnce() -> T + Send + 'a,
T: Send + 'a,
[src]🔬 This is a nightly-only experimental API. (thread_spawn_unchecked
)
pub unsafe fn spawn_unchecked<'a, F, T>(
self,
f: F
) -> Result<JoinHandle<T>, Error> where
F: FnOnce() -> T + Send + 'a,
T: Send + 'a,
[src]thread_spawn_unchecked
)Spawns a new thread without any lifetime restrictions by taking ownership
of the Builder
, and returns an io::Result
to its JoinHandle
.
The spawned thread may outlive the caller (unless the caller thread is the main thread; the whole process is terminated when the main thread finishes). The join handle can be used to block on termination of the child thread, including recovering its panics.
This method is identical to thread::Builder::spawn
,
except for the relaxed lifetime bounds, which render it unsafe.
For a more complete documentation see thread::spawn
.
Errors
Unlike the spawn
free function, this method yields an
io::Result
to capture any failure to create the thread at
the OS level.
Panics
Panics if a thread name was set and it contained null bytes.
Safety
The caller has to ensure that no references in the supplied thread closure or its return type can outlive the spawned thread’s lifetime. This can be guaranteed in two ways:
- ensure that
join
is called before any referenced data is dropped - use only types with
'static
lifetime bounds, i.e., those with no or only'static
references (boththread::Builder::spawn
andthread::spawn
enforce this property statically)
Examples
#![feature(thread_spawn_unchecked)] use std::thread; let builder = thread::Builder::new(); let x = 1; let thread_x = &x; let handler = unsafe { builder.spawn_unchecked(move || { println!("x = {}", *thread_x); }).unwrap() }; // caller has to ensure `join()` is called, otherwise // it is possible to access freed memory if `x` gets // dropped before the thread closure is executed! handler.join().unwrap();
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for Builder
impl UnwindSafe for Builder
Blanket Implementations
Mutably borrows from an owned value. Read more
Convert Box<dyn Trait>
(where Trait: Downcast
) to Box<dyn Any>
. Box<dyn Any>
can
then be further downcast
into Box<ConcreteType>
where ConcreteType
implements Trait
. Read more
Convert Rc<Trait>
(where Trait: Downcast
) to Rc<Any>
. Rc<Any>
can then be
further downcast
into Rc<ConcreteType>
where ConcreteType
implements Trait
. Read more
Convert &Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &Any
’s vtable from &Trait
’s. Read more
Convert &mut Trait
(where Trait: Downcast
) to &Any
. This is needed since Rust cannot
generate &mut Any
’s vtable from &mut Trait
’s. Read more
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
[src]
pub fn dyn_cast<T>(
self
) -> Result<<A as DynCastExtHelper<T>>::Target, <A as DynCastExtHelper<T>>::Source> where
T: ?Sized,
A: DynCastExtHelper<T>,
[src]Use this to cast from one trait object type to another. Read more
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
[src]
pub fn dyn_upcast<T>(self) -> <A as DynCastExtAdvHelper<T, T>>::Target where
T: ?Sized,
A: DynCastExtAdvHelper<T, T, Source = <A as DynCastExtAdvHelper<T, T>>::Target>,
[src]Use this to upcast a trait to one of its supertraits. Read more
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
F: ?Sized,
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
[src]
pub fn dyn_cast_adv<F, T>(
self
) -> Result<<A as DynCastExtAdvHelper<F, T>>::Target, <A as DynCastExtAdvHelper<F, T>>::Source> where
F: ?Sized,
T: ?Sized,
A: DynCastExtAdvHelper<F, T>,
[src]pub fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
[src]
pub fn dyn_cast_with_config<C>(
self
) -> Result<<A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Target, <A as DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>>::Source> where
C: DynCastConfig,
A: DynCastExtAdvHelper<<C as DynCastConfig>::Source, <C as DynCastConfig>::Target>,
[src]Use this to cast from one trait object type to another. With this method the type parameter is a config type that uniquely specifies which cast should be preformed. Read more
type Output = T
type Output = T
Should always be Self
pub fn vzip(self) -> V