c#线程本地存储数据

环境：

• window 10
• .netcore 3.1.1
• vs 16.4.5

说明：
要达到的效果是，每一个线程都有一个单独的容器用来存储数据。实现的方法有三种：线程内的数据槽、ThreadStatic特性、ThreadLocal<T>对象

一、线程内的数据槽

线程中的数据槽(LocalDataStoreSlot)是一种给线程存储数据的容器，一个槽只能存一个数据，一个线程可以有很多个槽。可以给槽命名，已命名的槽和线程建立了关联，你可以在任何地方从线程中获取命名的数据槽(GetNamedDataSlot("name-slot"))。注意：数据存储在槽内的，所以线程存取数据都是要指定具体槽的SetData(slot, "xiaoming")，GetData(slot)。还有，槽是对所有线程都有效的，只不过不同的线程的同一个槽内存取的是不同的数据。
线程中的数据槽有两种，未命名的和已命名的：

• 未命名的数据槽：
  只能通过AllocateDataSlot()方法获取，获取后如果想使用，那么所有线程都必须能引用到获取的槽。
• 命名数据槽：
  可以通过GetNamedDataSlot(“slotname”)或AllocateNamedDataSlot(“slot-name”)获取，获取后这个槽本身就和线程建立了关联(以槽名称作为纽带)，这样当线程需要时直接通过GetNamedDataSlot获取就行了，当需要清除关联时使用Thread.FreeNamedDataSlot(“names-slot”)方法清除这个关联，注意这个只是清除关联，不会清除已获取的槽中的数据，所以即使清除关联后，你只要有这个slot的引用，也是可以进行正常的存取数据的。如果不清楚关联的话AllocateNamedDataSlot方法发现已经有命名的槽的话就会报异常，而GetNamedDataSlot方法不会。

下面看看数据槽的使用示例：

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //Test1();
            //Test2();
            //Test3();
            Console.WriteLine("ok");
            Console.ReadLine();
        }

        /// <summary>
        /// 测试命名线程槽的GetNamedDataSlot方法
        /// </summary>
        private static void Test3()
        {
            LocalDataStoreSlot slot = Thread.GetNamedDataSlot("names-slot");
            var thread = new Thread(() =>
            {
                var slot2 = Thread.GetNamedDataSlot("names-slot");
                Console.WriteLine("slot==slot2=>" + (slot == slot2).ToString());
            });
            thread.Start();
            Thread.FreeNamedDataSlot("names-slot");
            var slot3 = Thread.AllocateNamedDataSlot("names-slot");
            var slot4 = Thread.AllocateNamedDataSlot("names-slot");
            Console.WriteLine("slot3==slot4 -> " + (slot3 == slot4));
        }

        /// <summary>
        /// 测试命名的线程槽
        /// </summary>
        private static void Test2()
        {
            LocalDataStoreSlot slot = Thread.AllocateNamedDataSlot("names-slot");
            var thread = new Thread(() =>
            {
                Thread.SetData(slot, "xiaoming");
                var data = Thread.GetData(slot);
                Console.WriteLine("work-thread-slot:" + data);
                Thread.FreeNamedDataSlot("names-slot");
                data = Thread.GetData(slot);
                var slot2 = Thread.GetNamedDataSlot("names-slot");
                data = Thread.GetData(slot2);
                Console.WriteLine("slot==slot2" + (slot == slot2).ToString());
                Console.WriteLine("work-thread-slot:" + data);
                Thread.SetData(slot, "xiaohong");
                Console.WriteLine("work-thread-slot:" + Thread.GetData(slot));
            });
            thread.Start();
            Thread.Sleep(3000);
            var data2 = Thread.GetData(slot);
            Console.WriteLine("main-thread-slot:" + data2);
        }

        /// <summary>
        /// 测试未命名的线程槽
        /// </summary>
        private static void Test1()
        {
            LocalDataStoreSlot slot = Thread.AllocateDataSlot();
            Thread.SetData(slot, "xiaoming");
            var data = Thread.GetData(slot);
            var thread = new Thread(() =>
              {
                  var data2 = Thread.GetData(slot);
                  Console.WriteLine("work-thread-slot:" + data2);
              });
            thread.Start();
            Console.WriteLine("main-thread-slot:" + data);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

二、ThreadStatic

这种方法是在静态字段上添加[ThreadStatic]特性，然后每个线程访问时都是不同的值。
注意：这要求字段必须是静态的，如果不是静态的那么加上[ThreadStatic]特性也没用，因为字段不是特性的话，它就属于一个实例对象，没办法在一个实例对象内根据线程进行隔离。
如果这个字段是静态的，那么这个字段是属于类的，它对所有的线程都一样，此时再给它加上[ThreadStatic]特性就会把这个静态字段进行线程隔离。
下面来看实验代码：

[ThreadStatic]
private static string name = string.Empty;
static void Main(string[] args)
{
	 var thread = new Thread(() =>
	   {
	       name = "xiaoming";
	       Console.WriteLine("work name=" + name);
	   });
	 thread.Start();
     thread.Join();
     Console.WriteLine("main name=" + name);
     Console.WriteLine("ok");
     Console.ReadLine();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

三、ThreadLocal

这是一个容器，提供了一个对象专门用来存储和线程相关的对象，它和[ThreadStatic]最大的不同是：不再要求字段是静态的。
具体使用方式如下：

class Program
{
    private ThreadLocal<string> username = new ThreadLocal<string>();
    static void Main(string[] args)
    {

        var pro = new Program();
        var thread = new Thread(() =>
        {
            pro.username.Value = "xiaoming";
            Console.WriteLine("worker username=" + pro.username.Value);
        });
        thread.Start();
        thread.Join();
        Console.WriteLine("worker username=" + pro.username.Value);
        Console.WriteLine("ok");
        Console.ReadLine();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        #region 测试ThreadStatic、ThreadLocal本地存储
        /*
         * 测试ThreadStatic、ThreadLocal本地存储
         */
        //[ThreadStatic]
        //private static string name = string.Empty;
        //static void Main(string[] args)
        //{
        //    ThreadLocal<string> userName = new ThreadLocal<string>();
        //    var thread = new Thread(() =>
        //      {
        //          userName.Value = "xiaohua";
        //          name = "xiaoming";
        //          Console.WriteLine("work name=" + name);
        //          Console.WriteLine("work userName=" + userName.Value);
        //      });
        //    thread.Start();
        //    thread.Join();
        //    Console.WriteLine("main name=" + name);
        //    Console.WriteLine("main userName=" + userName.Value);


        //    Console.WriteLine("ok");
        //    Console.ReadLine();
        //} 
        #endregion


        #region Debug和Releas模式的运行速度对比
        //public static void Main(string[] args)
        //{
        //    //for (int i = 0; i < 10000; i++)
        //    //{
        //    //    int res = new Random().Next(1, 100000);
        //    //    File.AppendAllText("c:\\temp\\ints.txt", res + "\r\n");
        //    //}
        //    //Release和Debug模式的区别
        //    var datas = File.ReadAllLines("c:\\temp\\ints.txt").Select(i => int.Parse(i)).ToList<int>();
        //    for (int i = 0; i < 5; i++)
        //    {
        //        var arr = new int[datas.Count];
        //        datas.CopyTo(arr);
        //        Stopwatch watch = new Stopwatch();
        //        watch.Start();
        //        Order(arr);
        //        watch.Stop();
        //        Console.WriteLine(watch.Elapsed);
        //    }
        //    Console.WriteLine("ok");
        //    Console.Read();
        //}

        //public static int[] Order(int[] datas)
        //{
        //    for (int i = 0; i < datas.Length; i++)
        //    {
        //        for (int j = i + 1; j < datas.Length; j++)
        //        {
        //            if (datas[i] < datas[j])
        //            {
        //                int t = datas[i];
        //                datas[i] = datas[j];
        //                datas[j] = t;
        //            }
        //        }
        //    }
        //    return datas;
        //} 
        #endregion
        public static void Main(string[] args)
        {
            var isStop = 0;
            var t = new Thread(() =>
              {
                  var isSuccess = true;
                  while (isStop == 0)
                  {

                      //Thread.VolatileRead(ref isStop);
                      isSuccess = !isSuccess;
                  }
              });
            t.Start();
            Thread.Sleep(1000);
            isStop = 1;
            t.Join();
            Console.WriteLine("ok");
            Console.ReadLine();


            //bool isStop = false;
            //var thread = new Thread(() =>
            //  {
            //      var isSuccess = false;
            //      while (!isStop)
            //      {
            //          //这个方法可以指示从内存中读写
            //          //Thread.MemoryBarrier();
            //          isSuccess = !isSuccess;
            //      }
            //  });
            //thread.Start();
            //Thread.Sleep(1000);
            //isStop = true;
            //thread.Join();
            //Console.WriteLine("ok");
            //Console.ReadLine();

            //下面不会出现bug
            //bool isStop = false;
            //var thread = new Thread(() =>
            //{
            //    while (true)
            //    {
            //        if (isStop) break;
            //    }
            //});
            //thread.Start();
            //Thread.Sleep(1000);
            //isStop = true;
            //thread.Join();
            //Console.WriteLine("ok");
            //Console.ReadLine();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139