Question

.net核心BackgroundService或IHostedService的启动方法是异步的：

//IHostedService
Task StartAsync(CancellationToken cancellationToken);
//BackgroundService
Task ExecuteAsync(CancellationToken stoppingToken);

那么我应该在ExecuteAsync / StartAsync方法中编写所有逻辑，还是应该仅启动一个新线程并立即返回？

例如，以下两个是正确的实现？

1。

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    new Thread(async () => await DoWork(stoppingToken)).Start();

    await Task.CompletedTask;
}

private async Task DoWork(CancellationToken stoppingToken) 
{
    while (!stoppingToken.IsCancellationRequested)
        //actual works
}

2。

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    while (!stoppingToken.IsCancellationRequested)
    {
        //actual works
        await Task.Delay(1000);//e.g
    }
}

我认为第二种似乎正确，但是如果有多个IHostedService，它们可以与第二种形式并行运行吗？

编辑1

我还编写了一个示例程序，说明托管服务本身并不是作为单独的线程运行的。

在我键入"Waiting for signal.."之前，不会将消息q写入控制台：

using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Threading;
using System.Threading.Tasks;

namespace BackgroundTaskTest
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            var host = new HostBuilder()
                .ConfigureServices((hostContext, services) =>
                {
                    IConfiguration config = hostContext.Configuration;

                    //register tasks
                    services.AddHostedService<ReadService>();
                    services.AddHostedService<BlockService>();
                })
                .UseConsoleLifetime()
                .Build();

            await host.RunAsync();
        }
    }

    public static class WaitClass
    {
        public static AutoResetEvent Event = new AutoResetEvent(false);
    }

    public class ReadService : BackgroundService
    {
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                var c = Console.ReadKey();
                if (c.KeyChar == 'q')
                {
                    Console.WriteLine("\nTrigger event");
                    WaitClass.Event.Set();
                }
                await Task.Delay(1);
            }
        }
    }

    public class BlockService : BackgroundService
    {
        protected override Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                Console.WriteLine("Waiting for signal..");
                WaitClass.Event.WaitOne();
                Console.WriteLine("Signal waited");
            }
            return Task.CompletedTask;
        }
    }
}

Answer 1

对于StartAsync()，至少，您应该启动一个单独的线程。如果您的工作需要很长时间才能完成。否则——至少根据我的经验，在 Windows 10 上使用 .NET Core 2.1——在所有工作完成之前，IHostedService 不会注册为“已启动”。

我有一个测试控制台应用程序，它对相同的 URL 进行 360 次 HTTP-GET，每次之间等待 10 秒，并计算它成功的次数和失败的次数。在此应用程序中，我已使用 ILogger 配置 NLog 日志记录，同时转到文本文件和控制台。最高级别的日志记录详细程度。

托管应用程序完成启动后，我看到一条消息记录到控制台（和文件），告诉我托管应用程序已启动，我可以按 Ctrl+C 退出。

如果在 StartAsync() 中，我只是 await 完成所有工作的测试方法，那么在一个多小时后所有工作完成之前，我不会看到记录该消息. 如果相反，我像在您的第一个示例中那样启动一个新线程，那么我应该几乎立即看到 Ctrl+C 指令。

因此，根据经验，您的第一个示例似乎是正确的。

Answer 2

只需使用async / await来实现它，如第二个示例所示。不需要多余的Thread。

旁注：Thread仅应用于COM互操作；对于Thread的其他所有旧用例，如今有更好的解决方案。键入new Thread后，您已经有了旧代码。

Answer 3

无需启动线程。 ExecuteAsync（）是异步。任何 async 都在单独的线程中运行。一个例外是 async 函数中在 await 之前仅运行一次的某些部分可以在调用线程中运行，但是在 await之后的任何部分在单独的线程中运行。

这意味着包含 await 的循环中的所有代码都在单独的线程中运行。即使循环中的某些代码出现在 await 之前，但仍会在下一个循环迭代中的await之后“运行”，因此它们都必须是单独线程的一部分。

总结，它已经在一个单独的线程中，编译器会为您处理。只是信任编译器，这是一个很难养成的习惯，围绕 await 循环的所有内容都在单独的线程中。

.net核心`IHostedService`应该启动一个新线程

3 个答案: