Bekle vs Görev.Gerekti - Deadlock?

Oldukça arasındaki farkı anlayamıyorum Task.Waitve await.

Bir ASP.NET WebAPI hizmetinde aşağıdaki işlevlere benzer bir şey var:

public class TestController : ApiController
{
    public static async Task<string> Foo()
    {
        await Task.Delay(1).ConfigureAwait(false);
        return "";
    }

    public async static Task<string> Bar()
    {
        return await Foo();
    }

    public async static Task<string> Ros()
    {
        return await Bar();
    }

    // GET api/test
    public IEnumerable<string> Get()
    {
        Task.WaitAll(Enumerable.Range(0, 10).Select(x => Ros()).ToArray());

        return new string[] { "value1", "value2" }; // This will never execute
    }
}

Nerede Getçıkacak.

Buna ne sebep olabilir? Bir engelleme beklemesini kullanmak yerine neden bir soruna neden olmaz await Task.Delay?

Waitve await- kavramsal olarak benzer olsa da - aslında tamamen farklıdır.

Waitgörev tamamlanıncaya kadar eşzamanlı olarak engellenir. Böylece mevcut iş parçacığı, görevin tamamlanmasını beklerken tam anlamıyla engellenir. Genel bir kural olarak, " asyncsonuna kadar" kullanmalısınız; yani, asynckodu engellemeyin . Blogumda, eşzamansız kodda engellemenin kilitlenmeye nasıl neden olduğuna dair ayrıntılara giriyorum .

awaitgörev tamamlanıncaya kadar eşzamansız olarak bekleyecektir. Bu, geçerli yöntemin "duraklatıldığı" (durumu yakalandığı) ve yöntemin arayan kişiye tamamlanmamış bir görev döndürdüğü anlamına gelir . Daha sonra, awaitifade tamamlandığında, yöntemin geri kalanı bir devamı olarak programlanır.

Ayrıca Wait, üzerinde çalıştığınız bir görevin bekleyen iş parçacığında yürütülebileceğini düşündüğünüz bir "işbirliği bloğundan" bahsettiniz . Bunun olabileceği durumlar var, ancak bu bir optimizasyon. Orada birçok durumlardır edemez görev başka zamanlayıcı içinse gibi olur, ya da çoktan başladı eğer yoksa böyle bir kod örnekte olduğu gibi olmayan bir kod görevi (eğer: Waityürütemediğinden Delayhiçbir kod olmadığından görev inline onun için).

async/ awaitİntro'yu yararlı bulabilirsiniz .

Farklı kaynaklardan okuduğum bilgilere dayanarak:

Bir awaitifade, yürüttüğü iş parçacığını engellemez. Bunun yerine, derleyicinin asyncyöntemin geri kalanını beklenen görevde bir devamı olarak kaydetmesine neden olur . Kontrol daha sonra asyncyöntemin arayanına geri döner . Görev tamamlandığında, devam etmesini başlatır ve asyncyöntemin yürütülmesi kaldığı yerden devam eder.

Tek bir taskkişinin tamamlanmasını beklemek için Task.Waityöntemini çağırabilirsiniz . Bir çağrı Waittek bir sınıf örneği kadar yöntemi blok çağrı iplik yürütme tamamlamıştır. Parametresiz Wait()yöntem, bir görev tamamlanana kadar koşulsuz olarak beklemek için kullanılır. Görev, Thread.Sleepyöntemi iki saniye uyumaya çağırarak işi simüle eder .

Bu makale de iyi bir okuma.

Diğer cevaplarda bazı önemli olgular verilmedi:

"zaman uyumsuz beklemek" CIL düzeyinde daha karmaşıktır ve bu nedenle bellek ve CPU zamanına mal olur.

Bekleme süresi kabul edilemez olduğunda herhangi bir görev iptal edilebilir.

"Async bekliyor" durumunda, böyle bir görevin iptal edilmesi veya izlenmesi için bir işleyicimiz yoktur.

Görev'i kullanmak "async bekliyor" dan daha esnektir.

Herhangi bir senkronizasyon işlevi zaman uyumsuz olarak sarılabilir.

public async Task<ActionResult> DoAsync(long id) 
{ 
    return await Task.Run(() => { return DoSync(id); } ); 
} 

"async bekliyor" birçok sorun üretir. Biz şimdi beklemiyoruz ifadesi çalışma zamanı ve bağlam hata ayıklama olmadan ulaşılacaktır. İlk önce ulaşılamazsa her şey engellenir . Bazen bile beklendiği gibi ulaşılıyor gibi görünüyor hala her şey engellendi:

https://github.com/dotnet/runtime/issues/36063

Neden senkronizasyon ve zaman uyumsuzluk yöntemi veya kesmek kullanarak kod çoğaltma ile yaşamak zorunda görmüyorum.

Sonuç: Görevi elle oluşturun ve kontrol etmek çok daha iyidir. Görev işleyici daha fazla kontrol sağlar. Görevleri izleyebilir ve yönetebiliriz:

https://github.com/lsmolinski/MonitoredQueueBackgroundWorkItem

İngilizcem için üzgünüm.