Neon example of shared state.

lib.rs

use std::sync::Arc;
use std::sync::RwLock;
use std::collections::HashMap;

#[macro_use]
extern crate neon;
use neon::prelude::*;

pub struct Increment {
    key: String,
    counters: Arc<RwLock<HashMap<String, u64>>>
}

impl Task for Increment {

    type Output = u64;
    type Error = String;
    type JsEvent = JsNumber;

    fn perform(&self) -> Result<Self::Output, Self::Error> {
        let mut counters = self.counters.write().unwrap();
        let counter = counters.entry(self.key.to_owned()).or_insert(0);
        *counter += 1;
        Ok(*counter)
    }

    fn complete(self,
                mut cx: TaskContext,
                result: Result<Self::Output, Self::Error>)
        -> JsResult<Self::JsEvent>
    {
        Ok(cx.number(result.unwrap() as f64))
    }
}

pub struct Counter {
    counters: Arc<RwLock<HashMap<String, u64>>>
}

declare_types! {
    pub class JsCounter for Counter {
        init(mut cx) {
            let counters = Arc::new(RwLock::new(HashMap::new()));
            Ok(Counter { counters })
        }

        method increment(mut cx) {
            let key = {
                let h: Handle<JsString> = cx.argument(0)?;
                h.to_string(&mut cx)?.value()
            };

            let f = cx.argument::<JsFunction>(1)?;
            let this = cx.this();
            let counters = cx.borrow(&this, |obj| Arc::clone(&obj.counters));
            
            let increment = Increment { key, counters };
            increment.schedule(f);

            Ok(cx.undefined().upcast())
        }
    }
}

register_module!(mut cx, {
    cx.export_class::<JsCounter>("Counter")?;
    Ok(())
});