[−][src]Struct async_thread::Builder
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();
Methods
impl Builder
[src]
pub fn new() -> Self
[src]
Generates the base configuration for spawning a thread, from which configuration methods can be chained.
Examples
let builder = async_thread::Builder::new() .name("foo".into()) .stack_size(32 * 1024); let handler = builder.spawn(|| { // thread code }).unwrap(); handler.join().await.unwrap();
pub fn name(self, name: String) -> Self
[src]
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 the std::thread documentation.
Examples
let builder = async_thread::Builder::new() .name("foo".into()); let handler = builder.spawn(|| { assert_eq!(thread::current().name(), Some("foo")) }).unwrap(); handler.join().await.unwrap();
pub fn stack_size(self, size: usize) -> Self
[src]
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 the std::thread documentation.
Examples
let builder = async_thread::Builder::new().stack_size(32 * 1024);
pub fn spawn<F, T>(self, f: F) -> Result<JoinHandle<T>> where
F: FnOnce() -> T,
F: Send + 'static,
T: Send + 'static,
[src]
F: FnOnce() -> T,
F: Send + 'static,
T: Send + 'static,
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 async_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
let builder = async_thread::Builder::new(); let handler = builder.spawn(|| { // thread code }).unwrap(); handler.join().await.unwrap();
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for Builder
impl Send for Builder
impl Sync for Builder
impl Unpin for Builder
impl UnwindSafe for Builder
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, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = !
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>,