从并发异步任务访问共享资源安全吗？ （C＃）

Question

我需要并行运行多个异步方法并等待所有这些方法。 (Task.WhenAll) 然后在这些方法中，我需要访问一个共享资源，如 Dictionary()。我需要它是线程安全的吗？

我尝试运行以下两个示例，两者似乎都暗示它是多线程的（交错的消息/日期）。 http://rextester.com/AEH56431http://rextester.com/YEB50034

这张图有问题吗？任何人都可以确认/否认？ 也没有看到 C# 并发大师 Stephen Cleary 专门谈论这个案例。 编辑：实际上 Stephen 在他的 async intro blog 中谈到了线程模型，这可以提供帮助。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;

namespace Rextester
{
    public class Program
    {
        static public async Task run2() 
        {
            Console.WriteLine("START");

            await Task.WhenAll(steps(1),steps(2),steps(3),steps(4));

            Console.WriteLine("STOP");
        }


        static public async Task steps(int i) {
            await Task.Delay(100*i);
            Console.WriteLine("step"+i+".1");
            Thread.Sleep((5-i)*300);
            Console.WriteLine("step"+i+".2");
            Thread.Sleep((5-i)*300);
            Console.WriteLine("step"+i+".3");
            Thread.Sleep((5-i)*300);
            Console.WriteLine("step"+i+".4");
        }

       public static void Main(string[] args)
        {
           run2().Wait();
        }

    }
}

结果是：

START
step1.1
step2.1
step3.1
step4.1
step4.2
step3.2
step4.3   <-- multithreading? (2 isn't done)
step2.2
step1.2
step4.4
step3.3   <-- multithreading?
step2.3
step3.4
step1.3   <-- multithreading?
step2.4
step1.4
STOP

然后是另一个变体：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Text;

namespace Rextester
{
    public class Program
    {
        static public async Task run() 
        {
            Console.WriteLine("START");

            await Task.WhenAll(steps(1),steps(2),steps(3),steps(4));

            Console.WriteLine("\nSTOP");
        }

        static public async Task steps(int i) {
            var a = new StringBuilder();

            await Task.Delay(100*i); // This is to force to run in Async mode.

            // following is a block of code with (hopefully) no "async waits". Just CPU-bound (Thread.Sleep should be blocking the thread I think?)

            a.Append("\nSTART ["+Thread.CurrentThread.ManagedThreadId+"]");
            a.Append("\nstep "+i+".1 >"+DateTime.Now.ToString("mm:ss.fff"));
            Thread.Sleep((5-i)*400);
            a.Append("\nstep "+i+".2 >"+DateTime.Now.ToString("mm:ss.fff"));
            Thread.Sleep((5-i)*400);
            a.Append("\nstep "+i+".3 >"+DateTime.Now.ToString("mm:ss.fff"));
            Thread.Sleep((5-i)*400);
            a.Append("\nstep "+i+".4 >"+DateTime.Now.ToString("mm:ss.fff"));
            a.Append("\nSTOP");

            Console.WriteLine(a.ToString());
        }

       public static void Main(string[] args)
        {
           run().Wait();
        }

    }
}

输出如下：

START

START [9]
step 4.1 >57:08.485
step 4.2 >57:08.891
step 4.3 >57:09.298
step 4.4 >57:09.704
STOP

START [8]
step 3.1 >57:08.391
step 3.2 >57:09.204
step 3.3 >57:10.017
step 3.4 >57:10.830
STOP

START [7]
step 2.1 >57:08.297
step 2.2 >57:09.501
step 2.3 >57:10.705
step 2.4 >57:11.908
STOP

START [6]
step 1.1 >57:08.203
step 1.2 >57:09.814
step 1.3 >57:11.424
step 1.4 >57:13.034
STOP

STOP

Answer 1

暗示它是多线程的（交错的消息/日期）

那些暗示它是并发。而且，事实上，使用Task.WhenAll 的这行代码就是你做异步并发的方式：

await Task.WhenAll(steps(1),steps(2),steps(3),steps(4))

请注意，每个单独的步骤总是连续。因此，steps 的每次执行都将“线性”进行，即使它是异步的。这意味着1.1 将始终在1.2 之前，在1.3 之前等。所以所有1.x 将按顺序排列，2.x 将按顺序排列，等等。但是，有多个并发执行steps，它们可以交错。

还要注意，无论是否存在多线程，这都是正确的。在这种情况下（控制台应用程序），没有SynchronizationContext 或TaskScheduler，因此每个await 都在线程池线程上恢复。如果在单线程场景（例如 UI 线程）上运行相同的代码，您会在同一个线程上看到相同的顺序和交错行为。

Answer 2

这些“步骤”能够并行运行。异步函数在遇到未完成的可等待对象的第一个等待时返回。这里是await Task.Delay(100*i);。 Delay 的延续将在线程池上运行。出于这个原因，延迟会将其余代码移动到线程池中。

如果没有Delay，所有这些都将是连续的（包括其他睡眠）。

真的，这段代码的工作方式有点巧合。如果您使所有阻塞异步，它会同时运行就更清楚了。或者，您可以插入Task.Run 调用以强制并发行为，并记录它是有意的。

另外请注意，异步 IO（包括Task.Delay）在运行时不会消耗工作线程。它根本不消耗线程。

也许您可以删除Delay 调用并单步执行代码。这很容易做到，因为现在一切都在主线程上执行。