implement Send and Sync on ffi pointer type

main.rs

#[macro_use]
extern crate lazy_static;

use std::collections::HashMap;
use std::sync::{Mutex, Arc};
use std::thread;

lazy_static! {
    static ref bank: Mutex<HashMap<Man, u32>> = Mutex::new({
        let mut m = HashMap::new();
        m
    });

    static ref counter: Mutex<u32> = Mutex::new(0);
}

#[derive(Debug, Hash, PartialEq, Eq)]
struct Man {
    name: String,
    age: u8,
    secret: Secret,
}

unsafe impl Send for Man {}
unsafe impl Sync for Man {}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash,)]
struct Secret(*const[u8]);
unsafe impl Send for Secret {}
unsafe impl Sync for Secret {}


fn main() {
    let secret = vec![3, 2, 1];
    let ptr = Box::into_raw(secret.into_boxed_slice());
    let s = Secret(ptr);

    let handle = thread::spawn(move || {
        let mut guard = bank.lock().unwrap();
        let secret = vec![3, 2, 1];
        (*guard).insert(Man {
            name: String::from("juju"),
            age: 36,
            secret: s,
        }, 10000);

        (*guard).insert(Man {
            name: String::from("Bill"),
            age: 40,
            secret: s,
        }, 1234);
    });

    handle.join();

    let guard = bank.lock().unwrap();
    let secret = vec![3, 2, 1];
    let money = guard.get(&Man{
        name: String::from("juju"),
        age: 36,
        secret: s,
    });
    println!("juju has {:?}", money);

    test();
}


fn test() {
    let mut handles = vec![];

    for _ in 0..10 {
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();

            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}