Monitor vs lock

by

Eric Lippert talks about this in his blog:
Locks and exceptions do not mix

The equivalent code differs between C# 4.0 and earlier versions.

In C# 4.0 it is:

bool lockWasTaken = false;
var temp = obj;
try
{
    Monitor.Enter(temp, ref lockWasTaken);
    { body }
}
finally
{
    if (lockWasTaken) Monitor.Exit(temp);
}

It relies on Monitor.Enter atomically setting the flag when the lock is taken.

And earlier it was:

var temp = obj;
Monitor.Enter(temp);
try
{
   body
}
finally
{
    Monitor.Exit(temp);
}

This relies on no exception being thrown between Monitor.Enter and the try. I think in debug code this condition was violated because the compiler inserted a NOP between them and thus made thread abortion between those possible.

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. Do I need to lock or mark as volatile when accessing a simple boolean flag in C#?
  6. Lock (Monitor) internal implementation in .NET
  7. When is ReaderWriterLockSlim better than a simple lock?
  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. Regarding local variable passing in Thread
  19. STAThread and multithreading
  20. The calling thread cannot access this object because a different thread owns it.WPF [duplicate]
  21. Lock-free multi-threading is for real threading experts
  22. Is it ok to read a shared boolean flag without locking it when another thread may set it (at most once)?
  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