multithreading - When or why should I use a Mutex over an RwLock?

Question

When I read the documentations of Mutex and RwLock, the difference I see is the following:

• Mutex can have only one reader or writer at a time,
• RwLock can have one writer or multiple reader at a time.

When you put it that way, RwLock seems always better (less limited) than Mutex, why would I use it, then?

question from:https://stackoverflow.com/questions/50704279/when-or-why-should-i-use-a-mutex-over-an-rwlock

Answer 1

Sometimes it is better to use a Mutex over an RwLock in Rust:

RwLock<T> needs more bounds for T to be thread-safe:

• Mutex requires T: Send to be Sync,
• RwLock requires T to be Send and Sync to be itself Sync.

In other words, Mutex is the only wrapper that can make a T syncable. I found a good and intuitive explanation in reddit:

Because of those bounds, RwLock requires its contents to be Sync, i.e. it's safe for two threads to have a &ptr to that type at the same time. Mutex only requires the data to be Send, because conceptually you can think of it like when you lock the Mutex it sends the data to your thread, and when you unlock it the data gets sent to another thread.

Use Mutex when your T is only Send and not Sync.

Preventing writer starvation

RwLock does not have a specified implementation because it uses the implementation of the system. Some read-write locks can be subject to writer starvation while Mutex cannot have this kind of issue.

Mutex should be used when you have possibly too many readers to let the writers have the lock.