Please check my design is reasonable？

[jokemanfire]

This is my design demon , any one can see my design is reasonable???

#[derive(Default)]
struct Comm{
    index: i64
}
impl Comm {
    pub fn get_index(&self)-> i64{
        self.index
    }
    pub fn get_index_mut(&mut self) -> i64{
        self.index
    }
    pub fn set_index_mut(&mut self,new_index : i64) {
        self.index = new_index
    }
}

#[tokio::main]
async fn main(){
    let hs: HashMap<String, RwLock<Comm>> = HashMap::new();
    let mps = Arc::new(RwLock::new(hs));
    let mps_1 = mps.clone();
    let t1 = tokio::spawn(async move {
     
        loop{
            let mut k  = mps_1.write().await;
            k.insert("k".to_string(), RwLock::new(Comm::default()));
            drop(k);
            tokio::time::sleep(Duration::from_secs(1)).await;
        }
    });
    let mps_2 = mps.clone();
    let t2 = tokio::spawn(async move{
        loop{
            let k = mps_2.read().await;
            if let Some(c) = k.get("k"){
                let mut tm = c.write().await;
                tm.get_index_mut();
                println!("tm")
            }
            tokio::time::sleep(Duration::from_secs(1)).await;
        }
      
    });
    t1.await;
    t2.await;
}

Because , I will encounter the hashmap change in any threads. But some threads only need read , the object pointed to by hashmap may be mutable or immutable, so hashmap objects are added with read-write locks. I hope to obtain hashmaps with a shorter lifecycle, while the lifecycle of the objects pointed to by hashmaps may be longer.

[jokemanfire]

I don't know how Rust allows read locks when write locks are occupied, because some requirements allow dirty data to be read in phantom