#thread #control #futures #threads

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

#723 in Asynchronous

Download history 153/week @ 2022-12-02 280/week @ 2022-12-09 121/week @ 2022-12-16 179/week @ 2022-12-23 101/week @ 2022-12-30 160/week @ 2023-01-06 151/week @ 2023-01-13 126/week @ 2023-01-20 112/week @ 2023-01-27 147/week @ 2023-02-03 478/week @ 2023-02-10 292/week @ 2023-02-17 180/week @ 2023-02-24 267/week @ 2023-03-03 373/week @ 2023-03-10 285/week @ 2023-03-17

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