How to implement Sync for RustBox?

Question

I am new to threads in Rust. I am struggling to pass the RustBox type from the rustbox crate within threads.

I want to press the q key and have it display a + symbol for 2 secs at (1, 1) while I press w key within those 2 secs which shows another + symbol at (1, 2).

I wrote some code for the same logic:

extern crate rustbox;

use std::thread;
use std::time::Duration;

use rustbox::{Color, RustBox};
use rustbox::Key;


fn mark_at(x: usize, y: usize, rustbox: &RustBox) {
    rustbox.print(x, y, rustbox::RB_BOLD, Color::Black, Color::White, "+");
    thread::spawn(move || {
        let delay = Duration::from_millis(2000);
        thread::sleep(delay);
        rustbox.print(x, y, rustbox::RB_BOLD, Color::Black, Color::White, " ");
    });
}


fn main() {
    let rustbox = match RustBox::init(Default::default()) {
        Result::Ok(v) => v,
        Result::Err(e) => panic!("{}", e),
    };
    rustbox.print(1, 1, rustbox::RB_BOLD, Color::Black, Color::White, " ");
    rustbox.print(1, 2, rustbox::RB_BOLD, Color::Black, Color::White, " ");

    loop {
        rustbox.present();
        match rustbox.poll_event(false) {
            Ok(rustbox::Event::KeyEvent(key)) => {
                match key {
                    Key::Char('q') => {
                        mark_at(1, 1, &rustbox);
                    }
                    Key::Char('w') => {
                        mark_at(1, 2, &rustbox);
                    }
                    Key::Esc => { break; }
                    _ => { }
                }
            },
            Err(e) => panic!("{}", e),
            _ => { }
        }
    }
}

It gives me:

error[E0277]: the trait bound `*mut (): std::marker::Sync` is not satisfied in `rustbox::RustBox`
  --> src/main.rs:12:5
   |
12 |     thread::spawn(move || {
   |     ^^^^^^^^^^^^^ `*mut ()` cannot be shared between threads safely
   |
   = help: within `rustbox::RustBox`, the trait `std::marker::Sync` is not implemented for `*mut ()`
   = note: required because it appears within the type `std::marker::PhantomData<*mut ()>`
   = note: required because it appears within the type `rustbox::RustBox`
   = note: required because of the requirements on the impl of `std::marker::Send` for `&rustbox::RustBox`
   = note: required because it appears within the type `[closure@src/main.rs:12:19: 16:6 rustbox:&rustbox::RustBox, x:usize, y:usize]`
   = note: required by `std::thread::spawn`

error: aborting due to previous error

How do I implement Sync for the RustBox type so that above code could work?

Answer 1

RustBox doesn't implement Send, so there is no (safe) way to share it between threads (it seems you already found the not yet merged pull request https://github.com/gchp/rustbox/pull/65 which would support Send).

If the pull request gets merged you could wrap the RustBox in a Mutex, i.e. Mutex<RustBox>, and references to that can be shared between threads.

But then you'll hit lifetime issues: your rustbox reference doesn't live long enough to spawn a new thread using it, so you'll have to wrap it in Arc.

use std::sync::{Arc,Mutex};

fn mark_at(x: usize, y: usize, rustbox: &Arc<Mutex<RustBox>>) {
    rustbox.lock().unwrap().print(x, y, rustbox::RB_BOLD, Color::Black, Color::White, "+");
    let rustbox = rustbox.clone(); // increment reference counter
    thread::spawn(move || {
        let delay = Duration::from_millis(2000);
        thread::sleep(delay);
        rustbox.lock().unwrap().print(x, y, rustbox::RB_BOLD, Color::Black, Color::White, " ");
    });
}

In your main function you'll have to wrap the rustbox:

let rustbox = Arc::new(Mutex::new(rustbox));

and lock() it every time you use it.

Make sure you don't keep the lock too long; it might help to use helper variables to make this more explicit, e.g:

let pe = rustbox.lock().unwrap().poll_event(false);
match pe {
// ...
}