C# 线程和同步

Question

我有一个用于同步（锁定）的私有静态字段。现在我有两个不想同时执行的函数。所以我这样做了：

public class Synchronization
{
    private static object _lock = new object();

    public void MethodA()
    {
        lock (_lock)
        {
            Console.WriteLine("I shouldn't execute with MethodB");
        }
    }

    public void MethodB()
    {
        lock (_lock)
        {
            Console.WriteLine("I shouldn't execute with MethodA");
        }
    }
}

我知道锁定一个对象会阻止单个函数的并行执行，但是如果我在同时运行的不同方法中使用相同的锁定对象，同样的工作吗？简单地说，任何其他线程都可以在另一个函数中获取已锁定对象的锁定吗？

Answer 1

我相信您阅读 MSDN 上的 Lock Statement 是正确的。

Answer 2

你做得对。您创建了两个不会同时进入的关键部分。

所以 MethodA 和 MethodB 不会同时“活跃”。并且同时只有一个 MethodA（和 MethodB）处于活动状态。

这适用于您创建的所有对象。我的意思是：任何对象的任何 MethodA 或 MethodB 中只有一个线程。如果您希望锁定只发生在一个对象内，您可以使 _lock 对象不是静态的。

Answer 3

一次只有一个线程可以获取锁，所以这个状态对于一个锁实例上的所有线程是独占的。因此，在您的示例中，对于 Synchronization 类的所有实例，在任何给定时间只能执行一个方法体，因为您的锁是静态的。如果您想锁定类的每个实例，请不要将锁定对象标记为静态。

您对同步的假设是正确的。

请注意，您应该标记锁定对象readonly，以获得完全防水的解决方案。就代码而言，锁定对象可能会被重新分配，从而破坏锁定语义，例如：

public class Synchronization
{
    private static object _lock = new object();

    public void MethodA()
    {
        lock (_lock)
        {
            Console.WriteLine("I shouldn't execute with MethodB");
        }
    }

    public void MethodB()
    {
        //This shouldn't be allowed!
        _lock = new object();

        lock (_lock)
        {
            Console.WriteLine("I shouldn't execute with MethodA");
        }
    }
}

锁定对象应标记为readonly，即：

private static readonly object _lock = new object();

Answer 4

根据作为锁定目标的对象授予锁定，而不是根据lock 语句发生的方法。因此，在您的情况下，您的多个线程可能会输入各种方法，但一次只有一个线程能够执行 lock 语句中的任何代码。

Answer 5

首先，_lock 不应该是静态的。或者您是否希望对象的多个实例相互锁定？其次，你应该在一个类中只有一个同步方法。更重要的是，您应该避免类中同步方法之间的依赖关系。否则，您的方法的调用者可能会出错并出现意外行为。

例如，考虑以下代码：

class Synchronized
{
    object lockObj = new object();
    int counter = 100;

    public void Decrement()
    {
        lock (this.lockObj)
        {
            this.counter--;
        }
    }

    public int IsZero()
    {
        lock (this.lockObj)
        {
            return this.counter == 0;
        }
    }
}

现在将如何处理共享同步实例？

这样使用

while (!synchronized.IsZero())
{
    synchronized.Decrement();
}

现在线程 1 调用 Decrement，计数器变为 0，然后线程 2 立即调用 Decrement，因为它在 Decrement 方法中等待锁定，而不是 IsZero 方法。计数器现在是 -1 并且循环是无限的。

不是锁定机制编程错误，而是调用者没有很好地使用它。如果你只在你的 Synchronized 类上暴露了一个同步方法，你就不会欺骗程序员盲目地相信它是安全的。

应该是这样的：

class Synchronized
{
    object lockObj = new object();
    int counter = 100;

    public bool IfNotZeroDecrement()
    {
        lock (this.lockObj)
        {
            if (this.counter > 0)
                this.counter--;

            return this.counter > 0;
        }
    }    
}

/// Usage:
while (synchronized.IfZeroDecrement())
{
}