从 2 个不同的线程写入共享资源，而不使用同步机制

Question

我有以下代码（用 C# 编写，但可以轻松翻译为您喜欢的语言...）

class Program
{
    static int sharedState = 0;

    static void Main(string[] args)
    {
        Thread t1 = new Thread(UpdateState);
        Thread t2 = new Thread(UpdateState);
        t1.Start();
        t2.Start();

        t1.Join();
        t2.Join();
        Console.WriteLine("sharedState value is {0}.", sharedState);
    }

    static void UpdateState()
    {
        for (int i = 0; i < 10; i++)
            sharedState++;
    }
}

正如您所猜到的，此代码创建两个工作线程，将共享状态值增加 1，持续 10 次。该代码在访问和写入共享值“sharedState”时没有任何同步机制（例如互斥锁、监视器或任何其他...），并且主线程正在等待两个工作线程完成其工作（Join）。 有人可以向我解释一下这段代码有什么问题吗？最后是否有可能 - 'sharedState' 的值将是 2？ （我的一个朋友被问到这个问题，他们告诉他这是可能的，我们都无法理解如何......） 顺便说一句 - 当我运行这段代码时，我每次都会得到 20...

Answer 1

线程的寿命不够长。在如此短的循环中，它们同时运行的可能性很小，尤其是在多核计算机上。当您启动第二个线程时，第一个线程已经完成。因为它只需要几分之一微秒，比启动线程所需的时间要少得多。让他们循环至少一千万次，以增加赔率并观看比赛。在发布版本中我的机器上的输出：

sharedState 值为 13952221。

每次运行时都有不同的值。

Answer 2

它不是线程安全的，因为

sharedState++;

在内部解释如下：

• 将值从静态属性推送到计算堆栈
• 增加计算堆栈中的值 用
• 计算堆栈中的值替换静态属性中的值

现在，如果此操作不是原子/同步的，您可以拥有更多线程同时从静态属性中获取值，但只会存储最后一个线程的修改。

如果您想要线程安全增量，您应该使用 Interlocked.Increment

Answer 3

1. 两个线程都读取该变量，并获取值 0。
2. 线程 1 设法将变量递增 9 次。
3. 线程 2 设法将变量递增一次。但它之前认为它是 0，所以它的新值为 1。
4. 两个线程都读取该变量，并得到值 1。
5. 线程 2 设法将变量递增 9 次。
6. 线程 1 设法将变量递增一次。但它之前认为是1，所以它的新值为2。

当然，这在实践中是极不可能的！

Answer 4

确实有问题。但只有当你非常频繁地运行循环时它才会发生：

假设状态为 1
线程a读取状态并获取1
线程 a 被操作系统暂停，b 正在运行
线程 b 读取状态并获取 1
线程b计算1+1并写入2
线程 b 读取 2
线程b计算2+1并写入3
...
线程a计算1+1并写入2
执行 3 个增量，状态已从 1 更改为 2

但您永远不会得到低于最低边界条件的结果。因此，如果您从 0 开始并且每个线程递增 10 倍，那么无论发生什么情况，您将始终获得 10 或更高。

对于同步：
Interlocked.Increment（参考任何内容）是你的朋友。它是使用汇编程序中的锁定前缀来实现的。这是安全增加值的最有效方法。
使用 CompareEcxchange 可以执行稍微复杂的操作。但lock(something) 也非常高效。