多线程共享变量和 AsyncLocal

>>返回《C# 并发编程》

• 1. 简介
• 2. 异步下的共享变量
• 3. 解析 AsyncLocal
  • 3.1. IAsyncLocalValueMap 的实现
  • 3.2. 结论

1. 简介

• 普通共享变量：
  • 在某个类上用静态属性的方式便可。
• 多线程共享变量
  • 但愿能将这个变量的共享范围缩小到单个线程内
  • 无关系的B线程没法访问到A线程的值；

[ThreadStatic]特性、ThreadLocal<T> 、CallContext 、AsyncLocal<T> 都具有这个特性。

例子：

因为 .NET Core 再也不实现 CallContext，因此下列代码只能在 .NET Framework 中执行

class Program
{
    //对照
    private static string _normalStatic;

    [ThreadStatic]
    private static string _threadStatic;
    private static ThreadLocal<string> _threadLocal = new ThreadLocal<string>();
    private static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    static void Main(string[] args)
    {
        Parallel.For(0, 4, _ =>
        {
            var threadId = Thread.CurrentThread.ManagedThreadId;

            var value = $"这是来自线程{threadId}的数据";
            
            _normalStatic = value;
            _threadStatic = value;
            CallContext.SetData("value", value);
            _threadLocal.Value = value;
            _asyncLocal.Value = value;
            
            Console.WriteLine($"Use Normal;                Thread：{threadId}; Value：{_normalStatic}");
            Console.WriteLine($"Use ThreadStaticAttribute; Thread：{threadId}; Value：{_threadStatic}");
            Console.WriteLine($"Use CallContext;           Thread：{threadId}; Value：{CallContext.GetData("value")}");
            Console.WriteLine($"Use ThreadLocal;           Thread：{threadId}; Value：{_threadLocal.Value}");
            Console.WriteLine($"Use AsyncLocal;            Thread：{threadId}; Value：{_asyncLocal.Value}");
        });

        Console.Read();
    }
}

输出：

Use Normal;                Thread：15; Value：10
Use [ThreadStatic];        Thread：15; Value：15
Use Normal;                Thread：10; Value：10
Use Normal;                Thread：8; Value：10
Use [ThreadStatic];        Thread：8; Value：8
Use CallContext;           Thread：8; Value：8
Use [ThreadStatic];        Thread：10; Value：10
Use CallContext;           Thread：10; Value：10
Use CallContext;           Thread：15; Value：15
Use ThreadLocal;           Thread：15; Value：15
Use ThreadLocal;           Thread：8; Value：8
Use AsyncLocal;            Thread：8; Value：8
Use ThreadLocal;           Thread：10; Value：10
Use AsyncLocal;            Thread：10; Value：10
Use AsyncLocal;            Thread：15; Value：15

结论：

• Normal 为对照组
• Nomal 的 Thread 与 Value 值不一样，由于读到了其余线程修改的值
• 其余的类型，存储的值，在 Parallel 启动的线程间是隔离的

2. 异步下的共享变量

平常开发过程当中，咱们常常遇到异步的场景。

异步可能会致使代码执行线程的切换。

例如：

测试：[ThreadStatic]特性、ThreadLocal<T> 、AsyncLocal<T> ，三种共享变量被异步代码赋值后的表现。

class Program
{
    [ThreadStatic]
    private static string _threadStatic;
    private static ThreadLocal<string> _threadLocal = new ThreadLocal<string>();
    private static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    static void Main(string[] args)
    {
        _threadStatic = "set";
        _threadLocal.Value = "set";
        _asyncLocal.Value = "set";
        PrintValuesInAnotherThread();
        Console.ReadKey();
    }

    private static void PrintValuesInAnotherThread()
    {
        Task.Run(() =>
        {
            Console.WriteLine($"ThreadStatic: {_threadStatic}");
            Console.WriteLine($"ThreadLocal: {_threadLocal.Value}");
            Console.WriteLine($"AsyncLocal: {_asyncLocal.Value}");
        });
    }
}

输出：

ThreadStatic: 
ThreadLocal: 
AsyncLocal: set

结论：

在异步发生后，线程被切换，只有 AsyncLocal 还可以保留原来的值.

• CallContext 也能够实现这个需求，但 .Net Core 没有被实现，这里就不过多说明。

咱们总结一下这些变量的表现：

实现方式	DotNetFx	DotNetCore	是否支持数据向辅助线程的
[ThreadStatic]	是	是	否
ThreadLocal	是	是	否
CallContext.SetData(string name, object data)	是	否	仅当参数 data 对应的类型实现了 ILogicalThreadAffinative 接口时支持
CallContext.LogicalSetData(string name, object data)	是	否	是
AsyncLocal	是	是	是

辅助线程: 用于处理后台任务，用户没必要等待就能够继续使用应用程序，好比线程池线程。

注意：

• [ThreadStatic]特性、ThreadLocal<T> 最好不要用在线程池线程
  • 线程池线程是可重用的，线程不会销毁，当线程被重用时，以前使用保存的值依然存在，可能形成影响
• 使用 AsyncLocal<T> 能够用在线程池线程
  • 线程使用后回归线程池， AsyncLocal<T> 的状态会被清除，没法访问以前的值
• new Task(...) 默认不是新建一个线程，而是使用线程池线程

3. 解析 AsyncLocal

• AsyncLocal<T>的 Value 属性的真正的数据存取是经过 ExecutionContext 的 internal 的方法 GetLocalValue 和 SetLocalValue 将数据存到 当前ExecutionContext 上的 m_localValues 字段上
  • ExecutionContext 会根据执行环境进行流动，详见 《ExecutionContext(执行上下文)综述》
  • 简单描述就是，线程发生切换的时候， ExecutionContext 会在前一个线程中被捕获，流向下一个线程，它所保存的数据也就随之流动了
    • 在全部会发生线程切换的地方，基础类库(BCL) 都为咱们封装好了对 ExecutionContext 的捕获
    • 例如：
      • new Thread(...).Start()
      • new Task(...).Start()
      • Task.Run(...)
      • ThreadPool.QueueUserWorkItem(...)
      • await 语法糖
• m_localValues 类型是 IAsyncLocalValueMap

3.1. IAsyncLocalValueMap 的实现

如下为基础设施提供的实现：

类型	元素个数
EmptyAsyncLocalValueMap	0
OneElementAsyncLocalValueMap	1
TwoElementAsyncLocalValueMap	2
ThreeElementAsyncLocalValueMap	3
MultiElementAsyncLocalValueMap	4 ~ 16
ManyElementAsyncLocalValueMap	> 16

随着 ExecutionContext 所关联的 AsyncLocal 数量的增长， IAsyncLocalValueMap 的实现将会在 ExecutionContext 的 SetLocalValue 方法中被不断替换。

• 查询的时间复杂度和空间复杂度依次递增

3.2. 结论

• AsyncLocal 类型存储数据，是在本身线程的 ExecutionContext 中
• ExecutionContext 的实例会随着异步或者多线程的启动而被流向执行后续代码的其余线程，保证了启动异步的线程存储的数据能够被访问到
• 数据存到 IAsyncLocalValueMap 类型的变量中，此变量会根据存储的 AsyncLocal 变量个数而切换实现
  • 支持存储量越大的实现类型，性能越差

参考资料：
《浅析 .NET 中 AsyncLocal 的实现原理》 --- 黑洞视界