Rust Multithreading only lock specific indices of vector - multithreading

Question

Situation
I have an array of f32
I have some threads that each will change a small part of the array
I do not know which indices will be changed
Every thread has to lock the array and then spend some time on an expensive calculation
Afterwards, it will change the index and release the array
Take a look at the commented minimal example below
The Problem
The first thread will lock the array and other threads can not edit it anymore. Thus wasting a lot of time. Other threads that need to edit different indices and would never touch the ones required by the first thread could have been executed at the same time.
Possible Solution
I know that the array outlives all threads so unsafe Rust is a viable option
I already posted a solution using the AtomicFloat external crate.
You may come up with a stdlib-only solution.
Minimal example:
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
use rand::Rng;
fn main() {
// Store the mutex
let container = Arc::new(Mutex::new([0.0; 10]));
// This will keep track of the created threads
let mut threads = vec![];
// Create new Threads
for _ in 0..10 {
// Create a copy of the mutex reference
let clone = Arc::clone(&container);
threads.push(thread::spawn(move || {
// The function somehow calculates the index that has to be changed
// In our case its simulated by picking a random index to emphasize that we do not know the index
let mut rng = rand::thread_rng();
let index = rng.gen_range(0..10);
// Unfortuantely we have to lock the array before the intense calculation !!!
// If we could just lock the index of the array, other threads could change other indices in parallel
// But now all of them need to wait for the lock
let mut myarray = clone.lock().unwrap();
// simulate intense calculation
thread::sleep(Duration::from_millis(1000));
// Now the index can be changed
println!("Changing index {}", index);
myarray[index] += 1.0;
}));
}
// Wait for all threads to finish
for thread in threads {
thread.join().unwrap();
}
// I know that myarray outlives the runtime of all threads.
// Therefore someone may come up with an unsafe solution
// Print the result
println!("{:?}", container);
}

Answer 1

This is a solution I came up with using the atomic_float crate.
Introduction to scoped threads
AtomicF32 docs
It works because the scoped thread ensures that all values live as long as the scope.
AtomicF32 protects the values from concurrent access
Note that this does not lock the index before the heavy work. When describing my problem I simplified it a bit. In reality, I had a loop that will often access the data thus almost constantly locking the array
use atomic_float::AtomicF32;
use rand::Rng;
use std::sync::atomic::Ordering;
use std::thread::{self, sleep};
use std::time::Duration;
fn main() {
// Create a new atomic float array
// atomic floats ensure that the value is protected from concurrent access
// Thus locking only the indecies
// Notice the array is not mutable
let myarray = [
AtomicF32::new(0.0),
AtomicF32::new(0.0),
AtomicF32::new(0.0),
AtomicF32::new(0.0),
AtomicF32::new(0.0),
AtomicF32::new(0.0),
AtomicF32::new(0.0),
AtomicF32::new(0.0),
AtomicF32::new(0.0),
AtomicF32::new(0.0),
];
// This is a scoped thread
thread::scope(|s| {
// The loop has to be inside the scope
// All threads spawned within thread::scope must terminate before thread::scope can return
// That's how it makes sure the scoped variables exist at least as long as the spawned threads
for _ in 0..10 {
//Create a new thread
s.spawn(|| {
let mut rng = rand::thread_rng();
let index = rng.gen_range(0..10);
// Simulate heavy work
sleep(Duration::from_millis(3000));
// Now the index can be changed
println!("Changing index {}", index);
// This is the atomic operation. The value is therefore protected from concurrent access
myarray[index].fetch_add(1.0, Ordering::SeqCst)
});
}
});
println!("{:?}", myarray);
}