#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

#744 in Concurrency

Download history 173/week @ 2024-07-29 241/week @ 2024-08-05 174/week @ 2024-08-12 89/week @ 2024-08-19 124/week @ 2024-08-26 83/week @ 2024-09-02 96/week @ 2024-09-09 90/week @ 2024-09-16 166/week @ 2024-09-23 173/week @ 2024-09-30 161/week @ 2024-10-07 170/week @ 2024-10-14 288/week @ 2024-10-21 365/week @ 2024-10-28 209/week @ 2024-11-04 241/week @ 2024-11-11

1,115 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