Are nested lock recommended?

[siddharthteli12]

struct Outer {
    map: Arc<RwLock<HashMap<String, Inner>>>,
}

struct Inner {
    inner_map: RwLock<HashMap<String, String>>,
}
impl Outer {
    fn add(&self, key: String, val: String) {
        self.map
            .read()
            .get("test")
            .unwrap()
            .inner_map
            .write()
            .insert(key, val);
    }
}

• Does this code snippet make any sense.
• Will it provide any benefit in performance over single RwLock
• Is it ok to acquire read lock on outer and write lock on inner RwLock
• How is concurrency handled in this scenario?
• I could feel this code is susceptible to deadlocks. But still is there any use case for this pattern or its completely useless?
• Any resource to learn more about locks?

[Amanieu]

Yes this is perfectly reasonable. You will get a performance benefit if the outer lock is rarely used in write mode.

You can't get a deadlock with this as long as you don't try to acquire the outer lock while holding an inner lock.

[siddharthteli12]

@Amanieu , Thanks a lot for your response. My main query is how concurrency is being handled in the above scenario.

[Amanieu]

Exactly how you would expect it to: multiple threads can acquire a read on the outer lock then different threads can acquire a write on the inner locks concurrently.