Task.Run() 中的异步/等待操作

Question

Task.Run(()=>{}) 将操作委托放入队列并返回任务。 在Task.Run() 中使用 async/await 有什么好处吗？ 我知道Task.Run()是必需的，因为如果我们想直接使用await，那么调用方法将需要异步并且会影响调用位置。

这是在Task.Run() 中具有异步等待的示例代码。此处提供完整示例：Create pre-computed tasks。

Task.Run(async () => { await new WebClient().DownloadStringTaskAsync("");});

也可以这样做：

Task.Run(() => new WebClient().DownloadStringTaskAsync("").Result;);

由于Task.Run() 和 Await 都会将工作排队并由线程池选择，Task.Run() 中的 async/await 会不会有点多余？

Answer 1

在 Task.Run() 中使用 async/await 有什么好处吗？

是的。 Task.Run 在线程池线程上运行一些操作。如果这个动作做了一些 IO 工作，并通过await 异步等待 IO 操作完成，那么这个线程池线程可以在 IO 操作仍在运行时被系统用于其他工作。

例子：

Task.Run( async () =>
{
    DoSomeCPUIntensiveWork();

    // While asynchronously waiting for this to complete, 
    // the thread is given back to the thread-pool
    var io_result = await DoSomeIOOperation(); 

    DoSomeOtherCPUIntensiveWork(io_result);
});

Answer 2

在 Task.Run() 中使用 async/await 有什么好处

async 方法在第一个 await 被命中后立即返回给调用者（对未完成的任务进行操作）。因此，如果异步方法的第一次“连续”执行需要很长时间Task.Run 将改变行为：它将导致该方法立即返回并在线程池上执行第一次“连续”。

这在 UI 场景中很有用，因为这样您可以 100% 确保您没有阻塞 UI。示例：HttpWebRequestdoes DNS 同步解析，即使您使用其中一种异步方法（这基本上是库错误/设计错误）。这可以暂停 UI 线程。因此，您可以使用 Task.Run 来 100% 确保 UI 不会被阻塞超过几微秒。

回到最初的问题：为什么要在 Task.Run 主体中等待？出于同样的原因，您通常等待：解除阻塞线程。

Answer 3

从非异步方法调用异步

当我们尝试在非异步方法中调用异步方法时，我们会做一些类似的事情。特别是如果异步方法是已知数量。虽然我们更多地使用了 TaskFactory ... 符合一种模式，使其更易于调试，确保每个人都采用相同的方法（并且 - 如果 async-->sync 开始出现错误，我们会感到窒息）。

那么，你的例子

想象一下，在您的示例中，您有一个非异步函数。而且，在该函数中，您需要调用 await webClient.DoSomethingAsync()。您不能在非异步函数中调用 await —— 编译器不会让您这样做。

选项 1：僵尸感染

您的第一个选择是一路爬取备份调用堆栈，将沿途的每个 da*n 方法标记为异步，并在各处添加等待。到处。就像，无处不在。然后 - 由于所有这些方法现在都是异步的，因此您需要使引用它们的方法全部异步。

顺便说一句，这可能是许多 SO 爱好者要提倡的方法。因为，“阻塞线程是个坏主意。”

所以。是的。这种“让异步成为异步”的方法意味着你的小库例程可以获取一个 json 对象，并触及 80% 的代码。谁会打电话给 CTO 让他知道？

选项 2：与一个僵尸一起去

或者，你可以将你的 async 封装在像你这样的函数中......

return Task.Run(async () => {
     content = await new WebClient().DoSomethingAsync();
     cachedDownloads.TryAdd(address, content);
     return content;
});

Presto...僵尸感染已包含在单个代码段中。我将把它留给位机制来争论如何/为什么在 CPU 级别执行。我真的不在乎。我关心没有人必须向 CTO 解释为什么整个库现在应该是 100% 异步的（或类似的东西）。

Answer 4

在您链接的示例中，主线程被阻塞，直到异步操作完成。调用Wait() 会阻止它（顺便说一句，这通常是个坏主意）。

让我们看一下linked 示例中DownloadStringAsync 的返回值：

return Task.Run(async () =>
{
    content = await new WebClient().DownloadStringTaskAsync(address);
    cachedDownloads.TryAdd(address, content);
    return content;
});

为什么要将它包装在 Task 中？考虑一下您的选择。如果您不想将其包装在Task 中，您将如何确保该方法返回Task<string> 并且仍然可以工作？您当然会将方法标记为async！但是，如果您将方法标记为 async 并在其上调用 Wait，您很可能会陷入死锁，因为主线程正在等待工作完成，并且您阻塞了主线程，所以它不能让你知道它已经完成了。

将方法标记为async 时，状态机将在调用线程上运行，但是在您的示例中，状态机在单独的线程上运行，这意味着在主线程上几乎没有工作。

Answer 5

确认，用Task.Run 包裹await 使用2 个线程而不是1 个。

Task.Run(async () => { //thread #1
 await new WebClient().DownloadStringTaskAsync(""); //thread #2
});

假设你有四个这样包装的调用，它将使用 4 x 2 = 8 个线程。

最好用简单的await 来调用它们。例如：

Task<byte[]> t1 = new WebClient().DownloadStringTaskAsync("");
Task<byte[]> t2 = new WebClient().DownloadStringTaskAsync("");
byte[] t1Result = await t1;
byte[] t2Result = await t2;

这是包装 Task.Run 使用额外线程的证明。 （没有用WebClient来证明这一点）

private static async Task wrapped()
{
    List<Task> tasks = new List<Task>();
    tasks.AddRange(new []
    {
        Task.Run(async() => await new MyThread().RunMe()),
        Task.Run(async() => await new MyThread().RunMe()),
        Task.Run(async() => await new MyThread().RunMe()),
        Task.Run(async() => await new MyThread().RunMe()),
    });

    Thread.Sleep(1000);
    int number = Process.GetCurrentProcess().Threads.Count;
    Console.WriteLine($"While running thread count: {number}");

    await Task.WhenAll(tasks);
}

解开

private static async Task unwrapped()
{
    List<Task> tasks = new List<Task>();
    Task<int> t1 = new MyThread().RunMe();
    Task<int> t2 = new MyThread().RunMe();
    Task<int> t3 = new MyThread().RunMe();
    Task<int> t4 = new MyThread().RunMe();
    tasks.AddRange(new[] {t1, t2, t3, t4});

    Thread.Sleep(1000);
    int number = Process.GetCurrentProcess().Threads.Count;
    Console.WriteLine($"While running thread count: {number}");

    int i1 = await t1;
    int i2 = await t2;
    int i3 = await t3;
    int i4 = await t4;
}

这里有完整的 POC 代码

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;

namespace AsyncThreadDemo
{
    class Program
    {
        static async Task Main(string[] args)
        {
            int number = Process.GetCurrentProcess().Threads.Count;
            Console.WriteLine($"Init thread count: {number}");


            //await wrapped();
            await unwrapped();

            number = Process.GetCurrentProcess().Threads.Count;
            Console.WriteLine($"Done thread count: {number}");

            Console.ReadLine();
        }

        private static async Task wrapped()
        {
            List<Task> tasks = new List<Task>();
            tasks.AddRange(new []
            {
                Task.Run(async() => await new MyThread().RunMe()),
                Task.Run(async() => await new MyThread().RunMe()),
                Task.Run(async() => await new MyThread().RunMe()),
                Task.Run(async() => await new MyThread().RunMe()),
            });

            Thread.Sleep(1000);
            int number = Process.GetCurrentProcess().Threads.Count;
            Console.WriteLine($"While running thread count: {number}");

            await Task.WhenAll(tasks);
        }

        private static async Task unwrapped()
        {
            List<Task> tasks = new List<Task>();
            Task<int> t1 = new MyThread().RunMe();
            Task<int> t2 = new MyThread().RunMe();
            Task<int> t3 = new MyThread().RunMe();
            Task<int> t4 = new MyThread().RunMe();
            tasks.AddRange(new[] {t1, t2, t3, t4});

            Thread.Sleep(1000);
            int number = Process.GetCurrentProcess().Threads.Count;
            Console.WriteLine($"While running thread count: {number}");

            int i1 = await t1;
            int i2 = await t2;
            int i3 = await t3;
            int i4 = await t4;
        }
    }

    public class MyThread
    {
        public static int _counter;

        public async Task<int> RunMe()
        {
            await Task.Run(() =>
            {
                for (int i = 0; i < 2; ++i)
                {
                    Thread.Sleep(1000);
                    Console.WriteLine($"T{Thread.CurrentThread.ManagedThreadId} {i}");
                }
                Console.WriteLine($"T{Thread.CurrentThread.ManagedThreadId} done");
            });
            return _counter++;
        }
    }
}