advanced patterns with Rust Core's Mutex when using threads in a no_std environment
I've been struggling with this for a few days now and could really use some help... I'm working on a Rust embedded project using `rust-core` in a `no_std` environment, and I'm working with some unexpected behavior when trying to use a `Mutex`. My goal is to share a mutable state across multiple threads, but it seems that the `Mutex` isn't behaving as I expected. Here's a simplified version of my code: ```rust #![no_std] #![feature(allocator_api)] use core::sync::atomic::{AtomicUsize, Ordering}; use core::sync::Mutex; use core::thread; struct SharedState { counter: AtomicUsize, } fn main() { let state = Mutex::new(SharedState { counter: AtomicUsize::new(0) }); let handles: Vec<_> = (0..10).map(|_| { let state_clone = state.clone(); thread::spawn(move || { let mut data = state_clone.lock().unwrap(); data.counter.fetch_add(1, Ordering::SeqCst); }) }).collect(); for handle in handles { handle.join().unwrap(); } println!("Final count: {}", state.lock().unwrap().counter.load(Ordering::SeqCst)); } ``` When I run this code, I'm getting a panic at the `unwrap()` call on the `lock()`, stating that the mutex is already locked. This happens intermittently, and I need to figure out why. I made sure to join all threads before accessing the mutex again. I've tried switching the ordering from `SeqCst` to `AcquireRelease`, but that didn't change anything. I also checked if there might be a question with the stack size since it’s an embedded environment, but increasing the stack size didn’t help either. I'm using Rust version 1.65.0 and targeting ARM Cortex-M. Can anyone shed light on why the `Mutex` might be deadlocking or behaving unexpectedly in this context? Is there a recommended way to properly use `Mutex` in a `no_std` environment with multiple threads? Any insights or suggestions would be greatly appreciated! My development environment is Linux. This is part of a larger web app I'm building.