ThreadLocal<T> and static approach?

Question

Static fields are being accessed using the class name like this:

public class Me()
{ 
  public static int a=5;
}

I can access it with Me.a, so it is attached to the class.

But when I look at:

static ThreadLocal<int> _x = new ThreadLocal<int> (() => 3);

It guarantees that each thread sees different copy of _x.

Didn't we just see that static is per class and not per thread? How does ThreadLocal manage to give each thread a different copy of _x?

Answer 1

The reference _x will indeed be one per class, as per its static specifier. However, only the reference will be shared among all threads, not the value inside its object. When you access _x.Value, ThreadLocal<T> invokes system-specific code that provides storage on the current thread, and reads or writes to that thread-specific storage.

Answer 2

My C# isn't that great, so here's a C++ answer to the same effect: Imagine a hypothetical class that contains a large array:

class Foo
{
    int array[HUGE];
    int & get() { return array[this_thread_id()]; }
}:

Now you can have one single, global (or class-static) object:

Foo tlstorage;

To access it from anywhere you say tlstorage.get() = 12;. However, the data is stored in the slot that "belongs" to your current thread. The entire storage is global, but only one slice is exposed to each thread.

Other languages like C and C++ have native support for this concept, and when you decorate a global or static variable as "thread-local", the compiler builds something that amounts to the same effect automatically. Perhaps in C# this is a library feature, though it probably also maps to something intrinsic.