监控与锁定

Question

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

编辑： 从到目前为止的答案看来，lock 是对Monitor 类的一系列调用的简写。 lock call 的简写到底是什么？或者更明确地说，

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 ?
    }
}

更新

感谢大家的帮助：我已经发布了另一个问题，作为对你们提供的一些信息的跟进。由于您似乎精通这方面的知识，因此我发布了链接：What is wrong with this solution to locking and managing locked exceptions?

Answer 1

Eric Lippert 在他的博客中谈到了这一点： Locks and exceptions do not mix

C# 4.0 和更早版本的等效代码不同。

---

在 C# 4.0 中是：

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

它依赖于Monitor.Enter 在获取锁时自动设置标志。

---

之前是这样的：

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

这依赖于Monitor.Enter 和try 之间没有抛出异常。我认为在调试代码中违反了这个条件，因为编译器在它们之间插入了一个 NOP，从而使它们之间的线程中止成为可能。

Answer 2

锁定 Lock 关键字确保一个线程一次执行一段代码。

锁定（锁定对象）

        {
        //   Body
        }

lock 关键字通过获取给定对象的互斥锁，执行语句然后释放锁来将语句块标记为临界区

如果另一个线程试图输入一个锁定的代码，它会等待，阻塞，直到对象被释放。

监控 Monitor 是一个静态类，属于 System.Threading 命名空间。

它为对象提供排他锁，以便在任何给定时间点只有一个线程可以进入临界区。

C#中Monitor和lock的区别

锁是 Monitor.Enter 的快捷方式，使用 try 和 finally。 锁定句柄尝试并最终在内部阻塞 Lock = Monitor + try finally.

如果您希望使用TryEnter()、Wait()、Pulse() 和PulseAll() 方法实现高级多线程解决方案的更多控制权，那么 Monitor 类是您的选择。

C#Monitor.wait()：一个线程等待其他线程通知。

Monitor.pulse()：一个线程通知另一个线程。

Monitor.pulseAll()：一个线程通知一个进程中的所有其他线程

Answer 3

除了以上所有解释之外，lock 是一个 C# 语句，而 Monitor 是一个位于 System.Threading 命名空间中的 .NET 类。

Answer 4

Monitor 更灵活。我最喜欢使用监视器的用例是当你不想等待轮到你而只是跳过：

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

Answer 5

正如其他人所说，lock“等同于”

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

但出于好奇，lock 将保留您传递给它的第一个引用，并且如果您更改它也不会抛出。 我知道不建议更改锁定的对象，您也不想这样做。

但同样，对于科学来说，这很好用：

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());

...这不是：

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());

错误：

“System.Threading.SynchronizationLockException”类型的异常 发生在 70783sTUDIES.exe 但未在用户代码中处理

附加信息：对象同步方法是从 一段不同步的代码。

这是因为Monitor.Exit(lockObject); 将作用于lockObject，因为strings 是不可变的，所以你正在从一个不同步的代码块中调用它......但无论如何。这只是一个有趣的事实。

Answer 6

lock 只是 Monitor.Enter 的快捷方式，try + finally 和 Monitor.Exit。只要够用就使用 lock 语句 - 如果您需要 TryEnter 之类的东西，则必须使用 Monitor。

Answer 7

监视器的锁定和基本行为（进入+退出）或多或少相同，但监视器有更多选项，可以让您有更多同步可能性。

锁是一种快捷方式，是基本使用的选项。

如果您需要更多控制，显示器是更好的选择。您可以将 Wait、TryEnter 和 Pulse 用于高级用途（如屏障、信号量等）。

Answer 8

一个lock语句相当于：

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

但是，请记住，Monitor 也可以 Wait() 和 Pulse()，这在复杂的多线程情况下通常很有用。

更新

但是在 C# 4 中它的实现方式不同：

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

感谢 CodeInChaos 的 cmets 和 links

Answer 9

两者都是一样的。 lock 是 c sharp 关键字并使用 Monitor 类。

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