When is ReaderWriterLockSlim better than a simple lock?

by

In your example, the sleeps mean that generally there is no contention. An uncontended lock is very fast. For this to matter, you would need a contended lock; if there are writes in that contention, they should be about the same (lock may even be quicker) – but if it is mostly reads (with a write contention rarely), I would expect the ReaderWriterLockSlim lock to out-perform the lock.

Personally, I prefer another strategy here, using reference-swapping – so reads can always read without ever checking / locking / etc. Writes make their change to a cloned copy, then use Interlocked.CompareExchange to swap the reference (re-applying their change if another thread mutated the reference in the interim).

More Related Contents:

  1. Re-entrant locks in C#
  2. Is it OK to use a string as a lock object?
  3. Does a locked object stay locked if an exception occurs inside it?
  4. How expensive is the lock statement?
  5. Monitor vs lock
  6. Do I need to lock or mark as volatile when accessing a simple boolean flag in C#?
  7. Why is lock(this) {…} bad?
  8. Creating a blocking Queue in .NET?
  9. What’s the difference between Invoke() and BeginInvoke()
  10. Question about terminating a thread cleanly in .NET
  11. How do I update the GUI from another thread?
  12. What operations are atomic in C#?
  13. Accessing UI (Main) Thread safely in WPF
  14. ‘using’ statement vs ‘try finally’
  15. Thread.Sleep for less than 1 millisecond
  16. Is Task.Factory.StartNew() guaranteed to use another thread than the calling thread?
  17. Returning a value from thread?
  18. Async process start and wait for it to finish
  19. STAThread and multithreading
  20. Does lock() guarantee acquired in order requested?
  21. Thread safe collections in .NET
  22. Properly locking a List in MultiThreaded Scenarios?
  23. How to achieve remove_if functionality in .NET ConcurrentDictionary
  24. Why does the lock object have to be static?
  25. Async thread body loop, It just works, but how?
  26. Why is it a bad practice to lock the object we are going to change?
  27. Starting a new thread in a foreach loop
  28. Multithreaded NamePipeServer in C#
  29. Wrapping ManualResetEvent as awaitable task
  30. Half – fences and full fences? [duplicate]

Leave a Comment