How to implement Sync for RustBox? - multithreading

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 {
// ...
}