Kiedy używać Task.Delay, kiedy używać Thread.Sleep?

Czy istnieją dobre reguły, kiedy należy używać Task.Delay kontra Thread.Sleep ?

• W szczególności, czy istnieje minimalna wartość zapewniająca, aby jedna była skuteczna / wydajna w stosunku do drugiej?
• Wreszcie, skoro Task.Delay powoduje przełączanie kontekstu na maszynie stanu asynchronicznie / oczekuj, czy jest narzut związany z jego używaniem?

Użyj, Thread.Sleepgdy chcesz zablokować bieżący wątek.

Użyj, Task.Delaygdy chcesz logicznego opóźnienia bez blokowania bieżącego wątku.

Efektywność nie powinna być najważniejszym problemem tych metod. Ich głównym zastosowaniem w świecie rzeczywistym są liczniki czasu ponawiania operacji we / wy, które są rzędu sekund, a nie milisekund.

Największa różnica między Task.Delayi Thread.Sleeppolega na tym, że Task.Delayma on działać asynchronicznie. Nie ma sensu używać Task.Delayw kodzie synchronicznym. Używanie Thread.Sleepw kodzie asynchronicznym jest BARDZO złym pomysłem .

Zwykle zadzwonisz Task.Delay() ze awaitsłowem kluczowym:

await Task.Delay(5000);

lub, jeśli chcesz uruchomić jakiś kod przed opóźnieniem:

var sw = new Stopwatch();
sw.Start();
Task delay = Task.Delay(5000);
Console.WriteLine("async: Running for {0} seconds", sw.Elapsed.TotalSeconds);
await delay;

Zgadnij, co to wydrukuje? Działa przez 0,0070048 sekund. Jeśli zamiast tego przeniesiemy await delaypowyższe Console.WriteLine, zostanie wydrukowany Uruchomiony przez 5.0020168 sekund.

Spójrzmy na różnicę w Thread.Sleep:

class Program
{
    static void Main(string[] args)
    {
        Task delay = asyncTask();
        syncCode();
        delay.Wait();
        Console.ReadLine();
    }

    static async Task asyncTask()
    {
        var sw = new Stopwatch();
        sw.Start();
        Console.WriteLine("async: Starting");
        Task delay = Task.Delay(5000);
        Console.WriteLine("async: Running for {0} seconds", sw.Elapsed.TotalSeconds);
        await delay;
        Console.WriteLine("async: Running for {0} seconds", sw.Elapsed.TotalSeconds);
        Console.WriteLine("async: Done");
    }

    static void syncCode()
    {
        var sw = new Stopwatch();
        sw.Start();
        Console.WriteLine("sync: Starting");
        Thread.Sleep(5000);
        Console.WriteLine("sync: Running for {0} seconds", sw.Elapsed.TotalSeconds);
        Console.WriteLine("sync: Done");
    }
}

Spróbuj przewidzieć, co to wydrukuje ...

async: Uruchamianie
asynchronizacji: Uruchamianie przez 0,0070048 sekund
Synchronizacja: Uruchamianie
asynchronizacji: Uruchamianie 5,0119008 sekund Asynchronizacja
: Gotowe
Synchronizacja: Uruchamianie 5.0020168 sekund
Synchronizacja: Gotowe

Warto również zauważyć, że Thread.Sleepjest o wiele dokładniejszy, dokładność ms nie jest tak naprawdę problemem, a Task.Delaymoże zająć minimum 15-30 ms. Narzut na obie funkcje jest minimalny w porównaniu z dokładnością ms, jaką mają (użyj Stopwatchklasy, jeśli potrzebujesz czegoś dokładniejszego). Thread.Sleepnadal wiąże Wątek, Task.Delayzwolnij go, aby mógł wykonać inną pracę podczas oczekiwania.

jeśli bieżący wątek zostanie zabity, a ty użyjesz Thread.Sleepgo i się wykonuje, możesz otrzymać ThreadAbortException. Dzięki Task.Delayzawsze możesz podać token anulowania i z gracją go zabić. To jeden z powodów, dla których wybrałbym Task.Delay. patrz http://social.technet.microsoft.com/wiki/contents/articles/21177.visual-c-thread-sleep-vs-task-delay.aspx

Zgadzam się również, że w tym przypadku wydajność nie jest najważniejsza.

Chcę coś dodać. W rzeczywistości Task.Delayjest mechanizm oczekiwania oparty na zegarze. Jeśli spojrzysz na źródło , znajdziesz odniesienie do Timerklasy odpowiedzialnej za opóźnienie. Z drugiej strony Thread.Sleepfaktycznie uśpia bieżący wątek, w ten sposób blokujesz i marnujesz jeden wątek. W modelu programowania asynchronicznego powinieneś zawsze używać, Task.Delay()jeśli chcesz, aby coś (kontynuacja) wydarzyło się z pewnym opóźnieniem.