c# - 从并发异步任务访问共享资源安全吗？ (C#)

Question

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

我尝试运行以下两个示例，两者似乎都暗示它是多线程的(交错的消息/日期)。 http://rextester.com/AEH56431 http://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

imply that it is multi-threaded (interleaved messages/dates)

那些意味着它是并发的。而且，事实上，使用 Task.WhenAll 的这一行就是您进行异步并发的方式:

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

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

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