2 releases

✓ Uses Rust 2018 edition

0.1.1 Dec 2, 2019
0.1.0 Dec 2, 2019

#119 in Concurrency

MIT license

249 lines

run-down Build Status codecov GitHub license Dependabot Status

The run-down crate provides an implementation of run-down protection.


Run-down protection as a pattern is useful in situations where re-initialization or destruction of a shared resource is required in a SMP environment.

The pattern has two parts, a means to guarantee the resource is accessible and remains so for the during of it's usage. As well as way to make the resource inaccessible from a point going forward and the ability to wait for all outstanding usages to drain so you can safely perform the required operation.

This crate was inspired by the run-down protection primitive in the NT kernel. Where it's used in situations such as driver unload, where futher access to the driver needs to be rejected and the unloading thread must wait for inflight acesss to stop before the driver can be completely unload.




use run_down::{
use std::sync::Arc;
use std::thread;
use std::time::Duration;

let rundown = Arc::new(RundownRef::new());

for i in 1..25 {

    let rundown_clone = Arc::clone(&rundown);

    thread::spawn(move || {
        // Attempt to acquire rundown protection, while the main
        // thread could be running down the object as we execute.
        match rundown_clone.try_acquire() {
            Ok(run_down_guard) => {
                println!("{}: Run-down protection acquired.", i);

                // Stall the thread while holding rundown protection.
            Err(m) => {
                println!("{}: Failed to acquire run-down protection - {:?}", i, m);

println!("0: Waiting for rundown to complete");
println!("0: Rundown complete");


  • Add a more interesting real-world example.

  • Add some benchmarks to see if there is any opportunity to optimize the implementation.

Note: This crate is not created by, affiliated with, or supported by Microsoft.


~12K SLoC