c# - 为什么在同一 (UI) 线程中顺序调用 AsyncLock 的方式与不同线程的方式不同(例如通过 Task.Run)？

Question

部分地，这个问题与this one有点相似。 , 但由于另一个问题没有被正确地问到(并且没有被完全问到)，我试图笼统地问它，所以这个问题不能被认为是重复的。

问题是关于理解AsyncLock 实际如何工作。 (在这种情况下，我指的是 Neosmart.AsyncLock 库，但是，我认为它在 AsyncLock 实现中使用了通用方法)。

所以。例如，我们有一个主线程(让它成为一个 UI 线程):

    static void Main(string[] args)
    {
        Console.WriteLine("Press Esc for exit");

        var lck = new AsyncLock();

        var doJob = new Action(async () =>
        {
            using (await lck.LockAsync())
            {
                // long lasting job
                Console.WriteLine("+++ Job starts");
                await Task.Delay(TimeSpan.FromSeconds(10));
                Console.WriteLine("--- Job finished");
            }
        });

        while (Console.ReadKey().Key != ConsoleKey.Escape)
        {
            doJob();
        }
    }

因此，连续按 Enter 每次都会启动 doJob，而无需等到上一个作业完成。

但是，当我们将其更改为:

    Task.Run(() =>
    {
        doJob();
    });

...一切都像魅力一样，在之前完成之前不会运行新作业。

很明显，异步逻辑与经典的 lock(_myLock) 大不相同，无法直接比较，但是，为什么第一种方法不能那样工作 当 LockAsync 的第二次调用将“锁定”(再次，在异步上下文中)“持久作业”开始直到上一个完成。

---

实际上有一个实际的要求，为什么我需要代码以这种方式工作，(真正的问题是我如何使用 await LockAsync 实现它？):

例如，在我的应用程序(例如，我的移动应用程序)中，在启动时有一些数据我正在开始预加载(这是一项需要保留数据的常见服务在缓存中以供进一步使用)，然后，当启动 UI 时，特定页面请求相同的数据 以显示 UI，并请求相同的服务加载相同的数据。因此，在没有任何自定义逻辑的情况下，服务将启动两个持久作业以检索相同的数据包。 相反，我希望我的 UI 在数据预加载完成后立即从缓存中接收数据。 像那样(一个抽象的可能场景):

    class MyApp
    {
        string[] _cache = null;
        AsyncLock _lock = new AsyncLock();

        async Task<IEnumerable<string>> LoadData()
        {
            using (await _lock.LockAsync())
            {
                if (_cache == null)
                {
                    await Task.Delay(TimeSpan.FromSeconds(10));
                    _cache = new[] {"one", "two", "three"};
                }
                return _cache;
            }
        }

        void OnAppLaunch()
        {
            LoadData();
        }

        async void OnMyCustomEvent()
        {
            var data = await LoadData();
            // to do something else with the data
        }
    }

如果我将其更改为 Task.Run(async () => { var data = await LoadData(); }) 问题将得到解决，但它看起来不太干净和好的方法。

Answer 1

正如 Matthew 在评论中指出的那样，AsyncLock 是可重入的，这意味着如果同一个线程再次尝试获取锁，它会识别并允许它继续。 AsyncLock 的作者写了一篇很长的文章来说明重入是他写它的真正原因:AsyncLock: an async/await-friendly locking library for C# and .NET

这不是错误；这是一项功能。™

在“2017 年 5 月 25 日更新”标题之后，有一些代码示例准确地演示了您在这里遇到的情况，并展示了它如何成为一项功能。

想要重新进入的原因是:

1. 如果您只关心多个线程接触同一个变量(防止竞争条件)，那么根本没有理由阻塞已经拥有锁的线程。
2. 它使使用锁的递归函数更易于编写，因为您无需测试是否已经拥有锁。缺乏重入支持 + 草率的递归编码 = 死锁。

如果你真的想让它不可重入，你可以用他说的不适合重入:SemaphoreSlim :

var lck = new SemaphoreSlim(1);

var doJob = new Action(async () => {

    await lck.WaitAsync();

    try {
        // long lasting job
        Console.WriteLine("+++ Job starts");
        await Task.Delay(TimeSpan.FromSeconds(2));
        Console.WriteLine("--- Job finished");
    } finally {
        lck.Release();
    }
});