AsyncLocal 用法簡介

通過 AsyncLocal 我們可以在一個邏輯上下文中維護一份私有數據，該上下文后續代碼中都可以訪問和修改這份數據，但另一個無關的上下文是無法訪問的。

無論是在新創建的 Task 中還是 await 關鍵詞之后，我們都能夠訪問前面設置的 AsyncLocal 的數據。

class Program
{
    private static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    
    static async Task Main(string[] args)
    {
        _asyncLocal.Value = "Hello World!";
        Task.Run(() => Console.WriteLine($"AsyncLocal in task: {_asyncLocal.Value}"));

        await FooAsync();
        Console.WriteLine($"AsyncLocal after await FooAsync: {_asyncLocal.Value}");
    }

    private static async Task FooAsync()
    {
        await Task.Delay(100);
        Console.WriteLine($"AsyncLocal after await in FooAsync: {_asyncLocal.Value}");
    }
}

輸出結果：

AsyncLocal in task: Hello World!

AsyncLocal after await in FooAsync: Hello World!

AsyncLocal after await FooAsync: Hello World!

AsyncLocal 實現原理

在我之前的博客揭秘 .NET 中的 AsyncLocal 中深入介紹了 AsyncLocal 的實現原理，這里只做簡單的回顧。

AsyncLocal 的實際數據存儲在 ExecutionContext 中，而 ExecutionContext 作為線程的私有字段與線程綁定，在線程會發生切換的地方，runtime 會將切換前的 ExecutionContext 保存起來，切換后再恢復到新線程上。

這個保存和恢復的過程是由 runtime 自動完成的，例如會發生在以下幾個地方：

new Thread(ThreadStart start).Start()
Task.Run(Action action)
ThreadPool.QueueUserWorkItem(WaitCallback callBack)
await 之后

以 await 為例，當我們在一個方法中使用了 await 關鍵詞，編譯器會將這個方法編譯成一個狀態機，這個狀態機會在 await 之前和之后分別保存和恢復 ExecutionContext。

class Program
{
    private static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    
    static async Task Main(string[] args)
    {
        _asyncLocal.Value = "Hello World!";
        await FooAsync();
        Console.WriteLine($"AsyncLocal after await FooAsync: {_asyncLocal.Value}");
    }

    private static async Task FooAsync()
    {
        await Task.Delay(100);
    }
}

輸出結果：

AsyncLocal after await FooAsync: Hello World!

AsyncLocal 的坑

有時候我們會在 FooAsync 方法中去修改 AsyncLocal 的值，并希望在 Main 方法在 await FooAsync 之后能夠獲取到修改后的值，但是實際上這是不可能的。

class Program
{
    private static AsyncLocal<string> _asyncLocal = new AsyncLocal<string>();
    
    static async Task Main(string[] args)
    {
        _asyncLocal.Value = "A";
        Console.WriteLine($"AsyncLocal before FooAsync: {_asyncLocal.Value}");
        await FooAsync();
        Console.WriteLine($"AsyncLocal after await FooAsync: {_asyncLocal.Value}");
    }

    private static async Task FooAsync()
    {
        _asyncLocal.Value = "B";
        Console.WriteLine($"AsyncLocal before await in FooAsync: {_asyncLocal.Value}");
        await Task.Delay(100);
        Console.WriteLine($"AsyncLocal after await in FooAsync: {_asyncLocal.Value}");
    }
}

輸出結果：

AsyncLocal before FooAsync: A

AsyncLocal before await in FooAsync: B

AsyncLocal after await in FooAsync: B

AsyncLocal after await FooAsync: A

為什么我們在 FooAsync 方法中修改了 AsyncLocal 的值，但是在 await FooAsync 之后，AsyncLocal 的值卻沒有被修改呢？

原因是 ExecutionContext 被設計成了一個不可變的對象，當我們在 FooAsync 方法中修改了 AsyncLocal 的值，實際上是創建了一個新的 ExecutionContext，原來其他的 AsyncLocal 的值被值拷貝到了新的 ExecutionContext 中，新的 AsyncLocal 的值只會寫入到新的 ExecutionContext 中，而原來的 ExecutionContext 及其關聯的 AsyncLocal 仍然保持不變。

這樣的設計是為了保證線程的安全性，因為在多線程環境下，如果 ExecutionContext 是可變的，那么在切換線程的時候，可能會出現數據不一致的情況。

我們通常把這種設計稱為 Copy On Write（簡稱COW），即在修改數據的時候，會先拷貝一份數據，然后在拷貝的數據上進行修改，這樣就不會影響到原來的數據。

ExecutionContext 中可能不止一個 AsyncLocal 的數據，修改任意一個 AsyncLocal 都會導致 ExecutionContext 的 COW。

所以上面代碼的執行過程如下：

AsyncLocal 的避坑指南

那么我們如何在 FooAsync 方法中修改 AsyncLocal 的值，并且在 Main 方法中獲取到修改后的值呢？

我們需要借助一個中介者，讓中介者來保存 AsyncLocal 的值，然后在 FooAsync 方法中修改中介者的屬性值，這樣就可以在 Main 方法中獲取到修改后的值了。

下面我們設計一個 ValueHolder 來保存 AsyncLocal 的值，修改 Value 并不會修改 AsyncLocal 的值，而是修改 ValueHolder 的屬性值，這樣就不會觸發 ExecutionContext 的 COW。

我們還需要設計一個 ValueAccessor 來封裝 ValueHolder 對值的訪問和修改，這樣可以保證 ValueHolder 的值只能在 ValueAccessor 中被修改。

class ValueAccessor<T> : IValueAccessor<T>
{
    private static AsyncLocal<ValueHolder<T>> _asyncLocal = new AsyncLocal<ValueHolder<T>>();

    public T Value
    {
        get => _asyncLocal.Value != null ? _asyncLocal.Value.Value : default;
        set
        {
            _asyncLocal.Value ??= new ValueHolder<T>();

            _asyncLocal.Value.Value = value;
        }
    }
}

class ValueHolder<T>
{
    public T Value { get; set; }
}

class Program
{
    private static IValueAccessor<string> _valueAccessor = new ValueAccessor<string>();

    static async Task Main(string[] args)
    {
        _valueAccessor.Value = "A";
        Console.WriteLine($"ValueAccessor before await FooAsync in Main: {_valueAccessor.Value}");
        await FooAsync();
        Console.WriteLine($"ValueAccessor after await FooAsync in Main: {_valueAccessor.Value}");
    }

    private static async Task FooAsync()
    {
        _valueAccessor.Value = "B";
        Console.WriteLine($"ValueAccessor before await in FooAsync: {_valueAccessor.Value}");
        await Task.Delay(100);
        Console.WriteLine($"ValueAccessor after await in FooAsync: {_valueAccessor.Value}");
    }
}

輸出結果：

ValueAccessor before await FooAsync in Main: A

ValueAccessor before await in FooAsync: B

ValueAccessor after await in FooAsync: B

ValueAccessor after await FooAsync in Main: B

HttpContextAccessor 的實現原理

我們常用的 HttpContextAccessor 通過HttpContextHolder 來間接地在 AsyncLocal 中存儲 HttpContext。

如果要更新 HttpContext，只需要在 HttpContextHolder 中更新即可。因為 AsyncLocal 的值不會被修改，更新 HttpContext 時 ExecutionContext 也不會出現 COW 的情況。

不過 HttpContextAccessor 中的邏輯有點特殊，它的 HttpContextHolder 是為保證清除 HttpContext 時，這個 HttpContext 能在所有引用它的 ExecutionContext 中被清除（可能因為修改 HttpContextHolder 之外的 AsyncLocal 數據導致 ExecutionContext 已經 COW 很多次了）。

下面是 HttpContextAccessor 的實現，英文注釋是原文，中文注釋是我自己的理解。

/// </summary>
public class HttpContextAccessor : IHttpContextAccessor
{
    private static readonly AsyncLocal<HttpContextHolder> _httpContextCurrent = new AsyncLocal<HttpContextHolder>();

    /// <inheritdoc/>
    public HttpContext? HttpContext
    {
        get
        {
            return _httpContextCurrent.Value?.Context;
        }
        set
        {
            var holder = _httpContextCurrent.Value;
            if (holder != null)
            {
                // Clear current HttpContext trapped in the AsyncLocals, as its done.
                // 這邊的邏輯是為了保證清除 HttpContext 時，這個 HttpContext 能在所有引用它的 ExecutionContext 中被清除
                holder.Context = null;
            }

            if (value != null)
            {
                // Use an object indirection to hold the HttpContext in the AsyncLocal,
                // so it can be cleared in all ExecutionContexts when its cleared.
                // 這邊直接修改了 AsyncLocal 的值，所以會導致 ExecutionContext 的 COW。新的 HttpContext 不會被傳遞到原先的 ExecutionContext 中。
                _httpContextCurrent.Value = new HttpContextHolder { Context = value };
            }
        }
    }

    private sealed class HttpContextHolder
    {
        public HttpContext? Context;
    }
}

但 HttpContextAccessor 的實現并不允許將新賦值的非 null 的 HttpContext 傳遞到外層的 ExecutionContext 中，可以參考上面的源碼及注釋理解。

class Program
{
    private static IHttpContextAccessor _httpContextAccessor = new HttpContextAccessor();
    
    static async Task Main(string[] args)
    {
        var httpContext = new DefaultHttpContext
        {
            Items = new Dictionary<object, object>
            {
                { "Name", "A"}
            }
        };
        _httpContextAccessor.HttpContext = httpContext;
        Console.WriteLine($"HttpContext before await FooAsync in Main: {_httpContextAccessor.HttpContext.Items["Name"]}");
        await FooAsync();
        // HttpContext 被清空了，下面這行輸出 null
        Console.WriteLine($"HttpContext after await FooAsync in Main: {_httpContextAccessor.HttpContext?.Items["Name"]}");
    }

    private static async Task FooAsync()
    {
        _httpContextAccessor.HttpContext = new DefaultHttpContext
        {
            Items = new Dictionary<object, object>
            {
                { "Name", "B"}
            }
        };
        Console.WriteLine($"HttpContext before await in FooAsync: {_httpContextAccessor.HttpContext.Items["Name"]}");
        await Task.Delay(1000);
        Console.WriteLine($"HttpContext after await in FooAsync: {_httpContextAccessor.HttpContext.Items["Name"]}");
    }
}

輸出結果：

HttpContext before await FooAsync in Main: A

HttpContext before await in FooAsync: B

HttpContext after await in FooAsync: B

HttpContext after await FooAsync in Main:

轉自博客園https://www.cnblogs.com/eventhorizon/p/17170301.html

該文章在 2024/2/27 9:31:43 編輯過

關鍵字查詢

net

正在查詢...

點晴ERP是一款針對中小制造業的專業生產管理軟件系統,系統成熟度和易用性得到了國內大量中小企業的青睞。

點晴PMS碼頭管理系統主要針對港口碼頭集裝箱與散貨日常運作、調度、堆場、車隊、財務費用、相關報表等業務管理，結合碼頭的業務特點，圍繞調度、堆場作業而開發的。集技術的先進性、管理的有效性于一體，是物流碼頭及其他港口類企業的高效ERP管理信息系統。

點晴WMS倉儲管理系統提供了貨物產品管理,銷售管理,采購管理,倉儲管理,倉庫管理,保質期管理,貨位管理,庫位管理,生產管理,WMS管理系統,標簽打印,條形碼,二維碼管理,批號管理軟件。

點晴免費OA是一款軟件和通用服務都免費，不限功能、不限時間、不限用戶的免費OA協同辦公管理系統。