Crate thread_priority

source ·
Expand description

Thread priority. A library for changing thread’s priority.

§Usage

Setting thread priority to minimum:

use thread_priority::*;

assert!(set_current_thread_priority(ThreadPriority::Min).is_ok());
// Or like this:
assert!(ThreadPriority::Min.set_for_current().is_ok());

§More examples

§Minimal cross-platform examples

Setting current thread’s priority to minimum:

use thread_priority::*;

assert!(set_current_thread_priority(ThreadPriority::Min).is_ok());

The same as above but using a specific value:

use thread_priority::*;
use std::convert::TryInto;

// The lower the number the lower the priority.
assert!(set_current_thread_priority(ThreadPriority::Crossplatform(0.try_into().unwrap())).is_ok());

§Building a thread using the ThreadBuilderExt trait

use thread_priority::*;
use thread_priority::ThreadBuilderExt;

let thread = std::thread::Builder::new()
    .name("MyNewThread".to_owned())
    .spawn_with_priority(ThreadPriority::Max, |result| {
        // This is printed out from within the spawned thread.
        println!("Set priority result: {:?}", result);
        assert!(result.is_ok());
}).unwrap();
thread.join();

// This also support scoped thread.
let x = 0;
std::thread::scope(|s|{
    std::thread::Builder::new()
        .name("MyNewThread".to_owned())
        .spawn_scoped_with_priority(s, ThreadPriority::Max, |result| {
            // This is printed out from within the spawned thread.
            println!("Set priority result: {:?}", result);
            assert!(result.is_ok());
            dbg!(&x);
    }).unwrap();
});

§Building a thread using the ThreadScopeExt trait

use thread_priority::*;
let x = 0;
std::thread::scope(|s|{
    s.spawn_with_priority(ThreadPriority::Max, |result| {
            // This is printed out from within the spawned thread.
            println!("Set priority result: {:?}", result);
            assert!(result.is_ok());
            dbg!(&x);
    });
});

§Building a thread using the ThreadBuilder.

use thread_priority::*;

let thread = ThreadBuilder::default()
    .name("MyThread")
    .priority(ThreadPriority::Max)
    .spawn(|result| {
        // This is printed out from within the spawned thread.
        println!("Set priority result: {:?}", result);
        assert!(result.is_ok());
}).unwrap();
thread.join();

// Another example where we don't care about the priority having been set.
let thread = ThreadBuilder::default()
    .name("MyThread")
    .priority(ThreadPriority::Max)
    .spawn_careless(|| {
        // This is printed out from within the spawned thread.
        println!("We don't care about the priority result.");
}).unwrap();
thread.join();

// Scoped thread is also supported if the compiler version is at least 1.63.
let mut x = 0;
std::thread::scope(|s|{
    let thread = ThreadBuilder::default()
        .name("MyThread")
        .priority(ThreadPriority::Max)
        .spawn_scoped(s, |result| {
            // This is printed out from within the spawned thread.
            println!("Set priority result: {:?}", result);
            assert!(result.is_ok());
            x += 1;
    }).unwrap();
    thread.join();
});
assert_eq!(x, 1);

// Scoped thread also has a "careless" mode.
std::thread::scope(|s|{
    let thread = ThreadBuilder::default()
        .name("MyThread")
        .priority(ThreadPriority::Max)
        .spawn_scoped_careless(s, || {
            // This is printed out from within the spawned thread.
            println!("We don't care about the priority result.");
            x += 1;
    }).unwrap();
    thread.join();
});
assert_eq!(x, 2);

§Using ThreadExt trait on the current thread

use thread_priority::*;

assert!(std::thread::current().get_priority().is_ok());
println!("This thread's native id is: {:?}", std::thread::current().get_native_id());

Re-exports§

Modules§

  • This module defines the unix thread control.

Structs§

Enums§

Traits§

Functions§

  • Spawns a thread with the specified priority.
  • Spawns a thread with the specified priority. This is different from spawn in a way that the passed function doesn’t need to accept the ThreadPriority::set_for_current result. In case of an error, the error is logged using the logging facilities.
  • Spawns a scoped thread with the specified priority.
  • Spawns a scoped thread with the specified priority. This is different from spawn_scoped in a way that the passed function doesn’t need to accept the ThreadPriority::set_for_current result. In case of an error, the error is logged using the logging facilities.