Multi-threaded local store slot (native storage slot) [go]

1. Using the ThreadStatic feature

The threadstatic feature is the simplest use of TLS, and only supports static fields, so you can simply mark this feature on the field:

1. [ThreadStatic]
2. static string str = "hehe";
4. static void Main ()
5. {
6. Another thread will only modify the STR variable in its own TLS
7. Thread th = new Thread (() = {str = "MGen"; Display (); });
8. Th. Start ();
9. Th. Join ();
10. Display ();
11. }
13. static void Display ()
14. {
15. Console.WriteLine ("{0} {1}", Thread.CurrentThread.ManagedThreadId, str);
16. }

Operation Result:

1 hehe
3 MGen

As you can see, the str static fields are stored independently in two threads and are not modified by one another.

2. Using the named LocalDataStoreSlot type

Obviously the threadstatic feature only supports static fields that are too limited. The LocalDataStoreSlot in the net thread type provides better TLS support. Let's take a look at the named LocalDataStoreSlot type, which can be thread.allocatenameddataslot to allocate a named space and destroy a named space by Thread.freenameddataslot. The acquisition and setting of spatial data is through the GetData method of the thread type and the SetData method.

2. static void Main ()
4. {
6. Create slots
8. LocalDataStoreSlot slot = Thread.allocatenameddataslot ("slot");
10. Set the value in TLS
12. Thread.setdata (slot, "hehe");
14. Modifying the TLS thread
16. Thread th = new Thread (() =
18. {
20. Thread.setdata (slot, "MGen");
22. Display ();
24. });
28. Th. Start ();
30. Th. Join ();
32. Display ();
34. Clear Slots
36. Thread.freenameddataslot ("slot");
38. }
42. Display the slot value in TLS
44. static void Display ()
46. {
48. LocalDataStoreSlot Dataslot = Thread.getnameddataslot ("slot");
50. Console.WriteLine ("{0} {1}", Thread.CurrentThread.ManagedThreadId, Thread.getdata (Dataslot));
52. }

Output:

3 MGen
1 hehe

3. Using unnamed LocalDataStoreSlot types

Threads also support unnamed localdatastoreslot, unnamed localdatastoreslot do not need to be cleared manually, and the Thread.AllocateDataSlot method is required for allocation. Note Because unnamed localdatastoreslot do not have a name, Therefore, the Thread.getnameddataslot method cannot be used, only the same localdatastoreslot can be referenced in multiple threads to operate on the TLS space, and the named LocalDataStoreSlot code above is changed to an unnamed localdatast Oreslot Execution:

2. Static LocalDataStoreSlot variables
4. static LocalDataStoreSlot slot;
8. static void Main ()
10. {
12. Create slots
14. Slot = Thread.AllocateDataSlot ();
16. Set the value in TLS
18. Thread.setdata (slot, "hehe");
20. Modifying the TLS thread
22. Thread th = new Thread (() =
24. {
26. Thread.setdata (slot, "MGen");
28. Display ();
30. });
34. Th. Start ();
36. Th. Join ();
38. Display ();
40. }
44. Display the slot value in TLS
46. static void Display ()
48. {
50. Console.WriteLine ("{0} {1}", Thread.CurrentThread.ManagedThreadId, Thread.getdata (slot));
52. }

4. Using the threadlocal<t> type of. NET 4.0

The. NET 4.0 thread has added a lot of things, including the threadlocal<t> type, and his appearance has made it much easier to simplify the TLS operation. Threadlocal<t> types and lazy<t> are surprisingly similar, constructor arguments are func<t> used to create objects (which can also be understood as default values for objects), and then use the Value property to get or set the object. Threadlocal's operation is somewhat more or less like the unnamed localdatastoreslot above, but Threadlocal feels more concise and better understood.

2. static threadlocal<string> local;
6. static void Main ()
8. {
10. Create threadlocal and provide default values
12. Local = new Threadlocal<string> (() = "hehe");
14. Modifying the TLS thread
16. Thread th = new Thread (() =
18. {
20. Local. Value = "MGen";
22. Display ();
24. });
28. Th. Start ();
30. Th. Join ();
32. Display ();
34. }
38. Displaying data values in TLS
40. static void Display ()
42. {
44. Console.WriteLine ("{0} {1}", Thread.CurrentThread.ManagedThreadId, Local. Value);
46. }

Output:

3 MGen

1 hehe

5. Emphasize the default values for different methods and TLS
The above code is a one-thread setting value, another thread directly modifies the value and outputs it, and does not perceive the default value in TLS, the following is a special emphasis on the default status of different methods. ThreadStatic does not provide a default value:

1. [ThreadStatic]
2. static int i = 123;
4. static void Main ()
5. {
6. Output local thread TLS data value
7. Console.WriteLine (i);
8. Output another thread TLS data value
9. ThreadPool.QueueUserWorkItem (_ = Console.WriteLine (i));
10. Console waits for thread to end
11. Console.readkey ();
12. }

Output:
123

0

Obviously the local thread TLS data is 123, and the default value of the static variable is not initialized in another thread.

LocalDataStoreSlot It is easy to see that there is no default value, because initialization can only construct a space and not give it a value, Thread.setdata obviously only sets the data in TLS, or demonstrates it in code:

1. Static LocalDataStoreSlot slot = Thread.AllocateDataSlot ();
3. static void Main ()
4. {
5. Thread.setdata (slot, 123);
6. Output local thread TLS data value
7. Console.WriteLine (Thread.getdata (slot));
8. Output another thread TLS data value
9. ThreadPool.QueueUserWorkItem (_ = = Console.WriteLine (Thread.getdata (slot) = = null));
10. Console waits for thread to end
11. Console.readkey ();
12. }

Output:
123
True
The second line is true, then the data in the other thread is null.

The final point:. NET 4.0 threadlocal will provide default values, remember the words I said above "threadlocal operation more or less like the above unnamed LocalDataStoreSlot"? One might ask why it created threadlocal? There's a big difference. Threadlocal can provide default values for data in TLS. (another threadlocal is a generic class, and LocalDataStoreSlot is not).

1. Static threadlocal<int> local = new Threadlocal<int> (() = 123);
2. static void Main ()
3. {
4. Output local thread TLS data value
5. Console.WriteLine (Local. Value);
6. Output another thread TLS data value
7. ThreadPool.QueueUserWorkItem (_ = = Console.WriteLine (local). Value));
8. Console waits for thread to end
9. Console.readkey ();
10. }

Output:
123
123

This article can also be consulted

Http://www.cnblogs.com/lulu/archive/2012/03/17/2403872.html

Multi-threaded local store slot (native storage slot) [go]