C#中的锁定

Question

我仍然有点不清楚什么时候在一些代码周围加上一个锁。我的一般经验法则是在读取或写入静态变量时将操作包装在锁中。但是当一个静态变量只被读取时（例如，它是在类型初始化期间设置的只读），访问它不需要包装在锁语句中，对吧？最近看到一些类似下面例子的代码，让我觉得自己的多线程知识可能有些差距：

class Foo
{
    private static readonly string bar = "O_o";

    private bool TrySomething()
    {
        string bar;

        lock(Foo.objectToLockOn)
        {
            bar = Foo.bar;          
        }       

        // Do something with bar
    }
}

这对我来说毫无意义——为什么会出现读取寄存器的并发问题？

此外，这个例子提出了另一个问题。其中一个比另一个更好吗？ （例如，示例二持有锁的时间更短？）我想我可以拆卸 MSIL...

class Foo
{
    private static string joke = "yo momma";

    private string GetJoke()
    {
        lock(Foo.objectToLockOn)
        {
            return Foo.joke;
        }
    }
}

对比

class Foo
{
    private static string joke = "yo momma";

        private string GetJoke()
        {
            string joke;

            lock(Foo.objectToLockOn)
            {
                joke = Foo.joke;
            }

            return joke;
        }
}

Answer 1

由于您编写的代码在初始化后都没有修改静态字段，因此不需要任何锁定。只需用新值替换字符串也不需要同步，除非新值取决于读取旧值的结果。

静态字段不是唯一需要同步的东西，任何可以修改的共享引用都容易受到同步问题的影响。

class Foo
{
    private int count = 0;
    public void TrySomething()    
    {
        count++;
    }
}

您可能认为执行 TrySomething 方法的两个线程会很好。但事实并非如此。

1. 线程 A 将 count (0) 的值读入寄存器，以便递增。
2. 上下文切换！线程调度程序决定线程 A 有足够的执行时间。接下来是线程 B。
3. 线程 B 将 count (0) 的值读入寄存器。
4. 线程 B 递增寄存器。
5. 线程 B 将结果 (1) 保存到计数中。
6. 上下文切换回 A。
7. 线程 A 使用保存在其堆栈中的 count (0) 值重新加载寄存器。
8. 线程 A 递增寄存器。
9. 线程 A 将结果 (1) 保存到计数中。

所以，即使我们调用了 count++ 两次，count 的值也只是从 0 变为 1。让代码线程安全：

class Foo
{
    private int count = 0;
    private readonly object sync = new object();
    public void TrySomething()    
    {
        lock(sync)
            count++;
    }
}

现在，当线程 A 被中断时，线程 B 不能乱计数，因为它会触发 lock 语句，然后阻塞，直到线程 A 释放同步。

顺便说一句，还有另一种方法可以使递增 Int32s 和 Int64s 线程安全：

class Foo
{
    private int count = 0;
    public void TrySomething()    
    {
        System.Threading.Interlocked.Increment(ref count);
    }
}

关于你问题的第二部分，我想我会选择更容易阅读的那个，任何性能差异都可以忽略不计。早期优化是万恶之源等。

Why threading is hard

Answer 2

读取或写入 32 位或更小的字段是 C# 中的原子操作。据我所知，您提供的代码不需要锁定。

Answer 3

在我看来，在您的第一种情况下，锁是不必要的。使用静态初始化器来初始化 bar 保证是线程安全的。由于您只读取过该值，因此无需锁定它。如果值永远不会改变，就永远不会有任何争用，为什么要锁定？

Answer 4

脏读？

Answer 5

在我看来，您应该非常努力地不要将静态变量放在需要从不同线程读取/写入的位置。在这种情况下，它们本质上是免费的全局变量，而全局变量几乎总是一件坏事。

话虽如此，如果您确实将静态变量放在这样的位置，您可能希望在读取期间锁定，以防万一 - 请记住，另一个线程可能突然介入并在 期间更改了值 em> 读取，如果是这样，您最终可能会收到损坏的数据。读取不一定是原子操作，除非您通过锁定确保它们。与写入相同 - 它们也不总是原子操作。

编辑： 正如 Mark 所指出的，对于 C# 中的某些原语，读取始终是原子的。但要小心其他数据类型。

Answer 6

如果您只是将值写入指针，则不需要锁定，因为该操作是原子的。通常，您应该在需要执行涉及至少两个原子操作（读取或写入）的事务时锁定，这取决于状态在开始和结束之间不发生变化。

也就是说——我来自 Java 领域，所有变量的读取和写入都是原子操作。这里的其他答案表明 .NET 是不同的。

Answer 7

至于您的“哪个更好”的问题，它们是相同的，因为函数范围不用于其他任何事情。