Struct Thread

pub struct Thread<T> { /* private fields */ }

Handle to a stoppable thread.

Implementations

impl<T> Thread<T>

where T: Send + 'static,

pub fn spawn<F>(f: F) -> Thread<T>

where F: FnOnce(Arc<AtomicBool>) -> T + Send + 'static,

Spawn a new job with cancelation.

pub fn join(self) -> Result<T, Box<dyn Any + Send + 'static>>

Join waits for the thread to exit then returns the return value.

Examples found in repository

examples/simple.rs (line 13)

fn main() {
    // spawn our task, this creates a new OS thread.
    let th = stoplight::spawn(|stop| {
        while !stop.load(Ordering::Relaxed) {}
        42
    });

    // stop() signals the thread to stop, and then join returns its return value.
    th.stop();
    assert_eq!(th.join().unwrap(), 42);
}

pub fn stop(&self)

Signal the Thread to stop, To wait for the thread to exit call join.

Examples found in repository

examples/simple.rs (line 12)

fn main() {
    // spawn our task, this creates a new OS thread.
    let th = stoplight::spawn(|stop| {
        while !stop.load(Ordering::Relaxed) {}
        42
    });

    // stop() signals the thread to stop, and then join returns its return value.
    th.stop();
    assert_eq!(th.join().unwrap(), 42);
}

pub fn thread(&self) -> &Thread

Extracts a handle to the underlying thread.

use stoplight;
use std::sync::atomic::{Ordering};

let th = stoplight::spawn(|stop| {
    while !stop.load(Ordering::Relaxed) {}
    42
});

let thread = th.thread();
eprintln!("thread id: {:?}", thread.id());