readwritelock

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

What's a good way of allowing searches from multiple threads on a list (or other data structure), but preventing searches on the list and edits to the list on different threads from interleaving? I tried using synchronized blocks in the searching and editing methods, but that can cause unnecessary blocking when trying to run searches in multiple threads. EDIT: The ReadWriteLock is exactly what I was looking for! Thanks. Usually, yes ReadWriteLock is good enough. But, if you're using Java 8 you can get a performance boost with the new StampedLock that lets you avoid the read lock. This applies

I have a set of data structures I need to protect with a readers/writer lock. I am aware of boost::shared_lock, but I would like to have a custom implementation using std::mutex, std::condition_variable and/or std::atomic so that I can better understand how it works (and tweak it later). Each data structure (moveable, but not copyable) will inherit from a class called Commons which encapsulates the locking. I'd like the public interface to look something like this: class Commons { public: void read_lock(); bool try_read_lock(); void read_unlock(); void write_lock(); bool try_write_lock(); void