浅析.NET中AsyncLocal的实现原理
作者：黑洞视界
前言
对于写过 ASP.NET Core 的童鞋来说，可以通过 HttpContextAccessor 在 Controller 之外的地方获取到HttpContext，而它实现的关键其实是在于一个AsyncLocal<HttpContextHolder> 类型的静态字段。接下来就和大家来一起探讨下这个 AsyncLocal 的具体实现原理。如果有讲得不清晰或不准确的地方，还望指出。
public class HttpContextAccessor : IHttpContextAccessor
{
private static AsyncLocal<HttpContextHolder> _httpContextCurrent = new AsyncLocal<HttpContextHolder>();
// 其他代码这里不展示
}本文源码参考为发文时间点为止最新的 github 开源代码，和之前实现有些许不同，但设计思想基本一致。
代码库地址：https://github.com/dotnet/runtime
1、线程本地存储
如果想要整个.NET程序中共享一个变量，我们可以将想要共享的变量放在某个类的静态属性上来实现。
而在多线程的运行环境中，则可能会希望能将这个变量的共享范围缩小到单个线程内。例如在web应用中，服务器为每个同时访问的请求分配一个独立的线程，我们要在这些独立的线程中维护自己的当前访问用户的信息时，就需要需要线程本地存储了。
例如下面这样一个例子。
class Program
{
[ThreadStatic]
private static string _value;
static void Main(string[] args)
{
Parallel.For(0, 4, _ =>
{
var threadId = Thread.CurrentThread.ManagedThreadId;
_value ??= $"这是来自线程{threadId}的数据";
Console.WriteLine($"Thread：{threadId}; Value：{_value}");
});
}
}输出结果：
Thread：4; Value：这是来自线程4的数据
Thread：1; Value：这是来自线程1的数据
Thread：5; Value：这是来自线程5的数据
Thread：6; Value：这是来自线程6的数据
除了可以使用 ThreadStaticAttribute 外，我们还可以使用 ThreadLocal<T> 、CallContext 、AsyncLocal<T> 来实现一样的功能。由于 .NET Core 不再实现 CallContext，所以下列代码只能在 .NET Framework 中执行。
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)
{
Parallel.For(0, 4, _ =>
{
var threadId = Thread.CurrentThread.ManagedThreadId;
var value = $"这是来自线程{threadId}的数据";
_threadStatic ??= value;
CallContext.SetData("value", value);
_threadLocal.Value ??= value;
_asyncLocal.Value ??= value;
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 ThreadStaticAttribute; Thread：3; Value：这是来自线程3的数据
Use ThreadStaticAttribute; Thread：4; Value：这是来自线程4的数据
Use ThreadStaticAttribute; Thread：1; Value：这是来自线程1的数据
Use CallContext; Thread：1; Value：这是来自线程1的数据
Use ThreadLocal; Thread：1; Value：这是来自线程1的数据
Use AsyncLocal; Thread：1; Value：这是来自线程1的数据
Use ThreadStaticAttribute; Thread：5; Value：这是来自线程5的数据
Use CallContext; Thread：5; Value：这是来自线程5的数据
Use ThreadLocal; Thread：5; Value：这是来自线程5的数据
Use AsyncLocal; Thread：5; Value：这是来自线程5的数据
Use CallContext; Thread：3; Value：这是来自线程3的数据
Use CallContext; Thread：4; Value：这是来自线程4的数据
Use ThreadLocal; Thread：4; Value：这是来自线程4的数据
Use AsyncLocal; Thread：4; Value：这是来自线程4的数据
Use ThreadLocal; Thread：3; Value：这是来自线程3的数据
Use AsyncLocal; Thread：3; Value：这是来自线程3的数据
上面的例子都只是在同一个线程中对线程进行存和取，但日常开发的过程中，我们会有很多异步的场景，这些场景可能会导致执行代码的线程发生切换。
比如下面的例子
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 = "ThreadStatic保存的数据";
_threadLocal.Value = "ThreadLocal保存的数据";
_asyncLocal.Value = "AsyncLocal保存的数据";
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: AsyncLocal保存的数据
在线程发生了切换之后，只有 AsyncLocal 还能够保留原来的值，当然，.NET Framework 中的 CallContext 也可以实现这个需求，下面给出一个相对完整的总结。
| 实现方式 | .NET FrameWork 可用 | .NET Core 可用 | 是否支持数据流向辅助线程 |
|---|---|---|---|
| ThreadStaticAttribute | 是 | 是 | 否 |
| ThreadLocal<T> | 是 | 是 | 否 |
| CallContext.SetData(string name, object data) | 是 | 否 | 仅当参数 data 对应的类型实现了 ILogicalThreadAffinative 接口时支持 |
| CallContext.LogicalSetData(string name, object data) | 是 | 否 | 是 |
| AsyncLocal<T> | 是 | 是 | 是 |
2、AsyncLocal 实现
我们主要对照 .NET Core 源码进行学习，源码地址：https://github.com/dotnet/runtime/blob/master/src/libraries/System.Private.CoreLib/src/System/Threading/AsyncLocal.cs
2.1、主体 AsyncLocal<T>
AsyncLocal<T> 为我们提供了两个功能
- 通过 Value 属性存取值
- 通过构造函数注册回调函数监听任意线程中对值做出的改动，需记着这个功能，后面介绍源码的时候会有很多地方涉及
其内部代码相对简单
public sealed class AsyncLocal<T> : IAsyncLocal
{
private readonly Action<AsyncLocalValueChangedArgs<T>>? m_valueChangedHandler;
// 无参构造
public AsyncLocal()
{
}
// 可以注册回调的构造函数，当 Value 在任意线程被改动，将调用回调
public AsyncLocal(Action<AsyncLocalValueChangedArgs<T>>? valueChangedHandler)
{
m_valueChangedHandler = valueChangedHandler;
}
[MaybeNull]
public T Value
{
get
{
// 从 ExecutionContext 中以自身为 Key 获取值
object? obj = ExecutionContext.GetLocalValue(this);
return (obj == null) ? default : (T)obj;
}
// 是否注册回调将回影响到 ExecutionContext 是否保存其引用
set => ExecutionContext.SetLocalValue(this, value, m_valueChangedHandler != null);
}
// 在 ExecutionContext 如果判断到值发生了变化，此方法将被调用
void IAsyncLocal.OnValueChanged(object? previousValueObj, object? currentValueObj, bool contextChanged)
{
Debug.Assert(m_valueChangedHandler != null);
T previousValue = previousValueObj == null ? default! : (T)previousValueObj;
T currentValue = currentValueObj == null ? default! : (T)currentValueObj;
m_valueChangedHandler(new AsyncLocalValueChangedArgs<T>(previousValue, currentValue, contextChanged));
}
}
internal interface IAsyncLocal
{
void OnValueChanged(object? previousValue, object? currentValue, bool contextChanged);
}真正的数据存取是通过 ExecutionContext.GetLocalValue 和 ExecutionContext.SetLocalValue 实现的。
public class ExecutionContext
{
internal static object? GetLocalValue(IAsyncLocal local);
internal static void SetLocalValue(
IAsyncLocal local,
object? newValue,
bool needChangeNotifications);
}需要注意的是这边通过 IAsyncLocal 这一接口实现了 AsyncLocal 与 ExcutionContext 的解耦。 ExcutionContext 只关注数据的存取本身，接口定义的类型都是 object，而不关心具体的类型 T。
2.2、AsyncLocal<T> 在 ExecutionContext 中的数据存取实现
在.NET 中，每个线程都关联着一个 执行上下文(execution context) 。 可以通过Thread.CurrentThread.ExecutionContext 属性进行访问，或者通过 ExecutionContext.Capture() 获取（前者的实现） 。
AsyncLocal 最终就是把数据保存在 ExecutionContext 上的，为了更深入地理解 AsyncLocal 我们需要先理解一下它。
2.2.1、 ExecutionContext 与 线程的绑定关系
ExecutionContext 被保存 Thread 的 internal 修饰的 _executionContext 字段上。但Thread.CurrentThread.ExecutionContext 并不直接暴露 _executionContext 而与 ExecutionContext.Capture() 共用一套逻辑。
class ExecutionContext
{
public static ExecutionContext? Capture()
{
ExecutionContext? executionContext = Thread.CurrentThread._executionContext;
if (executionContext == null)
{
executionContext = Default;
}
else if (executionContext.m_isFlowSuppressed)
{
executionContext = null;
}
return executionContext;
}
}下面是经过整理的 Thread 的与 ExecutionContext 相关的部分，Thread 属于部分类，_executionContext 字段定义在 Thread.CoreCLR.cs 文件中
class Thread
{
// 保存当前线程所关联的 执行上下文
internal ExecutionContext? _executionContext;
[ThreadStatic]
private static Thread? t_currentThread;
public static Thread CurrentThread => t_currentThread ?? InitializeCurrentThread();
public ExecutionContext? ExecutionContext => ExecutionContext.Capture();
}2.2.2、ExecutionContext 的私有变量
public sealed class ExecutionContext : IDisposable, ISerializable
{
// 默认执行上下文
internal static readonly ExecutionContext Default = new ExecutionContext(isDefault: true);
// 执行上下文禁止流动后的默认上下文
internal static readonly ExecutionContext DefaultFlowSuppressed = new ExecutionContext(AsyncLocalValueMap.Empty, Array.Empty<IAsyncLocal>(), isFlowSuppressed: true);
// 保存所有注册了修改回调的 AsyncLocal 的 Value 值，本文暂不涉及对此字段的具体讨论
private readonly IAsyncLocalValueMap? m_localValues;
// 保存所有注册了回调的 AsyncLocal 的对象引用
private readonly IAsyncLocal[]? m_localChangeNotifications;
// 当前线程是否禁止上下文流动
private readonly bool m_isFlowSuppressed;
// 当前上下文是否是默认上下文
private readonly bool m_isDefault;
}2.2.3、IAsyncLocalValueMap 接口及其实现
在同一个线程中，所有 AsyncLocal 所保存的 Value 都保存在 ExecutionContext 的 m_localValues 字段上。
public class ExecutionContext
{
private readonly IAsyncLocalValueMap m_localValues;
}为了优化查找值时的性能，微软为 IAsyncLocalValueMap 提供了6个实现
| 类型 | 元素个数 |
|---|---|
| EmptyAsyncLocalValueMap | 0 |
| OneElementAsyncLocalValueMap | 1 |
| TwoElementAsyncLocalValueMap | 2 |
| ThreeElementAsyncLocalValueMap | 3 |
| MultiElementAsyncLocalValueMap | 4 ~ 16 |
| ManyElementAsyncLocalValueMap | > 16 |
随着 ExecutionContext 所关联的 AsyncLocal 数量的增加，IAsyncLocalValueMap 的实现将会在ExecutionContext的SetLocalValue方法中被不断替换。查询的时间复杂度和空间复杂度依次递增。代码的实现与 AsyncLocal 同属于 一个文件。当然元素数量减少时也会替换成之前的实现。
// 这个接口是用来在 ExecutionContext 中保存 IAsyncLocal => object 的映射关系。
// 其实现被设定为不可变的(immutable)，随着元素的数量增加而变化，空间复杂度和时间复杂度也随之增加。
internal interface IAsyncLocalValueMap
{
bool TryGetValue(IAsyncLocal key, out object? value);
// 通过此方法新增 AsyncLocal 或修改现有的 AsyncLocal
// 如果数量无变化，返回同类型的 IAsyncLocalValueMap 实现类实例
// 如果数量发生变化（增加或减少，将value设值为null时会减少），则可能返回不同类型的 IAsyncLocalValueMap 实现类实例
IAsyncLocalValueMap Set(IAsyncLocal key, object? value, bool treatNullValueAsNonexistent);
}Map 的创建是以静态类 AsyncLocalValueMap 的 Create 方法作为创建的入口的。
internal static class AsyncLocalValueMap
{
// EmptyAsyncLocalValueMap 设计上只在这边实例化，其他地方当作常量使用
public static IAsyncLocalValueMap Empty { get; } = new EmptyAsyncLocalValueMap();
public static bool IsEmpty(IAsyncLocalValueMap asyncLocalValueMap)
{
Debug.Assert(asyncLocalValueMap != null);
Debug.Assert(asyncLocalValueMap == Empty || asyncLocalValueMap.GetType() != typeof(EmptyAsyncLocalValueMap));
return asyncLocalValueMap == Empty;
}
public static IAsyncLocalValueMap Create(IAsyncLocal key, object? value, bool treatNullValueAsNonexistent)
{
// 创建最初的实例
// 如果 AsyncLocal 注册了回调，则需要保存 null 的 Value，以便下次设置非null的值时因为值发生变化而触发回调
return value != null || !treatNullValueAsNonexistent ?
new OneElementAsyncLocalValueMap(key, value) :
Empty;
}
}此后每次更新元素时都必须调用 IAsyncLocalValueMap 实现类的 Set 方法，原实例是不会发生变化的，需保存 Set 的返回值。
接下来以 ThreeElementAsyncLocalValueMap 为例进行解释
private sealed class ThreeElementAsyncLocalValueMap : IAsyncLocalValueMap
{
// 申明三个私有字段保存 key
private readonly IAsyncLocal _key1, _key2, _key3;
// 申明三个私有字段保存
private readonly object? _value1, _value2, _value3;
public ThreeElementAsyncLocalValueMap(IAsyncLocal key1, object? value1, IAsyncLocal key2, object? value2, IAsyncLocal key3, object? value3)
{
_key1 = key1; _value1 = value1;
_key2 = key2; _value2 = value2;
_key3 = key3; _value3 = value3;
}
public IAsyncLocalValueMap Set(IAsyncLocal key, object? value, bool treatNullValueAsNonexistent)
{
// 如果 AsyncLocal 注册过回调，treatNullValueAsNonexistent 的值是 false，
// 意思是就算 value 是 null，也认为它是有效的
if (value != null || !treatNullValueAsNonexistent)
{
// 如果现在的 map 已经保存过传入的 key ，则返回一个更新了 value 值的新 map 实例
if (ReferenceEquals(key, _key1)) return new ThreeElementAsyncLocalValueMap(key, value, _key2, _value2, _key3, _value3);
if (ReferenceEquals(key, _key2)) return new ThreeElementAsyncLocalValueMap(_key1, _value1, key, value, _key3, _value3);
if (ReferenceEquals(key, _key3)) return new ThreeElementAsyncLocalValueMap(_key1, _value1, _key2, _value2, key, value);
// 如果当前Key不存在map里，则需要一个能存放第四个key的map
var multi = new MultiElementAsyncLocalValueMap(4);
multi.UnsafeStore(0, _key1, _value1);
multi.UnsafeStore(1, _key2, _value2);
multi.UnsafeStore(2, _key3, _value3);
multi.UnsafeStore(3, key, value);
return multi;
}
else
{
// value 是 null，对应的 key 会被忽略或者从 map 中去除，这边会有两种情况
// 1、如果当前的 key 存在于 map 当中，则将这个 key 去除，map 类型降级为 TwoElementAsyncLocalValueMap
return
ReferenceEquals(key, _key1) ? new TwoElementAsyncLocalValueMap(_key2, _value2, _key3, _value3) :
ReferenceEquals(key, _key2) ? new TwoElementAsyncLocalValueMap(_key1, _value1, _key3, _value3) :
ReferenceEquals(key, _key3) ? new TwoElementAsyncLocalValueMap(_key1, _value1, _key2, _value2) :
// 2、当前 key 不存在于 map 中，则会被直接忽略
(IAsyncLocalValueMap)this;
}
}
// 至多对比三次就能找到对应的 value
public bool TryGetValue(IAsyncLocal key, out object? value)
{
if (ReferenceEquals(key, _key1))
{
value = _value1;
return true;
}
else if (ReferenceEquals(key, _key2))
{
value = _value2;
return true;
}
else if (ReferenceEquals(key, _key3))
{
value = _value3;
return true;
}
else
{
value = null;
return false;
}
}
}2.2.4、ExecutionContext - SetLocalValue
需要注意的是这边会涉及到两个 Immutable 结构，一个是 ExecutionContext 本身，另一个是 IAsyncLocalValueMap 的实现类。同一个 key 前后两次 value 发生变化后，会产生新的 ExecutionContext 的实例和 IAsyncLocalMap 实现类实例（在 IAsyncLocalValueMap 实现类的 Set 方法中完成）。
internal static void SetLocalValue(IAsyncLocal local, object? newValue, bool needChangeNotifications)
{
// 获取当前执行上下文
ExecutionContext? current = Thread.CurrentThread._executionContext;
object? previousValue = null;
bool hadPreviousValue = false;
if (current != null)
{
Debug.Assert(!current.IsDefault);
Debug.Assert(current.m_localValues != null, "Only the default context should have null, and we shouldn't be here on the default context");
// 判断当前作为 Key 的 AsyncLocal 是否已经有对应的 Value
hadPreviousValue = current.m_localValues.TryGetValue(local, out previousValue);
}
// 如果前后两次 Value 没有发生变化，则继续处理
if (previousValue == newValue)
{
return;
}
// 对于 treatNullValueAsNonexistent: !needChangeNotifications 的说明
// 如果 AsyncLocal 注册了回调，则 needChangeNotifications 为 ture，m_localValues 会保存 null 值以便下次触发change回调
IAsyncLocal[]? newChangeNotifications = null;
IAsyncLocalValueMap newValues;
bool isFlowSuppressed = false;
if (current != null)
{
Debug.Assert(!current.IsDefault);
Debug.Assert(current.m_localValues != null, "Only the default context should have null, and we shouldn't be here on the default context");
isFlowSuppressed = current.m_isFlowSuppressed;
// 这一步很关键，通过调用 m_localValues.Set 对 map 进行修改，这会产生一个新的 map 实例。
newValues = current.m_localValues.Set(local, newValue, treatNullValueAsNonexistent: !needChangeNotifications);
newChangeNotifications = current.m_localChangeNotifications;
}
else
{
// 如果当前上下文不存在，创建第一个 IAsyncLocalValueMap 实例
newValues = AsyncLocalValueMap.Create(local, newValue, treatNullValueAsNonexistent: !needChangeNotifications);
}
// 如果 AsyncLocal 注册了回调，则需要保存 AsyncLocal 的引用
// 这边会有两种情况，一个是数组未创建过，一个是数组已存在
if (needChangeNotifications)
{
if (hadPreviousValue)
{
Debug.Assert(newChangeNotifications != null);
Debug.Assert(Array.IndexOf(newChangeNotifications, local) >= 0);
}
else if (newChangeNotifications == null)
{
newChangeNotifications = new IAsyncLocal[1] { local };
}
else
{
int newNotificationIndex = newChangeNotifications.Length;
// 这个方法会创建一个新数组并将原来的元素拷贝过去
Array.Resize(ref newChangeNotifications, newNotificationIndex + 1);
newChangeNotifications[newNotificationIndex] = local;
}
}
// 如果 AsyncLocal 存在有效值，且允许执行上下文流动，则创建新的 ExecutionContext实例，新实例会保存所有的AsyncLocal的值和所有需要通知的 AsyncLocal 引用。
Thread.CurrentThread._executionContext =
(!isFlowSuppressed && AsyncLocalValueMap.IsEmpty(newValues)) ?
null : // No values, return to Default context
new ExecutionContext(newValues, newChangeNotifications, isFlowSuppressed);
if (needChangeNotifications)
{
// 调用先前注册好的委托
local.OnValueChanged(previousValue, newValue, contextChanged: false);
}
}2.2.5、ExecutionContext - GetLocalValue
值的获取实现相对简单
internal static object? GetLocalValue(IAsyncLocal local)
{
ExecutionContext? current = Thread.CurrentThread._executionContext;
if (current == null)
{
return null;
}
Debug.Assert(!current.IsDefault);
Debug.Assert(current.m_localValues != null, "Only the default context should have null, and we shouldn't be here on the default context");
current.m_localValues.TryGetValue(local, out object? value);
return value;
}3、ExecutionContext 的流动
在线程发生切换的时候，ExecutionContext 会在前一个线程中被默认捕获，流向下一个线程，它所保存的数据也就随之流动。
在所有会发生线程切换的地方，基础类库(BCL) 都为我们封装好了对执行上下文的捕获。
例如：
- new Thread(ThreadStart start).Start()
- Task.Run(Action action)
- ThreadPool.QueueUserWorkItem(WaitCallback callBack)
- await 语法糖
class Program
{
static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
static async Task Main(string[] args)
{
_asyncLocal.Value = "AsyncLocal保存的数据";
new Thread(() =>
{
Console.WriteLine($"new Thread: {_asyncLocal.Value}");
})
{
IsBackground = true
}.Start();
ThreadPool.QueueUserWorkItem(_ =>
{
Console.WriteLine($"ThreadPool.QueueUserWorkItem: {_asyncLocal.Value}");
});
Task.Run(() =>
{
Console.WriteLine($"Task.Run: {_asyncLocal.Value}");
});
await Task.Delay(100);
Console.WriteLine($"after await: {_asyncLocal.Value}");
}
}输出结果：
new Thread: AsyncLocal保存的数据
ThreadPool.QueueUserWorkItem: AsyncLocal保存的数据
Task.Run: AsyncLocal保存的数据
after await: AsyncLocal保存的数据
3.1、流动的禁止和恢复
ExecutionContext 为我们提供了 SuppressFlow（禁止流动） 和 RestoreFlow （恢复流动）这两个静态方法来控制当前线程的执行上下文是否像辅助线程流动。并可以通过 IsFlowSuppressed 静态方法来进行判断。
class Program
{
static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
static async Task Main(string[] args)
{
_asyncLocal.Value = "AsyncLocal保存的数据";
Console.WriteLine("默认：");
PrintAsync(); // 不 await，后面的线程不会发生切换
Thread.Sleep(1000); // 确保上面的方法内的所有线程都执行完
ExecutionContext.SuppressFlow();
Console.WriteLine("SuppressFlow：");
PrintAsync();
Thread.Sleep(1000);
Console.WriteLine("RestoreFlow：");
ExecutionContext.RestoreFlow();
await PrintAsync();
Console.Read();
}
static async ValueTask PrintAsync()
{
new Thread(() =>
{
Console.WriteLine($" new Thread: {_asyncLocal.Value}");
})
{
IsBackground = true
}.Start();
Thread.Sleep(100); // 保证输出顺序
ThreadPool.QueueUserWorkItem(_ =>
{
Console.WriteLine($" ThreadPool.QueueUserWorkItem: {_asyncLocal.Value}");
});
Thread.Sleep(100);
Task.Run(() =>
{
Console.WriteLine($" Task.Run: {_asyncLocal.Value}");
});
await Task.Delay(100);
Console.WriteLine($" after await: {_asyncLocal.Value}");
Console.WriteLine();
}
}输出结果：
默认：
new Thread: AsyncLocal保存的数据
ThreadPool.QueueUserWorkItem: AsyncLocal保存的数据
Task.Run: AsyncLocal保存的数据
after await: AsyncLocal保存的数据
SuppressFlow：
new Thread:
ThreadPool.QueueUserWorkItem:
Task.Run:
after await:
RestoreFlow：
new Thread: AsyncLocal保存的数据
ThreadPool.QueueUserWorkItem: AsyncLocal保存的数据
Task.Run: AsyncLocal保存的数据
after await: AsyncLocal保存的数据
需要注意的是，在线程A中创建线程B之前调用 ExecutionContext.SuppressFlow 只会影响 ExecutionContext 从线程A => 线程B的传递，线程B => 线程C 不受影响。
class Program
{
static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
static void Main(string[] args)
{
_asyncLocal.Value = "A => B";
ExecutionContext.SuppressFlow();
new Thread((() =>
{
Console.WriteLine($"线程B：{_asyncLocal.Value}"); // 输出线程B：
_asyncLocal.Value = "B => C";
new Thread((() =>
{
Console.WriteLine($"线程C：{_asyncLocal.Value}"); // 输出线程C：B => C
}))
{
IsBackground = true
}.Start();
}))
{
IsBackground = true
}.Start();
Console.Read();
}
}3.2、ExcutionContext 的流动实现
上面举例了四种场景，由于每一种场景的传递过程都比较复杂，目前先介绍其中一个。
但不管什么场景，都会涉及到 ExcutionContext 的 Run 方法。在Run 方法中会调用 RunInternal 方法，
public static void Run(ExecutionContext executionContext, ContextCallback callback, object? state)
{
if (executionContext == null)
{
ThrowNullContext();
}
// 内部会调用 RestoreChangedContextToThread 方法
RunInternal(executionContext, callback, state);
}RunInternal 调用下面一个 RestoreChangedContextToThread 方法将 ExcutionContext.Run 方法传入的 ExcutionContext 赋值给当前线程的 _executionContext 字段。
internal static void RestoreChangedContextToThread(Thread currentThread, ExecutionContext? contextToRestore, ExecutionContext? currentContext)
{
Debug.Assert(currentThread == Thread.CurrentThread);
Debug.Assert(contextToRestore != currentContext);
// 在这边把之前的 ExecutionContext 赋值给了当前线程
currentThread._executionContext = contextToRestore;
if ((currentContext != null && currentContext.HasChangeNotifications) ||
(contextToRestore != null && contextToRestore.HasChangeNotifications))
{
OnValuesChanged(currentContext, contextToRestore);
}
}3.2.1、new Thread(ThreadStart start).Start() 为例说明 ExecutionContext 的流动
这边可以分为三个步骤：
在 Thread 的 Start 方法中捕获当前的 ExecutionContext，将其传递给 Thread 的构造函数中实例化的 ThreadHelper 实例，ExecutionContext 会暂存在 ThreadHelper 的实例字段中，线程创建完成后会调用ExecutionContext.RunInternal 将其赋值给新创建的线程。
代码位置：
public void Start()
{
#if FEATURE_COMINTEROP_APARTMENT_SUPPORT
// Eagerly initialize the COM Apartment state of the thread if we're allowed to.
StartupSetApartmentStateInternal();
#endif // FEATURE_COMINTEROP_APARTMENT_SUPPORT
// Attach current thread's security principal object to the new
// thread. Be careful not to bind the current thread to a principal
// if it's not already bound.
if (_delegate != null)
{
// If we reach here with a null delegate, something is broken. But we'll let the StartInternal method take care of
// reporting an error. Just make sure we don't try to dereference a null delegate.
Debug.Assert(_delegate.Target is ThreadHelper);
// 由于 _delegate 指向 ThreadHelper 的实例方法，所以 _delegate.Target 指向 ThreadHelper 实例。
var t = (ThreadHelper)_delegate.Target;
ExecutionContext? ec = ExecutionContext.Capture();
t.SetExecutionContextHelper(ec);
}
StartInternal();
}class ThreadHelper
{
internal ThreadHelper(Delegate start)
{
_start = start;
}
internal void SetExecutionContextHelper(ExecutionContext? ec)
{
_executionContext = ec;
}
// 这个方法是对 Thread 构造函数传入的委托的包装
internal void ThreadStart()
{
Debug.Assert(_start is ThreadStart);
ExecutionContext? context = _executionContext;
if (context != null)
{
// 将 ExecutionContext 与 CurrentThread 进行绑定
ExecutionContext.RunInternal(context, s_threadStartContextCallback, this);
}
else
{
InitializeCulture();
((ThreadStart)_start)();
}
}
}4、总结
AsyncLocal 本身不保存数据，数据保存在 ExecutionContext 实例的 m_localValues 的私有字段上，字段类型定义是 IAsyncLocalMap ，以 IAsyncLocal => object 的 Map 结构进行保存，且实现类型随着元素数量的变化而变化。
ExecutionContext 实例 保存在 Thread.CurrentThread._executionContext 上，实现与当前线程的关联。
对于 IAsyncLocalMap 的实现类，如果 AsyncLocal 注册了回调，value 传 null 不会被忽略。
没注册回调时分为两种情况：如果 key 存在，则做删除处理，map 类型可能出现降级。如果 key 不存在，则直接忽略。
ExecutionContext 和 IAsyncLocalMap 的实现类都被设计成不可变(immutable)。同一个 key 前后两次 value 发生变化后，会产生新的 ExecutionContext 的实例和 IAsyncLocalMap 实现类实例。
ExecutionContext 与当前线程绑定，默认流动到辅助线程，可以禁止流动和恢复流动，且禁止流动仅影响当前线程向其辅助线程的传递，不影响后续。
到此这篇关于浅析.NET中AsyncLocal的实现原理的文章就介绍到这了,更多相关.NET AsyncLocal内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！