监视器 VS 锁定

什么时候适合在 C # 中使用 Monitor类或者 lock关键字来保证线程安全？

编辑: 从目前的答案来看，lock是对 Monitor类的一系列调用的简写。锁定调用的简称是什么？或者更明确地说,

class LockVsMonitor
{
private readonly object LockObject = new object();
public void DoThreadSafeSomethingWithLock(Action action)
{
lock (LockObject)
{
action.Invoke();
}
}
public void DoThreadSafeSomethingWithMonitor(Action action)
{
// What goes here ?
}
}

更新

感谢大家的帮助: 我已经发布了另一个问题，作为你们提供的一些信息的后续。因为你似乎很精通这方面，我已经张贴了链接: 这种锁定和管理锁定异常的解决方案有什么问题？

109223 次浏览
小开

lock is just shortcut for Monitor.Enter with try + finally and Monitor.Exit. Use lock statement whenever it is enough - if you need something like TryEnter, you will have to use Monitor.

小开

Both are the same thing. lock is c sharp keyword and use Monitor class.

http://msdn.microsoft.com/en-us/library/ms173179(v=vs.80).aspx

小开

A lock statement is equivalent to:

Monitor.Enter(object);
try
{
// Your code here...
}
finally
{
Monitor.Exit(object);
}

However, keep in mind that Monitor can also Wait() and Pulse(), which are often useful in complex multithreading situations.

Update

However in C# 4 its implemented differently:

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

Thanx to CodeInChaos for comments and links

小开
最佳答案

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.

小开

The lock and the basic behavior of the monitor (enter + exit) is more or less the same, but the monitor has more options that allows you more synchronization possibilities.

The lock is a shortcut, and it's the option for the basic usage.

If you need more control, the monitor is the better option. You can use the Wait, TryEnter and the Pulse, for advanced usages (like barriers, semaphores and so on).

小开

As others have said, lock is "equivalent" to

Monitor.Enter(object);
try
{
// Your code here...
}
finally
{
Monitor.Exit(object);
}

But just out of curiosity, lock will preserve the first reference you pass to it and will not throw if you change it. I know it's not recommended to change the locked object and you don't want to do it.

But again, for the science, this works fine:

var lockObject = "";
var tasks = new List<Task>();
for (var i = 0; i < 10; i++)
tasks.Add(Task.Run(() =>
{
Thread.Sleep(250);
lock (lockObject)
{
lockObject += "x";
}
}));
Task.WaitAll(tasks.ToArray());

...And this does not:

var lockObject = "";
var tasks = new List<Task>();
for (var i = 0; i < 10; i++)
tasks.Add(Task.Run(() =>
{
Thread.Sleep(250);
Monitor.Enter(lockObject);
try
{
lockObject += "x";
}
finally
{
Monitor.Exit(lockObject);
}
}));
Task.WaitAll(tasks.ToArray());

Error:

An exception of type 'System.Threading.SynchronizationLockException' occurred in 70783sTUDIES.exe but was not handled in user code

Additional information: Object synchronization method was called from an unsynchronized block of code.

This is because Monitor.Exit(lockObject); will act on lockObject which has changed because strings are immutable, then you're calling it from an unsynchronized block of code.. but anyway. This is just a fun fact.

小开

Monitor is more flexible. My favorite use case of using monitor is:

When you don't want to wait for your turn and just skip:

//already executing? forget it, lets move on
if (Monitor.TryEnter(_lockObject))
{
try
{
//do stuff;
}
finally
{
Monitor.Exit(_lockObject);
}
}
小开

In addition to all above explanations, lock is a C# statement whereas Monitor is a class of .NET located in System.Threading namespace.

小开

Lock Lock keyword ensures that one thread is executing a piece of code at one time.

lock(lockObject)

        {
//   Body
}

The lock keyword marks a statement block as a critical section by obtaining the mutual-exclusion lock for a given object, executing a statement and then releasing the lock

If another thread tries to enter a locked code, it will wait, block, until the object is released.

Monitor The Monitor is a static class and belongs to the System.Threading namespace.

It provides exclusive lock on the object so that only one thread can enter into the critical section at any given point of time.

Difference between Monitor and lock in C#

The lock is the shortcut for Monitor.Enter with try and finally. Lock handles try and finally block internally Lock = Monitor + try finally.

If you want more control to implement advanced multithreading solutions using TryEnter() Wait(), Pulse(), and PulseAll() methods, then the Monitor class is your option.

C# Monitor.wait(): A thread wait for other threads to notify.

Monitor.pulse(): A thread notify to another thread.

Monitor.pulseAll(): A thread notifies all other threads within a process


提交答案