锁是顺序一致的吗？

Question

这是这个问题的 C# 版本：Is std::mutex sequentially consistent?

简而言之：如果多个线程对不同的对象进行锁定，它们是否保证在这些不同的锁定中看到相同的事件顺序？

这里是演示：

internal sealed class Test
{
    private readonly object lockerA = new object();
    private bool valueA;

    private readonly object lockerB = new object();
    private bool valueB;

    public void RunTest()
    {
        var taskA = Task.Run(() =>
        {
            lock (lockerA)
                valueA = true;
        });
        var taskB = Task.Run(() =>
        {
            lock (lockerB)
                valueB = true;
        });
        var taskC = Task.Run(() =>
        {
            // Reads A, then B.
            bool readA;
            lock (lockerA)
                readA = valueA;

            bool readB;
            lock (lockerB)
                readB = valueB;

            return (readA, readB);
        });
        var taskD = Task.Run(() =>
        {
            // Reads B, then A.
            bool readB;
            lock (lockerB)
                readB = valueB;

            bool readA;
            lock (lockerA)
                readA = valueA;

            return (readA, readB);
        });

        Task.WaitAll(taskA, taskB, taskC, taskD);

        if (taskC.Result == (readA:true, readB:false) && taskD.Result == (readA:false, readB:true))
        {
            // Can this happen?
            Console.WriteLine("Ordering inconsistency!");
        }
    }
}

编辑：

修复了Matthew Watson 显示示例即使具有顺序一致性也失败后的错误。

Answer 1

锁不保证顺序一致性。相反，它保证如果一个线程在需要一组资源的情况下启动一个操作，那么在具有锁的线程完成对资源的使用之前，其他线程都不能访问（和更改）这些资源。哪个线程首先尝试访问资源取决于一大堆锁并不真正关心的其他因素。

在您希望确保对象在该操作期间不被其他线程修改的操作中使用锁。哪个操作首先访问线程 - 那是完全不同的故事。

请参阅lock statement documentation。

Answer 2

要查看理论上这是否可以返回 (false, true) 和 (true, false)，我们只需要展示一组交错的步骤，任务理论上可以执行该结果。

下面是这样一组步骤：

Init: A = false, B = false

Task A: starting up
Task B: starting up
Task C: enter lock A
Task C: read A = false   C.A = false
Task C: leave lock A
Task A: enter lock A
Task A: set A = true     A = true
Task A: leave lock A
Task A: exit
Task D: enter lock B
Task D: read B = false   D.B = false
Task D: leave lock B
Task B: enter lock B
Task B: set B = true     B = true
Task B: leave lock B
Task B: exit
Task C: enter lock B
Task C: read B = true    C.B = true
Task C: leave lock B
Task C: exit returning (false, true)
Task D: enter lock A
Task D: read A = true    D.A = true
Task D: leave lock A
Task D: exit returning (true, false)

Now task C returned (false, true) and task D returned (true, false)

这证明理论上可以返回乱序结果。