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

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?

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.

Mutex is a simple method of locking to control access to shared resources.

• At the same time, only one thread can master a mutex, and threads with locked status can access shared resources.
• If another thread wants to lock a resource that has been mutexed, the thread hangs until the locked thread releases the mutex.

Read write locks are more complex than mutex locks.

• Threads using mutex lack read concurrency.
• When there are more read operations and fewer write operations, read-write locks can be used to improve thread read concurrency.

Let me summarize for myself:

• The implementation of read-write lock is more complex than that of mutual exclusion lock, and the performance is poor.
• The read-write lock supports simultaneous reading by multiple threads. The mutex lock does not support simultaneous reading by multiple threads, so the read-write lock has high concurrency.