public class HttpContextAccessor : IHttpContextAccessor
{
    private static AsyncLocal<HttpContextHolder> _httpContextCurrent = new AsyncLocal<HttpContextHolder>();
	// 其他代碼這里不展示
}

class Program
{
    [ThreadStatic]
    private static string _value;
    static void Main(string[] args)
    {
        Parallel.For(0, 4, _ =>
        {
            var threadId = Thread.CurrentThread.ManagedThreadId;
            _value ??= $"這是來自線程{threadId}的數(shù)據(jù)";
            Console.WriteLine($"Thread：{threadId}; Value：{_value}");
        });
    }
}

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}的數(shù)據(jù)";
            _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();
    }
}

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保存的數(shù)據(jù)";
        _threadLocal.Value = "ThreadLocal保存的數(shù)據(jù)";
        _asyncLocal.Value = "AsyncLocal保存的數(shù)據(jù)";
        PrintValuesInAnotherThread();
        Console.ReadKey();
    }
    private static void PrintValuesInAnotherThread()
    {
        Task.Run(() =>
        {
            Console.WriteLine($"ThreadStatic: {_threadStatic}");
            Console.WriteLine($"ThreadLocal: {_threadLocal.Value}");
            Console.WriteLine($"AsyncLocal: {_asyncLocal.Value}");
        });
    }
}

public sealed class AsyncLocal<T> : IAsyncLocal
{
    private readonly Action<AsyncLocalValueChangedArgs<T>>? m_valueChangedHandler;
    // 無參構(gòu)造
    public AsyncLocal()
    {
    }
    // 可以注冊回調(diào)的構(gòu)造函數(shù)，當(dāng) Value 在任意線程被改動(dòng)，將調(diào)用回調(diào)
    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;
        }
        // 是否注冊回調(diào)將回影響到 ExecutionContext 是否保存其引用
        set => ExecutionContext.SetLocalValue(this, value, m_valueChangedHandler != null);
    }
    // 在 ExecutionContext 如果判斷到值發(fā)生了變化，此方法將被調(diào)用
    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);
}

public class ExecutionContext
{
    internal static object? GetLocalValue(IAsyncLocal local);
    internal static void SetLocalValue(
        IAsyncLocal local,
        object? newValue,
        bool needChangeNotifications);
}

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;
    }
}

class Thread
{
	// 保存當(dāng)前線程所關(guān)聯(lián)的 執(zhí)行上下文
    internal ExecutionContext? _executionContext;
    [ThreadStatic]
    private static Thread? t_currentThread;
    public static Thread CurrentThread => t_currentThread ?? InitializeCurrentThread();
	public ExecutionContext? ExecutionContext => ExecutionContext.Capture();
}

public sealed class ExecutionContext : IDisposable, ISerializable
{
    // 默認(rèn)執(zhí)行上下文
    internal static readonly ExecutionContext Default = new ExecutionContext(isDefault: true);
    // 執(zhí)行上下文禁止流動(dòng)后的默認(rèn)上下文
    internal static readonly ExecutionContext DefaultFlowSuppressed = new ExecutionContext(AsyncLocalValueMap.Empty, Array.Empty<IAsyncLocal>(), isFlowSuppressed: true);
	// 保存所有注冊了修改回調(diào)的 AsyncLocal 的 Value 值，本文暫不涉及對此字段的具體討論
    private readonly IAsyncLocalValueMap? m_localValues;
    // 保存所有注冊了回調(diào)的 AsyncLocal 的對象引用
    private readonly IAsyncLocal[]? m_localChangeNotifications;
    // 當(dāng)前線程是否禁止上下文流動(dòng)
    private readonly bool m_isFlowSuppressed;
    // 當(dāng)前上下文是否是默認(rèn)上下文
    private readonly bool m_isDefault;
}

public class ExecutionContext
{
    private readonly IAsyncLocalValueMap m_localValues;
}

// 這個(gè)接口是用來在 ExecutionContext 中保存 IAsyncLocal => object 的映射關(guān)系。
// 其實(shí)現(xiàn)被設(shè)定為不可變的(immutable)，隨著元素的數(shù)量增加而變化，空間復(fù)雜度和時(shí)間復(fù)雜度也隨之增加。
internal interface IAsyncLocalValueMap
{
    bool TryGetValue(IAsyncLocal key, out object? value);
	// 通過此方法新增 AsyncLocal 或修改現(xiàn)有的 AsyncLocal
    // 如果數(shù)量無變化，返回同類型的 IAsyncLocalValueMap 實(shí)現(xiàn)類實(shí)例
	// 如果數(shù)量發(fā)生變化（增加或減少，將value設(shè)值為null時(shí)會(huì)減少），則可能返回不同類型的 IAsyncLocalValueMap 實(shí)現(xiàn)類實(shí)例
    IAsyncLocalValueMap Set(IAsyncLocal key, object? value, bool treatNullValueAsNonexistent);
}

internal static class AsyncLocalValueMap
{
    // EmptyAsyncLocalValueMap 設(shè)計(jì)上只在這邊實(shí)例化，其他地方當(dāng)作常量使用
    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)
    {
        // 創(chuàng)建最初的實(shí)例
        // 如果 AsyncLocal 注冊了回調(diào)，則需要保存 null 的 Value，以便下次設(shè)置非null的值時(shí)因?yàn)橹蛋l(fā)生變化而觸發(fā)回調(diào)
        return value != null || !treatNullValueAsNonexistent ?
            new OneElementAsyncLocalValueMap(key, value) :
            Empty;
    }
}

private sealed class ThreeElementAsyncLocalValueMap : IAsyncLocalValueMap
{
	// 申明三個(gè)私有字段保存 key
    private readonly IAsyncLocal _key1, _key2, _key3;
	// 申明三個(gè)私有字段保存
    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 注冊過回調(diào)，treatNullValueAsNonexistent 的值是 false，
		// 意思是就算 value 是 null，也認(rèn)為它是有效的
        if (value != null || !treatNullValueAsNonexistent)
        {
			// 如果現(xiàn)在的 map 已經(jīng)保存過傳入的 key ，則返回一個(gè)更新了 value 值的新 map 實(shí)例
            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);
            // 如果當(dāng)前Key不存在map里，則需要一個(gè)能存放第四個(gè)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，對應(yīng)的 key 會(huì)被忽略或者從 map 中去除，這邊會(huì)有兩種情況
			// 1、如果當(dāng)前的 key 存在于 map 當(dāng)中，則將這個(gè) key 去除，map 類型降級(jí)為 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、當(dāng)前 key 不存在于 map 中，則會(huì)被直接忽略
                (IAsyncLocalValueMap)this;
        }
    }
	// 至多對比三次就能找到對應(yīng)的 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;
        }
    }
}

internal static void SetLocalValue(IAsyncLocal local, object? newValue, bool needChangeNotifications)
{
	// 獲取當(dāng)前執(zhí)行上下文
    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");
		// 判斷當(dāng)前作為 Key 的 AsyncLocal 是否已經(jīng)有對應(yīng)的 Value 
        hadPreviousValue = current.m_localValues.TryGetValue(local, out previousValue);
    }
	// 如果前后兩次 Value 沒有發(fā)生變化，則繼續(xù)處理
    if (previousValue == newValue)
    {
        return;
    }
	// 對于 treatNullValueAsNonexistent: !needChangeNotifications 的說明
	// 如果 AsyncLocal 注冊了回調(diào)，則 needChangeNotifications 為 ture，m_localValues 會(huì)保存 null 值以便下次觸發(fā)change回調(diào)
    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;
		// 這一步很關(guān)鍵，通過調(diào)用 m_localValues.Set 對 map 進(jìn)行修改，這會(huì)產(chǎn)生一個(gè)新的 map 實(shí)例。
        newValues = current.m_localValues.Set(local, newValue, treatNullValueAsNonexistent: !needChangeNotifications);
        newChangeNotifications = current.m_localChangeNotifications;
    }
    else
    {
        // 如果當(dāng)前上下文不存在，創(chuàng)建第一個(gè) IAsyncLocalValueMap 實(shí)例
        newValues = AsyncLocalValueMap.Create(local, newValue, treatNullValueAsNonexistent: !needChangeNotifications);
    }
    // 如果 AsyncLocal 注冊了回調(diào)，則需要保存 AsyncLocal 的引用
    // 這邊會(huì)有兩種情況，一個(gè)是數(shù)組未創(chuàng)建過，一個(gè)是數(shù)組已存在
    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;
			// 這個(gè)方法會(huì)創(chuàng)建一個(gè)新數(shù)組并將原來的元素拷貝過去
			Array.Resize(ref newChangeNotifications, newNotificationIndex + 1);
            newChangeNotifications[newNotificationIndex] = local;
        }
    }
	// 如果 AsyncLocal 存在有效值，且允許執(zhí)行上下文流動(dòng)，則創(chuàng)建新的 ExecutionContext實(shí)例，新實(shí)例會(huì)保存所有的AsyncLocal的值和所有需要通知的 AsyncLocal 引用。
    Thread.CurrentThread._executionContext =
        (!isFlowSuppressed && AsyncLocalValueMap.IsEmpty(newValues)) ?
        null : // No values, return to Default context
        new ExecutionContext(newValues, newChangeNotifications, isFlowSuppressed);
    if (needChangeNotifications)
    {
		// 調(diào)用先前注冊好的委托
        local.OnValueChanged(previousValue, newValue, contextChanged: false);
    }
}

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;
}

class Program
{
    static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    static async Task Main(string[] args)
    {
        _asyncLocal.Value = "AsyncLocal保存的數(shù)據(jù)";
        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}");
    }
}

class Program
{
    static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    static async Task Main(string[] args)
    {
        _asyncLocal.Value = "AsyncLocal保存的數(shù)據(jù)";
        Console.WriteLine("默認(rèn)：");
        PrintAsync(); // 不 await，后面的線程不會(huì)發(fā)生切換
        Thread.Sleep(1000); // 確保上面的方法內(nèi)的所有線程都執(zhí)行完
        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();
    }
}

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();
    }
}

public static void Run(ExecutionContext executionContext, ContextCallback callback, object? state)
{
    if (executionContext == null)
    {
        ThrowNullContext();
    }
	// 內(nèi)部會(huì)調(diào)用 RestoreChangedContextToThread 方法
    RunInternal(executionContext, callback, state);
}

internal static void RestoreChangedContextToThread(Thread currentThread, ExecutionContext? contextToRestore, ExecutionContext? currentContext)
{
    Debug.Assert(currentThread == Thread.CurrentThread);
    Debug.Assert(contextToRestore != currentContext);
	// 在這邊把之前的 ExecutionContext 賦值給了當(dāng)前線程
    currentThread._executionContext = contextToRestore;
    if ((currentContext != null && currentContext.HasChangeNotifications) ||
        (contextToRestore != null && contextToRestore.HasChangeNotifications))
    {
        OnValuesChanged(currentContext, contextToRestore);
    }
}

        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 的實(shí)例方法，所以 _delegate.Target 指向 ThreadHelper 實(shí)例。
                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;
    }
    // 這個(gè)方法是對 Thread 構(gòu)造函數(shù)傳入的委托的包裝
    internal void ThreadStart()
    {
        Debug.Assert(_start is ThreadStart);
        ExecutionContext? context = _executionContext;
        if (context != null)
        {
			// 將 ExecutionContext 與 CurrentThread 進(jìn)行綁定
            ExecutionContext.RunInternal(context, s_threadStartContextCallback, this);
        }
        else
        {
            InitializeCulture();
            ((ThreadStart)_start)();
        }
    }
}