使用 ThreadStatic 来替换昂贵的本地变量——好主意吗？

Question

更新：正如我所料，社区针对这个问题给出的合理建议是“衡量一下然后看看”。 chibacity 发布了一个答案，其中包含一些非常好的内容为我做这件事的测试；与此同时，我自己写了一个测试；我看到的性能差异实际上是如此巨大，以至于 我感到有必要写一篇关于它的博客文章。

但是，我也应该承认Hans 的解释，ThreadStatic 属性确实不是免费的，实际上依赖于 CLR 辅助方法来发挥其魔力。这使得它是否是适用于任何任意情况的适当优化并不明显。

对我来说好消息是，就我的情况而言，它似乎取得了很大的进步。

---

我有一个方法（除其他外）为一些局部变量实例化一些中等大小的数组（~50 个元素）。

经过一些分析后，我发现这种方法是性能瓶颈。并不是说该方法需要花费很长的时间来调用；而是该方法需要很长的时间来调用。相反，它被简单地快速调用很多次（一次会话中数十万到数百万次，这将是几个小时）。因此，即使对其性能进行相对较小的改进也是值得的。

我突然想到，也许我可以使用标记为 [ThreadStatic] 的字段，而不是在每次调用时分配一个新数组；每当调用该方法时，它都会检查该字段是否在当前线程上初始化，如果没有，则对其进行初始化。从那时起，同一线程上的所有调用都将有一个数组准备就绪。

（该方法初始化数组本身中的每个元素，因此数组中存在“陈旧”元素不应该成为问题。）

我的问题很简单：这看起来是个好主意吗？以这种方式使用 ThreadStatic 属性（即，作为一种性能优化，以减轻为局部变量实例化新对象的成本）是否存在我应该了解的陷阱？ ThreadStatic 字段本身的性能可能不是很好；例如，是否有很多额外的“东西”在后台发生，有其自己的一套成本，以使此功能成为可能？

对我来说，尝试优化像 50 个元素数组这样便宜（？）的东西也是错误的，如果是这样，一定要让我知道，但是一般问题仍然成立。

Answer 1

[ThreadStatic] 没有免费的午餐。对变量的每次访问都需要通过 CLR 中的辅助函数 (JIT_GetThreadFieldAddr_Primitive/Objref)，而不是通过抖动进行内联编译。它也不是局部变量的真正替代品，递归将转向字节。您确实必须自己对此进行分析，用循环中那么多 CLR 代码来猜测性能是不可行的。

Answer 2

我进行了一个简单的基准测试，对于问题中描述的简单参数，ThreadStatic 表现更好。

与许多具有大量迭代的算法一样，我怀疑这是分配新数组的版本中 GC 开销杀死它的一个简单情况：

更新

通过包含数组的附加迭代的测试除了先前在本地复制引用的测试之外，还要对最小数组引用使用进行建模，再加上 ThreadStatic 数组引用使用：

Iterations : 10,000,000

Local ArrayRef          (- array iteration) : 330.17ms
Local ArrayRef          (- array iteration) : 327.03ms
Local ArrayRef          (- array iteration) : 1382.86ms
Local ArrayRef          (- array iteration) : 1425.45ms
Local ArrayRef          (- array iteration) : 1434.22ms
TS    CopyArrayRefLocal (- array iteration) : 107.64ms
TS    CopyArrayRefLocal (- array iteration) : 92.17ms
TS    CopyArrayRefLocal (- array iteration) : 92.42ms
TS    CopyArrayRefLocal (- array iteration) : 92.07ms
TS    CopyArrayRefLocal (- array iteration) : 92.10ms
Local ArrayRef          (+ array iteration) : 1740.51ms
Local ArrayRef          (+ array iteration) : 1647.26ms
Local ArrayRef          (+ array iteration) : 1639.80ms
Local ArrayRef          (+ array iteration) : 1639.10ms
Local ArrayRef          (+ array iteration) : 1646.56ms
TS    CopyArrayRefLocal (+ array iteration) : 368.03ms
TS    CopyArrayRefLocal (+ array iteration) : 367.19ms
TS    CopyArrayRefLocal (+ array iteration) : 367.22ms
TS    CopyArrayRefLocal (+ array iteration) : 368.20ms
TS    CopyArrayRefLocal (+ array iteration) : 367.37ms
TS    TSArrayRef        (+ array iteration) : 360.45ms
TS    TSArrayRef        (+ array iteration) : 359.97ms
TS    TSArrayRef        (+ array iteration) : 360.48ms
TS    TSArrayRef        (+ array iteration) : 360.03ms
TS    TSArrayRef        (+ array iteration) : 359.99ms

代码：

[ThreadStatic]
private static int[] _array;

[Test]
public object measure_thread_static_performance()
{
    const int TestIterations = 5;
    const int Iterations = (10 * 1000 * 1000);
    const int ArraySize = 50;

    Action<string, Action> time = (name, test) =>
    {
        for (int i = 0; i < TestIterations; i++)
        {
            TimeSpan elapsed = TimeTest(test, Iterations);
            Console.WriteLine("{0} : {1:F2}ms", name, elapsed.TotalMilliseconds);
        }
    };

    int[] array = null;
    int j = 0;

    Action test1 = () =>
    {
        array = new int[ArraySize];
    };

    Action test2 = () =>
    {
        array = _array ?? (_array = new int[ArraySize]);
    };

    Action test3 = () =>
    {
        array = new int[ArraySize];

        for (int i = 0; i < ArraySize; i++)
        {
            j = array[i];
        }
    };

    Action test4 = () =>
    {
        array = _array ?? (_array = new int[ArraySize]);

        for (int i = 0; i < ArraySize; i++)
        {
            j = array[i];
        }
    };

    Action test5 = () =>
    {
        array = _array ?? (_array = new int[ArraySize]);

        for (int i = 0; i < ArraySize; i++)
        {
            j = _array[i];
        }
    };

    Console.WriteLine("Iterations : {0:0,0}\r\n", Iterations);
    time("Local ArrayRef          (- array iteration)", test1);
    time("TS    CopyArrayRefLocal (- array iteration)", test2);
    time("Local ArrayRef          (+ array iteration)", test3);
    time("TS    CopyArrayRefLocal (+ array iteration)", test4);
    time("TS    TSArrayRef        (+ array iteration)", test5);

    Console.WriteLine(j);

    return array;
}

[SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.GC.Collect")]
private static TimeSpan TimeTest(Action action, int iterations)
{
    Action gc = () =>
    {
        GC.Collect();
        GC.WaitForFullGCComplete();
    };

    Action empty = () => { };

    Stopwatch stopwatch1 = Stopwatch.StartNew();

    for (int j = 0; j < iterations; j++)
    {
        empty();
    }

    TimeSpan loopElapsed = stopwatch1.Elapsed;

    gc();
    action(); //JIT
    action(); //Optimize

    Stopwatch stopwatch2 = Stopwatch.StartNew();

    for (int j = 0; j < iterations; j++) action();

    gc();

    TimeSpan testElapsed = stopwatch2.Elapsed;

    return (testElapsed - loopElapsed);
}

Answer 3

从类似的结果 这个，ThreadStatic 看起来相当快。我不确定是否有人对它是否比重新分配 50 个元素的数组更快有具体的答案。这就是你必须对自己进行基准测试的事情。 :)

我有点纠结这是否是一个“好主意”。只要所有的实现细节都保留在类中，这不一定是一个坏主意（您真的不希望调用者必须担心它），但除非基准测试显示此方法可以提高性能，否则我会坚持简单地使用每次都分配数组，因为它使代码更简单且更易于阅读。由于这两种解决方案中较为复杂的一种，因此在选择这个解决方案之前，我需要先了解其复杂性带来的一些好处。