#thread #control #execution #execution-status

thread-control

Rust library to control threads' execution/status

3 releases

Uses old Rust 2015

0.1.2 Apr 27, 2017
0.1.1 Sep 21, 2016
0.1.0 Sep 21, 2016

#795 in Concurrency

Download history 260/week @ 2024-03-31 295/week @ 2024-04-07 275/week @ 2024-04-14 258/week @ 2024-04-21 149/week @ 2024-04-28 135/week @ 2024-05-05 153/week @ 2024-05-12 98/week @ 2024-05-19 241/week @ 2024-05-26 99/week @ 2024-06-02 167/week @ 2024-06-09 144/week @ 2024-06-16 111/week @ 2024-06-23 79/week @ 2024-06-30 141/week @ 2024-07-07 125/week @ 2024-07-14

481 downloads per month
Used in 3 crates (2 directly)

MIT/Apache

7KB
67 lines

Thread-control library

Missing Rust features to control threads execution.

Example:

use std::thread;
use thread_control::*;

fn main() {
    let (flag, control) = make_pair();
    let handle = thread::spawn(move || {
        while flag.alive() {
        }
    });
    assert_eq!(control.is_done(), false);
    control.stop(); // Also you can `control.interrupt()` it
    handle.join();
    assert_eq!(control.is_interrupted(), false);
    assert_eq!(control.is_done(), true);
}

License

Licensed under either of

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.


lib.rs:

Library to control thread execution.

Usage example:

use std::thread;
use thread_control::*;

fn main() {
    let (flag, control) = make_pair();
    let handle = thread::spawn(move || {
        while flag.alive() {
        }
    });
    assert_eq!(control.is_done(), false);
    control.stop();
    handle.join();
    assert_eq!(control.is_interrupted(), false);
    assert_eq!(control.is_done(), true);
}

Interrupt example:

use std::thread;
use thread_control::*;

fn main() {
    let (flag, control) = make_pair();
    let handle = thread::spawn(move || {
        while flag.alive() {
        }
    });
    control.interrupt();
    handle.join();
    assert_eq!(control.is_interrupted(), true);
    assert_eq!(control.is_done(), true);
}

Panics example:

use std::thread;
use thread_control::*;

fn main() {
    let (flag, control) = make_pair();
    let handle = thread::spawn(move || {
        while flag.alive() {
            panic!("PANIC!");
        }
    });
    handle.join();
    assert_eq!(control.is_interrupted(), true);
    assert_eq!(control.is_done(), true);
}

No runtime deps