Unexpected panics when using async functions with tokio in Rust core project
I'm working with an scenario with my Rust application that uses the tokio runtime. Specifically, I'm getting unexpected panics when I try to execute an async function that interacts with a shared state. The panic occurs intermittently, and I suspect it might be related to how I manage the state across different tasks. Here's a simplified version of my code: ```rust use std::sync::{Arc, Mutex}; use tokio::task; struct SharedState { counter: usize, } #[tokio::main] async fn main() { let state = Arc::new(Mutex::new(SharedState { counter: 0 })); let mut handles = vec![]; for _ in 0..10 { let state_clone = Arc::clone(&state); let handle = task::spawn(async move { for _ in 0..100 { let mut lock = state_clone.lock().unwrap(); lock.counter += 1; } }); handles.push(handle); } for handle in handles { handle.await.unwrap(); } println!("Final counter: {}", state.lock().unwrap().counter); } ``` I've tried wrapping the `lock()` calls with behavior handling to catch potential issues like the mutex being poisoned, but the panics still happen. The behavior message I see is often `thread 'tokio-runtime-worker' panicked at 'called `Option::unwrap()` on a `None` value'`. This indicates that I might be accessing something that is not initialized correctly, but I need to find where the scenario lies. I also checked that the `tokio` version I'm using is 1.0.0. Could this be a question with the way I'm structuring my async tasks, or is there a better way to handle shared state in a concurrent environment? Any insights or suggestions would be greatly appreciated!