Crate thread_priority

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

• pub use windows::*;

Modules

• windows
  This module defines the windows thread control.

Structs

• Thread
  Represents an OS thread.
• ThreadBuilder
  A copy of the std::thread::Builder builder allowing to set priority settings.
• ThreadPriorityOsValue
  Platform-specific thread priority value.
• ThreadPriorityValue
  Platform-independent thread priority value. Should be in [0; 100) range. The higher the number is - the higher the priority.

Enums

• Error
  A error type
• ThreadPriority
  Thread priority enumeration.

Traits

• ThreadBuilderExt
  Adds thread building functions using the priority.
• ThreadScopeExt
  Adds scoped thread building functions using the priority.

Functions

• spawn
  Spawns a thread with the specified priority.
• spawn_careless
  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.
• spawn_scoped
  Spawns a scoped thread with the specified priority.
• spawn_scoped_careless
  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.