4 ms·

I assume Rust concurrency guarantees will prevent races and have this covered. Except of course if you use unsafe. Right?

• Georgelemental 3y ago
  Will prevent data races, yes.
  • _nalply 3y ago
    Of course I meant data races. Or am I barking up the wrong tree? And of course only if you use safe Rust.
• kevincox 3y ago
  Yes. It is actually fairly tricky to get a value across threads like this. The simplest I could come up with is this: struct UnsafeSync<T>(T); unsafe impl<T> Sync for UnsafeSync<T> {} fn main() { let i = std::sync::Arc::new(UnsafeSync(std::cell::Cell::new(0))); let thread_i = i.clone(); std::thread::spawn(move || { thread_i.0.set(1); }); eprintln!("i is {}", i.0.get()); } https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=5f790043616473095a1be2e405516546 https://play.rust-lang.org/?version=stable&mode=debug&editio...
  • _nalply 3y ago
    Why didn't you use a Mutex?
    • kevincox 3y ago
      What are you thinking? I could have used a Mutex then cast the `&Mutex` to `&mut Mutex` so that I could call `.get_mut()`. But this didn't seem simpler.
      • _nalply 3y ago
        I wanted to avoid unsafe. Because unsafe introduces conceptual complications and it seemed to be simpler to avoid that in an example.
        • kevincox 3y ago
          Well you can't have a memory race without unsafe. The goal of the example was to show undefined behaviour.
          • _nalply 3y ago
            Ah, you wanted to show an example in Rust with unsafe where atomicity was not guaranteed.