Crate hybridfutex

source ·
Expand description

HybridFutex Documentation MIT licensed

HybridFutex is a Rust library that provides a synchronization primitive that allows threads to wait for a notification from another thread. It is designed to be low-overhead and scalable and supports both synchronous and asynchronous waiting and notification.


  • Support Notify many operations on any target.
  • Support for synchronous and asynchronous waiting.
  • Built-in fairness and scalability for high-contention scenarios.
  • Efficient kernel-assisted blocking using park API.
  • Low-latency waiting and notification on both Windows and Unix platforms.
  • Cross-platform compatibility with no external dependencies.
  • Simple and easy-to-use API.


To use HybridFutex, simply add it as a dependency in your Cargo.toml file:

hybrid-futex = "0.1"

Then, you can use HybridFutex in your Rust code as follows:

use std::sync::Arc;
use std::thread;
use std::time::Duration;
use hybridfutex::HybridFutex;

let wait_queue = Arc::new(HybridFutex::new());
let wait_queue_clone = wait_queue.clone();

// Spawn a thread that waits for a notification from another thread
let handle = thread::spawn(move || {
    println!("Thread 1 is waiting");
    println!("Thread 1 is notified");

// Wait for a short time before notifying the other thread

// Notify the other thread

// Wait for the other thread to finish


This project is licensed under the MIT License - see the LICENSE file for details.


  • This library is inspired by the futex system-call in Linux.


  • A HybridFutex is a synchronization primitive that allows threads to wait for a notification from another thread. The HybridFutex maintains a counter that represents the number of waiters, and a queue of waiters. The counter is incremented when a thread calls wait_sync or wait_async methods, and decremented when a thread calls notify_one or notify_many methods. A thread calling wait_sync or wait_async is blocked until it is notified by another thread calling notify_one or notify_many.
  • A future representing a thread that is waiting for a notification from another thread using a HybridFutex synchronization primitive.