异步等待和并行

Posted 2023-05-07

【中文标题】异步等待和并行

【英文标题】：Async await and parallel

【发布时间】：2016-05-09 15:50:12

【问题描述】：

我对 async/await 如何并行工作有点困惑，所以我在这里做了一个测试代码： 我尝试发送 6 个我用列表模拟的任务。 此任务中的每一个都将执行 3 个其他子任务。

您可以复制/粘贴进行测试

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

namespace ConsoleApplication1

    class Program
    
         static void Main(string[] args)
        
            //job simulation 
            Func<int, string, Tuple<int, string>> tc = Tuple.Create;
            var input = new List<Tuple<int, string>>
                  tc( 6000, "task 1" ),
                  tc( 5000, "task 2" ),
                  tc( 1000, "task 3" ),
                  tc( 1000, "task 4" ),
                  tc( 1000, "task 5" ),
                  tc( 1000, "task 6" )
            ;

            List<Tuple<int, string>> JobsList = new List<Tuple<int, string>>(input);

            //paralelism atempt
            List<Task> TaskLauncher = new List<Task>();

            Parallel.ForEach<Tuple<int, string>>(JobsList, item =>  JobDispatcher(item.Item1, item.Item2));

            Console.ReadLine();
        
        public static async Task JobDispatcher(int time , string query)
        
          List<Task> TList = new List<Task>();
          Task<string> T1 = SubTask1(time, query);
          Task<string> T2 = SubTask2(time, query);
          Task<string> T3 = SubTask3(time, query);
          TList.Add(T1);
          TList.Add(T2);
          TList.Add(T3);
          Console.WriteLine("0 Launched ", query);

          await Task.WhenAll(TList.ToArray());


          Console.WriteLine(T1.Result);
          Console.WriteLine(T2.Result);
          Console.WriteLine(T3.Result);

        


        public static async Task<string> SubTask1(int time, string query)
        
            //somework
            Thread.Sleep(time);
            return query + "Finshed SubTask1";
        
        public static async Task<string> SubTask2(int time, string query)
        
            //somework
            Thread.Sleep(time);
            return query + "Finshed SubTask2";
        
        public static async Task<string> SubTask3(int time, string query)
         
             //somework
             Thread.Sleep(time);
             return query + "Finshed SubTask3";
         


    

理想情况下，我应该在发布时阅读：

task 1 launched
task 2 launched
task 3 launched
task 4 launched
task 5 launched
task 6 launched

那么此时所有任务运行 6*3 = 18 个线程同时运行 但它不是这里发生的事情似乎执行同步。

结果如下：

用 async/await 编写可以将任务和子任务作为 18 个并行线程启动的东西的正确方法是什么？

【问题讨论】：

***.com/a/11565317/2613020

它不是同步运行的，任务4在任务3之前启动，但在任务3之后完成。

首先它应该在控制台中写入，因为我稍后会在函数中等待子任务

看看these articles。

@Zwan: async/await 是关于异步（并发没有线程）； Parallel 是关于并行性（使用 more 线程的并发性）。这些是完全不同的并发方法，很少需要both。或许如果您描述了您实际尝试做的事情，我们可以提出一个更合理的解决方案？

【参考方案1】：

试试这个示例代码。请注意，它在大约 6 秒内完成，这表明所有任务都是异步运行的：

using System;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication1

    class Program
    
        static void Main()
        
            // ThreadPool throttling may cause the speed with which
            // the threads are launched to be throttled.
            // You can avoid that by uncommenting the following line,
            // but that is considered bad form:

            // ThreadPool.SetMinThreads(20, 20);

            var sw = Stopwatch.StartNew();
            Console.WriteLine("Waiting for all tasks to complete");

            RunWorkers().Wait();

            Console.WriteLine("All tasks completed in " + sw.Elapsed);
        

        public static async Task RunWorkers()
        
            await Task.WhenAll(
                JobDispatcher(6000, "task 1"),
                JobDispatcher(5000, "task 2"),
                JobDispatcher(4000, "task 3"),
                JobDispatcher(3000, "task 4"),
                JobDispatcher(2000, "task 5"),
                JobDispatcher(1000, "task 6")
            );
        

        public static async Task JobDispatcher(int time, string query)
        
            var results = await Task.WhenAll(
                worker(time, query + ": Subtask 1"),
                worker(time, query + ": Subtask 2"),
                worker(time, query + ": Subtask 3")
            );

            Console.WriteLine(string.Join("\n", results));
        

        static async Task<string> worker(int time, string query)
        
            return await Task.Run(() =>
            
                Console.WriteLine("Starting worker " + query);
                Thread.Sleep(time);
                Console.WriteLine("Completed worker " + query);
                return query + ": " + time + ", thread id: " + Thread.CurrentThread.ManagedThreadId;
            );
        
    

在RunWorkers() 中，您将使用一组任务来代替：

public static async Task RunWorkers()

    Task[] tasks = new Task[6];

    for (int i = 0; i < 6; ++i)
        tasks[i] = JobDispatcher(1000 + i*1000, "task " + i);

    await Task.WhenAll(tasks);

【讨论】：

构建线程的有趣方式我也可以在静态异步任务 worker(int time, string query) methode中添加3个子任务吗？

它的反应完全符合我对parallele的期望还不知道为什么我的代码的某些部分在你运行顺利时看起来“阻塞”。稍后会调查。无论如何谢谢会在生产代码中尝试这个

感谢在第一篇文章中使用时间值，当我的 12 秒证明某些东西一开始没有并行运行时，您的代码是 6 秒...

@Servy 我删除了具有Task.Run() 的版本，但我相信它仍然需要worker() 中的Task.Run()。 （它之前有await Task.Delay()，但为了让它更像OP的代码，我用Thread.Sleep()替换了它，这意味着它现在需要在任务中运行。）

我来自未来，我通过 WPF 尝试了代码（将“控制台”与“调试”交换）。我注意到“所有任务在...中完成”没有出现。解决方案：使用await RunWorkers (); 代替RunWorkers().Wait(); 并将'async' 添加到Main 方法。