Question

我正在使用Async等待Task.Factory方法。

public async Task<JobDto> ProcessJob(JobDto jobTask)
{
    try
    {
        var T = Task.Factory.StartNew(() =>
        {
            JobWorker jobWorker = new JobWorker();
            jobWorker.Execute(jobTask);
        });

        await T;
    }

这个方法我在这样的循环中调用

for(int i=0; i < jobList.Count(); i++)
{
    tasks[i] = ProcessJob(jobList[i]);
}

我注意到新任务在Process explorer中打开，它们也开始工作（基于日志文件）。然而，有时10个，有时8个或有时7个完成。其余的人再也没有回来。

为什么会这样？
他们超时吗？我在哪里可以为我的任务设置超时？

更新

基本上，我希望每个Task在调用后立即开始运行，并等待AWAIT T关键字的响应。我在这里假设，一旦完成，他们每个人都会回到Await T并做下一步行动。我在10个任务中有7个看到了这个结果，但其中3个没有回来。

由于

Answer 1

如果代码没有其他问题，很难说出问题是什么，但是您可以通过使ProcessJob同步并随后使用Task.Run来简化代码来简化代码。

public JobDto ProcessJob(JobDto jobTask)
{
    JobWorker jobWorker = new JobWorker();
    return jobWorker.Execute(jobTask);
}

启动任务并等待所有任务完成。更喜欢使用Task.Run而不是Task.Factory.StartNew，因为它提供了更有利的默认设置，可以将工作推送到后台。请参阅here。

for(int i=0; i < jobList.Count(); i++)
{
    tasks[i] = Task.Run(() => ProcessJob(jobList[i]));
}

try
{
   await Task.WhenAll(tasks);
}
catch(Exception ex)
{
   // handle exception
}

Answer 2

您的代码可能会吞噬异常。我会在启动新任务的代码部分的末尾添加ContineWith调用。像这个未经测试的代码：

var T = Task.Factory.StartNew(() =>
        {
            JobWorker jobWorker = new JobWorker();
            jobWorker.Execute(jobTask);
        }).ContinueWith(tsk =>
        {
            var flattenedException = tsk.Exception.Flatten();
            Console.Log("Exception! " + flattenedException);
            return true;
         });
        },TaskContinuationOptions.OnlyOnFaulted);  //Only call if task is faulted

另一种可能性是，其中一项任务中的某些内容超时（如您所述）或死锁。要跟踪超时（或可能是死锁）是否是根本原因，您可以添加一些超时逻辑（如this SO回答中所述）：

int timeout = 1000; //set to something much greater than the time it should take your task to complete (at least for testing)
var task = TheMethodWhichWrapsYourAsyncLogic(cancellationToken);
if (await Task.WhenAny(task, Task.Delay(timeout, cancellationToken)) == task)
{
    // Task completed within timeout.
    // Consider that the task may have faulted or been canceled.
    // We re-await the task so that any exceptions/cancellation is rethrown.
    await task;

}
else
{
    // timeout/cancellation logic
}

在MSDN上的TPL中查看有关异常处理的documentation。

Answer 3

首先，让我们制作一个可重现的代码版本。这不是实现您正在做的事情的最佳方式，而是向您展示代码中发生的事情！

我会保持代码与您的代码几乎相同，但我会使用简单的int而不是您的JobDto，并且在完成作业Execute()后我会写入我们以后可以验证的文件。这是代码

public class SomeMainClass
{
    public void StartProcessing()
    {
        var jobList = Enumerable.Range(1, 10).ToArray();
        var tasks = new Task[10];
        //[1] start 10 jobs, one-by-one
        for (int i = 0; i < jobList.Count(); i++)
        {
            tasks[i] = ProcessJob(jobList[i]);
        }
        //[4] here we have 10 awaitable Task in tasks
        //[5] do all other unrelated operations
        Thread.Sleep(1500); //assume it works for 1.5 sec
        // Task.WaitAll(tasks); //[6] wait for tasks to complete
        // The PROCESS IS COMPLETE here
    }

    public async Task ProcessJob(int jobTask)
    {
        try
        {
            //[2] start job in a ThreadPool, Background thread
            var T = Task.Factory.StartNew(() =>
            {
                JobWorker jobWorker = new JobWorker();
                jobWorker.Execute(jobTask);
            });
            //[3] await here will keep context of calling thread
            await T; //... and release the calling thread
        }
        catch (Exception) { /*handle*/ }
    }
}

public class JobWorker
{
    static object locker = new object();
    const string _file = @"C:\YourDirectory\out.txt";
    public void Execute(int jobTask) //on complete, writes in file
    {
        Thread.Sleep(500); //let's assume does something for 0.5 sec
        lock(locker)
        {
            File.AppendAllText(_file, 
                Environment.NewLine + "Writing the value-" + jobTask);
        }
    }
}

仅运行StartProcessing()后，这就是我在文件

中获得的内容

Writing the value-4
Writing the value-2
Writing the value-3
Writing the value-1
Writing the value-6
Writing the value-7
Writing the value-8
Writing the value-5

所以，8/10工作已经完成。显然，每次运行时，数字和顺序都可能会发生变化。但问题是，所有工作都没有完成！

现在，如果我取消评论步骤[6] Task.WaitAll(tasks);，这就是我在文件中的内容

Writing the value-2
Writing the value-3
Writing the value-4
Writing the value-1
Writing the value-5
Writing the value-7
Writing the value-8
Writing the value-6
Writing the value-9
Writing the value-10

所以，我的所有工作都在这里完成了！

为什么代码的行为类似于代码注释中已经解释过了。需要注意的主要事项是，您的任务在基于ThreadPool的{{1}}个线程中运行。因此，如果您不等待它们，它们将在MAIN进程结束并且主线程退出时被杀死。

如果您仍然不想等待那里的任务，您可以从第一个方法返回任务列表，并在流程的最后返回Background任务，如下所示

await

希望这能解决所有困惑。

Task.Factory.StartNew中的随机任务永远不会完成

3 个答案: