为什么虽然是引用类型，但使用ThreadLocal的Value成员的本地副本的速度更快？

Question

I'm following the example on page 107 of Patterns for Parallel Programming: Understanding and Applying Parallel Patterns with the .NET Framework 4 ( https://www.microsoft.com/en-us/download/details.aspx?id=19222 ). It is stated that using a local copy of the ThreadLocal's Value member is faster compared to using Threadlocal.Value itself. I tested this and it is indeed the case. But why?

As can be seen in the code, a local copy of _vector2.Value is saved in vector2 and this local copy is used to sum all items. If you use _vector2.Value[i] += _vector1.Value[i] instead of vector2[i] += vector1[i] the code runs just as well albeit slower. This is what is stated in the article. Now int[] is a reference type. This means that when you make a copy in vector2 you are actually copying a reference the original int[] in ThreadLocal's Value member. This is corroborated by commenting out _vector2.Value = vector2 . The printed result remains the same. So, I don't think this assignment is needed.

Now, since _vector2.Value and vector2 are referencing the same data, how is it possible that working with the local copy (vector2) is still faster? Approximately 4 times faster in my test. Has anyone any idea what I'm missing?

    class ReferenceList
    {
        const int VECTOR_LENGTH = 100000000;
        private ThreadLocal<int[]> _vector1 = new ThreadLocal<int[]>(() => Enumerable.Range(1, VECTOR_LENGTH).ToArray());
        private ThreadLocal<int[]> _vector2 = new ThreadLocal<int[]>(() => Enumerable.Range(1, VECTOR_LENGTH).ToArray());

        internal void DoWork()
        {
            int[] vector1 = _vector1.Value;
            int[] vector2 = _vector2.Value;

            for (int i = 0; i < VECTOR_LENGTH; i++)
            {
                // This is the fast way (as in the document)
                vector2[i] += vector1[i];

                // This is the slow way
                //_vector2.Value[i] += _vector1.Value[i];
            }

            // Since int[] is a reference type. This step is not needed, I think. The result is not influenced when commenting out this line
            _vector2.Value = vector2;

            Console.WriteLine($"Thread-{Thread.CurrentThread.ManagedThreadId} Result: {String.Join(", ", _vector2.Value.Take(10))}");
        }

Answer 1

vector1 is a reference directly to the array. Nothing is ever going to be faster than that.

_vector1 is not a reference directly to the array. _vector1.Value will result in the same value - but it takes it some effort to get that value, as per the source code . Thus, every time you ask for .Value you take that performance hit (of executing methods etc) again (even though you know it will return the same value, it takes it some effort to work that out). And that is ignoring other related costs like possible reduction in data locality, increased cache misses etc.