CODEWITHSUNDEEP
multithreadingrustthread-safetybuffer
seanybaggins
seanybaggins

Reputation: 21

Rust - writing to indices of a vector across multiple threads

I have a circular ring buffer (implemented as a vector) where I want one thread to periodically write to the ring buffer and another to periodically read from the ring buffer. Is it possible to create a vector that can be read and written at the same time so long as threads accessing the vector are not at the same index?

What I am hoping to achieve:

use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

fn main() {

    let vec = Arc::new(vec![Mutex::new(1), Mutex::new(2),Mutex::new(3)]);

    {
        let vec = vec.clone();
        thread::spawn(move|| {
            let mut s2 = *vec.get_mut(2).unwrap().lock().unwrap();
            s2 = 7;
        });
    }

    println!("{}", vec[2].lock().unwrap());
}

Compiler output is:

Compiling playground v0.0.1 (/playground)
warning: variable `s2` is assigned to, but never used
  --> src/main.rs:12:21
   |
12 |             let mut s2 = *vec.get_mut(2).unwrap().lock().unwrap();
   |                     ^^
   |
   = note: `#[warn(unused_variables)]` on by default
   = note: consider using `_s2` instead

warning: value assigned to `s2` is never read
  --> src/main.rs:13:13
   |
13 |             s2 = 7;
   |             ^^
   |
   = note: `#[warn(unused_assignments)]` on by default
   = help: maybe it is overwritten before being read?

error[E0596]: cannot borrow data in an `Arc` as mutable
  --> src/main.rs:12:27
   |
12 |             let mut s2 = *vec.get_mut(2).unwrap().lock().unwrap();
   |                           ^^^ cannot borrow as mutable
   |
   = help: trait `DerefMut` is required to modify through a dereference, but it is not implemented for `std::sync::Arc<std::vec::Vec<std::sync::Mutex<i32>>>`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0596`.
error: could not compile `playground`.

To learn more, run the command again with --verbose.

Foiled by the rust type system trying to prevent a race condition :(

What I don't want

Link to playground:

https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=5b5efe91bdd45c658d11f1cefb16045e

Upvotes: 0

Views: 3555

Answers (1)

Inline
Inline

Reputation: 2863

First, I would recommend you to use std::sync::RwLock, because it allows multiple readers to read data simultaneously.

Second, spawning threads can lead to performance bottlenecks in your code. Try to use thread pool.

Of course, the exact choice will vary depending on the result of benchmarks, but those are general recommendations.

Your code is mostly correct, except one crucial part. You are using Mutex which implements interior mutability pattern and also provides thread-safety.

Interior mutability moves compiletime checks of XOR borrowing rule (either N immutable borrows or just one mutable) to the run-time. So, Mutex ensures that any time there exists only one reader or only one writer.

When you try to get mutable reference from vec, like this

vec.get_mut(..)

You are essentially ignoring benefits provided by interior mutability. Compiler can't guarantee that XOR rule is not broken, because you borrow vec as mutable.

Obvious solution is to borrow vec as immutable and using Mutex to safeguard against race condition and don't utilize compiler borrowing rules.

let mut s2 = vec
    .get(2) // Get immutable reference to second item
    .unwrap() // Ensure that it exists
    .lock() // Lock mutex. 
    .unwrap(); // Ensure mutex isn't poisoned.

// s2 is now `std::sync::MutexGuard<i32>`, which implements `std::ops::DerefMut`, 
// so it can get us mutable reference to data.
*s2 = 7;

Upvotes: 1

Related Questions