Question

我正在试验不需要原子指令的锁。彼得森的算法似乎是最简单的起点。但是，如果有足够的迭代次数，就会出现问题。

代码：

public class Program
{
    private static volatile int _i = 0;
    public static void Main(string[] args)
    {
        for (int i = 0; i < 1000; i++)
        {
            RunTest();
        }
        Console.Read();
    }

    private static void RunTest()
    {
        _i = 0;
        var lockType = new PetersonLock();
        var t1 = new Thread(() => Inc(0, lockType));
        var t2 = new Thread(() => Inc(1, lockType));

        t1.Start();
        t2.Start();

        t1.Join();
        t2.Join();
        Console.WriteLine(_i);
    }

    private static void Inc(int pid, ILock lockType)
    {
        try
        {
            for (int i = 0; i < 1000000; i++)
            {
                lockType.Request(pid);
                _i++;
                lockType.Release(pid);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }
}

public interface ILock
{
    void Request(int pid);
    void Release(int pid);
}

public class NoLock : ILock
{
    public void Request(int pid) { }
    public void Release(int pid) { }
}

public class StandardLock : ILock
{
    private object _sync = new object();

    public void Request(int pid)
    {
        Monitor.Enter(_sync);
    }

    public void Release(int pid)
    {
        Monitor.Exit(_sync);
    }
}

public class PetersonLock : ILock
{
    private volatile bool[] _wantsCs = new bool[2];
    private volatile int _turn;

    public void Request(int pid)
    {
        int j = pid == 1 ? 0 : 1;
        _wantsCs[pid] = true;
        _turn = j;
        while (_wantsCs[j] && _turn == j)
        {
            Thread.Sleep(0);
        }
    }

    public void Release(int pid)
    {
        _wantsCs[pid] = false;
    }
}

当我跑步时，我一直得到＆lt; 2,000,000。发生了什么事？

Answer 1

这里的问题是这两个陈述：

_wantsCs[pid] = true;
_turn = j;

.NET和C＃的内存模型允许重新排序这两个写入。

要强制它们不重新排序，请在它们之间添加一个内存屏障：

_wantsCs[pid] = true;
Thread.MemoryBarrier();
_turn = j;

每次都会获得预期的输出。

请注意，这个问题在说明部分的Wikipedia page for Peterson's Algorithm中有所描述（在此缩短，请阅读完整备注的文章）：

备注
  ...
  大多数现代CPU重新排序内存访问以提高执行效率（请参阅允许重新排序类型的内存排序）。这些处理器总是提供一些方法来强制在内存访问流中进行排序，通常是通过内存屏障指令。 在重新排序内存访问的处理器上实现Peterson和相关算法通常需要使用此类操作才能正常工作，以防止顺序操作以不正确的顺序发生。

（我的重点）

为什么彼得森的锁在这次测试中失败了？

1 个答案: