Правильного пути к синхронизировать параллельные задачи

Question

В настоящее время у нас есть этот код, который работает отлично:

Result result1 = null; 
Result result2 = null; 

var task1 = Task.Factory.StartNew(()=> 
{ 
    var records = DB.Read(".."); 
    //Do A lot 
    result1 = Process(records); 
}); 

var task2 = Task.Factory.StartNew(()=> 
{ 
    var records = DB.Read("....."); 
    //Do A lot 
    result2 = Process(records); 
}); 

Task.WaitAll(task1, task2); 

var result = Combine(result1, result2); 

Теперь мы хотели бы использовать асинхронные аналоги DB функций, и мы используем эту новую модель:

Result result1 = null; 
Result result2 = null; 

var task1 = await Task.Factory.StartNew(async()=> 
{ 
    var records = await DB.ReadAsync(".."); 
    //Do A lot 
    result1 = Process(records); 
}); 

var task2 = await Task.Factory.StartNew(async()=> 
{ 
    var records = await DB.ReadAsync("....."); 
    //Do A lot 
    result2 = Process(records); 
}); 

Task.WaitAll(task1, task2); 

var result = Combine(result1, result2); 

После того, как мы перешли на асинхронный режим, мы начали наблюдать аномальное поведение. Поэтому я задаюсь вопросом, является ли это правильным шаблоном для распараллеливания асинхронных вызовов?

Answer 1

Task.Factory.StartNew является асинхронным API. Вы должны использовать Task.Run, которая была разработана с асинхронным-ждать в виду:

var task1 = await Task.Run(async()=> 
{ 
    var records = await DB.ReadAsync(".."); 
    //Do A lot 
    result1 = Process(records); 
}); 

Этот вопрос о том, что асинхронная лямбда возвращает Task так Task.Factory.StartNew возвращает Task<Task> (внешний один, потому что Task.Factory.StartNew возвращает Task и внутренний один который является результатом асинхронной лямбда).

Это означает, что, когда вы ждете на task1 и task2, вы не очень ожидаете всей операции, только синхронной ее части.

Вы можете исправить это с помощью Task.Unwrap на возвращаемом Task<Task>:

Task<Task> task1 = await Task.Factory.StartNew(async()=> 
{ 
    var records = await DB.ReadAsync(".."); 
    //Do A lot 
    result1 = Process(records); 
}); 

Task actualTask1 = task1.Unwrap(); 
await actualTask1; 

Task.Run Но делает это неявно для вас.

---

В качестве примечания, вы должны понимать, что вам не нужно Task.Run выполнять эти операции одновременно. Вы можете сделать это только с помощью вызова этих методов и ожидают результаты вместе с Task.When:

async Task MainAsync() 
{ 
    var task1 = FooAsync(); 
    var task2 = BarAsync(); 
    await Task.WhenAll(task1, task2); 

    var result = Combine(task1.Result, task2.Result); 
} 

async Task<Result> FooAsync() 
{ 
    var records = await DB.ReadAsync(".."); 
    //Do A lot 
    return Process(records); 
} 

async Task<Result> BarAsync() 
{ 
    var records = await DB.ReadAsync("....."); 
    //Do A lot 
    return Process(records); 
} 

Вам нужно только Task.Run, если вам нужно, чтобы разгрузить даже синхронные части этих методов (часть перед первым await) к ThreadPool.

Answer 2

Task.Factory.StartNew начало новой задачи исполнения другое независимое исполнительный блок. Таким образом, самый простой способ справиться с этим может выглядеть следующим образом:

var task1 = Task.Factory.StartNew(()=> //NO AWAIT 
{ 
    var records = DB.Read("....."); //NO ASYNC 
    //Do A lot 
    result1 = Process(records); 
}); 

... another task definition 

Task.WaitAll(task1, task2); 

Рид и процесс последовательно в одной задаче, так как у вас есть зависимость данных.

Answer 3

Ну, используя .WaitAll не является асинхронным программированием, потому что вы фактически блокируете текущий поток при ожидании. Также вы не вызываете .Unwrap, и поэтому вы просто ждете только от создания асинхронной лямбды, а не от самой асинхронной лямбда.

Task.Run может развернуть асинхронную лямбду для вас. Но есть более простой и понятный способ.

var task1 = DB.ReadAsync("..").ContinueWith(task => { 
    //Do A lot 
    return Process(task.Result); 
}, TaskScheduler.Default); 

var task2 = DB.ReadAsync("..").ContinueWith(task => { 
    //Do A lot 
    return Process(task.Result); 
}, TaskScheduler.Default); 

var result = Combine(await task1, await task2); 

Таким образом, вы получите результат именно тогда, когда он будет готов. Таким образом, вам не нужны дополнительные задачи и переменные.

Обратите внимание: ContinueWith является сложной функцией, и она работает на TaskScheduler.Current, если она не является нулевой, и в противном случае она работает на TaskScheduler.Default, который является планировщиком пула потоков. Поэтому безопаснее всегда указывать планировщик при вызове этой функции.

Также для claryfing я не включал проверку ошибок, потому что на самом деле DB.ReadAsync может быть завершен с ошибкой. Но это легко, и вы можете справиться с этим сами.