如何为 Unity3D 编写线程安全的 C# 代码？

Question

我想了解如何编写线程安全代码。

例如，我的游戏中有这段代码：

bool _done = false;
Thread _thread;

// main game update loop
Update()
{
    // if computation done handle it then start again
    if(_done)
    {
        // .. handle it ...
        _done = false;
        _thread = new Thread(Work);
        _thread.Start();
    }
}

void Work()
{
     // ... massive computation

     _done = true;
}

如果我理解正确的话，主游戏线程和我的_thread 可能有自己的缓存版本_done，而一个线程可能永远不会看到_done 在另一个线程中发生变化？

如果可以，如何解决？

1. 是否可以通过只应用volatile关键字来解决。

2. 或者是否可以通过Interlocked的Exchange和Read等方法读写值？

3. 如果我用lock (_someObject)包围_done读写操作，我需要使用Interlocked或其他东西来防止缓存吗？

编辑 1

4. 如果我将_done 定义为volatile 并从多个线程调用Update 方法。在我将_done 赋值为false 之前，是否有2 个线程会进入if 语句？

Answer 1

1. 是的，但从技术上讲，这不是 volatile 关键字所做的；但是，它具有该结果作为副作用-volatile 的大多数用途用于该副作用；实际上 volatile 的 MSDN 文档现在只列出了这种副作用场景 (link) - 我猜 实际原件 措辞（关于重新排序说明）太混乱了？所以也许这是现在正式使用了吗？

2. Interlocked 没有 bool 方法；您需要使用具有 0/1 之类的值的 int，但这几乎就是 bool 的含义无论如何 - 请注意 Thread.VolatileRead 也可以使用 p>

3. lock 有一个完整的栅栏；你不需要任何额外的结构，lock 本身就足以让 JIT 了解你需要什么

就个人而言，我会使用volatile。您方便地按递增的间接费用顺序列出了您的 1/2/3。 volatile 将是这里最便宜的选择。

Answer 2

虽然您可能使用 volatile 关键字作为布尔标志，但它并不总是保证对该字段的线程安全访问。

在你的情况下，我可能会创建一个单独的类 Worker 并使用事件来通知后台任务何时完成执行：

// Change this class to contain whatever data you need

public class MyEventArgs 
{
    public string Data { get; set; }
}

public class Worker
{
    public event EventHandler<MyEventArgs> WorkComplete = delegate { };
    private readonly object _locker = new object();

    public void Start()
    {
        new Thread(DoWork).Start();
    }

    void DoWork()
    {
        // add a 'lock' here if this shouldn't be run in parallel 
        Thread.Sleep(5000); // ... massive computation
        WorkComplete(this, null); // pass the result of computations with MyEventArgs
    }
}

class MyClass
{
    private readonly Worker _worker = new Worker();

    public MyClass()
    {
        _worker.WorkComplete += OnWorkComplete;
    }

    private void OnWorkComplete(object sender, MyEventArgs eventArgs)
    {
        // Do something with result here
    }

    private void Update()
    {
        _worker.Start();
    }
}

根据需要随意更改代码

附： Volatile 在性能方面具有良好的性能，在您的场景中，它应该可以正常工作，因为看起来您以正确的顺序进行读取和写入。内存屏障可能是通过新读/写来精确实现的——但 MSDN 规范不能保证。是否冒险使用volatile 由您决定。

Answer 3

也许您甚至不需要您的 _done 变量，因为如果您使用线程的 IsAlive() 方法，您可以实现相同的行为。 （假设您只有 1 个后台线程）

像这样：

if(_thread == null || !_thread.IsAlive())
{
    _thread = new Thread(Work);
    _thread.Start();
}

我没有测试这个顺便说一句..这只是一个建议:)

Answer 4

使用 MemoryBarrier()

System.Threading.Thread.MemoryBarrier() 是这里的正确工具。该代码可能看起来很笨拙，但它比其他可行的替代方案更快。

bool _isDone = false;
public bool IsDone
{
    get
    {
        System.Threading.Thread.MemoryBarrier();
        var toReturn = this._isDone;
        System.Threading.Thread.MemoryBarrier();

        return toReturn;
    }
    private set
    {
        System.Threading.Thread.MemoryBarrier();
        this._isDone = value;
        System.Threading.Thread.MemoryBarrier();
    }
}

不要使用易失性

volatile 不会阻止读取较旧的值，因此它不符合此处的设计目标。请参阅Jon Skeet's explanation 或Threading in C# 了解更多信息。

请注意，volatile可能由于未定义的行为，特别是在许多常见系统上的强大内存模型，在许多情况下似乎都可以工作。但是，当您在其他系统上运行代码时，对未定义行为的依赖可能会导致出现错误。一个实际的例子是，如果您在 Raspberry Pi 上运行此代码（由于 .NET Core 现在可以实现！）。

编辑：在讨论了“volatile 在这里不起作用”的说法之后，尚不清楚 C# 规范究竟保证了什么；可以说，volatile 可能 可以保证工作，尽管它有更大的延迟。 MemoryBarrier() 仍然是更好的解决方案，因为它确保了更快的提交。此行为在“C# 4 in a Nutshell”的示例中进行了解释，在“Why do I need a memory barrier?”中进行了讨论。

不要使用锁

锁是一种更重的机制，旨在加强过程控制。在这样的应用程序中，它们不必要地笨重。

性能影响很小，您可能不会在少量使用时注意到它，但它仍然不是最佳的。此外，它可能会（即使是轻微的）导致线程不足和死锁等更大的问题。

详细说明为什么 volatile 不起作用

为了演示这个问题，这里是.NET source code from Microsoft (via ReferenceSource)：

public static class Volatile
{
    public static bool Read(ref bool location)
    {
        var value = location;
        Thread.MemoryBarrier();
        return value;
    }

    public static void Write(ref byte location, byte value)
    {
        Thread.MemoryBarrier();
        location = value;
    }
}

所以，假设一个线程设置_done = true;，然后另一个读取_done 以检查它是否为true。如果我们内联它会是什么样子？

void WhatHappensIfWeUseVolatile()
{
    // Thread #1:  Volatile write
    Thread.MemoryBarrier();
    this._done = true;           // "location = value;"

    // Thread #2:  Volatile read
    var _done = this._done;      // "var value = location;"
    Thread.MemoryBarrier();

    // Check if Thread #2 got the new value from Thread #1
    if (_done == true)
    {
        //  This MIGHT happen, or might not.
        //  
        //  There was no MemoryBarrier between Thread #1's set and
        //  Thread #2's read, so we're not guaranteed that Thread #2
        //  got Thread #1's set.
    }
}

简而言之，volatile 的问题在于，虽然它确实插入了 MemoryBarrier()，但它没有将它们插入到我们需要它们的位置这种情况。

Answer 5

新手可以通过执行以下操作在 Unity 中创建线程安全代码：

• 复制他们希望工作线程处理的数据。
• 告诉工作线程处理副本。
• 在工作线程中，工作完成后，向主线程调度调用以应用更改。

这样您的代码中不需要锁和易失性，只需两个调度程序（隐藏所有锁和易失性）。

现在这是简单而安全的变体，新手应该使用。您可能想知道专家在做什么：他们做的事情完全相同。

这是我的一个项目中 Update 方法的一些代码，它解决了您要解决的相同问题：

Helpers.UnityThreadPool.Instance.Enqueue(() => {
    // This work is done by a worker thread:
    SimpleTexture t = Assets.Geometry.CubeSphere.CreateTexture(block, (int)Scramble(ID));
    Helpers.UnityMainThreadDispatcher.Instance.Enqueue(() => {
        // This work is done by the Unity main thread:
        obj.GetComponent<MeshRenderer>().material.mainTexture = t.ToUnityTexture();
    });
});

请注意，要使上述线程安全，我们唯一要做的就是在调用 enqueue 后不要编辑 block 或 ID。不涉及易失性或显式锁定。

这里是来自UnityMainThreadDispatcher的相关方法：

List<Action> mExecutionQueue;
List<Action> mUpdateQueue;

public void Update()
{
    lock (mExecutionQueue)
    {
        mUpdateQueue.AddRange(mExecutionQueue);
        mExecutionQueue.Clear();
    }
    foreach (var action in mUpdateQueue) // todo: time limit, only perform ~10ms of actions per frame
    {
        try {
            action();
        }
        catch (System.Exception e) {
            UnityEngine.Debug.LogError("Exception in UnityMainThreadDispatcher: " + e.ToString());
        }
    }
    mUpdateQueue.Clear();
}

public void Enqueue(Action action)
{
    lock (mExecutionQueue)
        mExecutionQueue.Add(action);
}

这是一个线程池实现的链接，您可以在 Unity 最终支持 .NET 线程池之前使用它：https://stackoverflow.com/a/436552/1612743

Answer 6

我认为您不需要在代码中添加那么多。除非 Unity 的 Mono 版本确实与常规的 .Net 框架（我确信它没有）做一些巨大的和代码破坏性的不同，否则在你的场景中你不会在不同的线程中拥有不同的 _done 副本。所以，不需要 Interlocked，不需要 volatile，不需要黑魔法。

您真正可能遇到的情况是，您的主线程将_done 设置为false，同时您的后台线程将其设置为true，这绝对是一件坏事。这就是为什么您需要用“锁”来包围这些操作（不要忘记将它们锁定在 SAME 同步对象上）。

只要您按照代码示例中的描述使用 _done，您就可以在每次编写变量时“锁定”它，一切都会好起来的。