AsyncLocal用法簡介
通過 AsyncLocal 我們可以在一個邏輯上下文中維護一份私有數(shù)據(jù)，該上下文后續(xù)代碼中都可以訪問和修改這份數(shù)據(jù)，但另一個無關(guān)的上下文是無法訪問的。
無論是在新創(chuàng)建的 Task 中還是 await 關(guān)鍵詞之后，我們都能夠訪問前面設(shè)置的 AsyncLocal 的數(shù)據(jù)。
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}");
}
}
輸出結(jié)果：
AsyncLocal in task: Hello World!
AsyncLocal after await in FooAsync: Hello World!
AsyncLocal after await FooAsync: Hello World!
AsyncLocal實現(xiàn)原理
AsyncLocal 的實際數(shù)據(jù)存儲在 ExecutionContext 中，而 ExecutionContext 作為線程的私有字段與線程綁定，在線程會發(fā)生切換的地方，runtime 會將切換前的 ExecutionContext 保存起來，切換后再恢復(fù)到新線程上。
這個保存和恢復(fù)的過程是由 runtime 自動完成的，例如會發(fā)生在以下幾個地方：
- new Thread(ThreadStart start).Start()
- Task.Run(Action action)
- ThreadPool.QueueUserWorkItem(WaitCallback callBack)
- await 之后
以 await 為例，當我們在一個方法中使用了 await 關(guān)鍵詞，編譯器會將這個方法編譯成一個狀態(tài)機，這個狀態(tài)機會在 await 之前和之后分別保存和恢復(fù) 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);
}
}
輸出結(jié)果：
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}");
}
}
輸出結(jié)果：
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 被設(shè)計成了一個不可變的對象，當我們在 FooAsync 方法中修改了 AsyncLocal 的值，實際上是創(chuàng)建了一個新的 ExecutionContext，原來其他的 AsyncLocal 的值被值拷貝到了新的 ExecutionContext 中，新的 AsyncLocal 的值只會寫入到新的 ExecutionContext 中，而原來的 ExecutionContext 及其關(guān)聯(lián)的 AsyncLocal 仍然保持不變。
這樣的設(shè)計是為了保證線程的安全性，因為在多線程環(huán)境下，如果 ExecutionContext 是可變的，那么在切換線程的時候，可能會出現(xiàn)數(shù)據(jù)不一致的情況。
我們通常把這種設(shè)計稱為 Copy On Write（簡稱COW），即在修改數(shù)據(jù)的時候，會先拷貝一份數(shù)據(jù)，然后在拷貝的數(shù)據(jù)上進行修改，這樣就不會影響到原來的數(shù)據(jù)。
ExecutionContext 中可能不止一個 AsyncLocal 的數(shù)據(jù)，修改任意一個 AsyncLocal 都會導致 ExecutionContext 的 COW。
所以上面代碼的執(zhí)行過程如下：
AsyncLocal的避坑指南
那么我們?nèi)绾卧?FooAsync 方法中修改 AsyncLocal 的值，并且在 Main 方法中獲取到修改后的值呢？
我們需要借助一個中介者，讓中介者來保存 AsyncLocal 的值，然后在 FooAsync 方法中修改中介者的屬性值，這樣就可以在 Main 方法中獲取到修改后的值了。
下面我們設(shè)計一個 ValueHolder 來保存 AsyncLocal 的值，修改 Value 并不會修改 AsyncLocal 的值，而是修改 ValueHolder 的屬性值，這樣就不會觸發(fā) ExecutionContext 的 COW。
我們還需要設(shè)計一個 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}");
}
}
輸出結(jié)果：
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的實現(xiàn)原理
我們常用的?HttpContextAccessor?通過HttpContextHolder?來間接地在?AsyncLocal?中存儲?HttpContext。
如果要更新 HttpContext，只需要在 HttpContextHolder 中更新即可。因為 AsyncLocal 的值不會被修改，更新 HttpContext 時 ExecutionContext 也不會出現(xiàn) COW 的情況。
不過 HttpContextAccessor 中的邏輯有點特殊，它的 HttpContextHolder 是為保證清除 HttpContext 時，這個 HttpContext 能在所有引用它的 ExecutionContext 中被清除（可能因為修改 HttpContextHolder 之外的 AsyncLocal 數(shù)據(jù)導致 ExecutionContext 已經(jīng) COW 很多次了）。
下面是 HttpContextAccessor 的實現(xiàn)，英文注釋是原文，中文注釋是我自己的理解。
/// </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 的實現(xiàn)并不允許將新賦值的非 null 的 HttpContext 傳遞到外層的 ExecutionContext 中，可以參考上面的源碼及注釋理解。文章來源：http://www.zghlxwxcb.cn/news/detail-498035.html
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"]}");
}
}
輸出結(jié)果：文章來源地址http://www.zghlxwxcb.cn/news/detail-498035.html
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: 到了這里，關(guān)于.NET的AsyncLocal用法指南的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
