Crate nursery

An implementation of Nathaniel J. Smiths Structured Concurrency model: Notes on Structured Concurrency.

Description

The building block of concurrency is called a Nursery. They can adopt or schedule concurrent operations. Before a Nursery is dropped it will block on all of it’s pending concurrent operations. A Nursery is itself a concurrent operation so it can be adopted by another Nursery to form a hierarchy.

Example

extern crate nursery;
use nursery::thread::{Handle, Pending};
use nursery::{Nursery, Waitable};
use std::sync::Arc;
use std::sync::Mutex;
 
pub struct Counter {
    count: i32,
}
 
impl Counter {
    pub fn incr(&mut self) {
        self.count += 1;
    }
}
 
let counter = Arc::new(Mutex::new(Counter { count: 0 }));
{
    let h_counter = counter.clone();
    let h1 = Pending::new(move || {
        let mut c = h_counter.lock().unwrap();
        c.incr();
    });
    let h_counter = counter.clone();
    let h2 = Pending::new(move || {
        let mut c = h_counter.lock().unwrap();
        c.incr();
    });
    let mut child = Nursery::new();
    child.schedule(Box::new(h1));
    child.schedule(Box::new(h2));
    let mut parent = Nursery::new();
    parent.adopt(child.into());
    // Before parent is dropped all of the above concurrent operations
    // will complete.
}
assert_eq!(counter.lock().unwrap().count, 2);

Re-exports

pub use crate::thread::Handle as ThreadHandle;

Modules

thread

Structs

Nursery

An RAII aware concurrency primitive.

Traits

Schedulable

The trait that as of yet not started concurrent operations must implement.

Waitable

The trait that handles to a concurrent operation must implement.