Quando utilizzare Task.Delay, quando utilizzare Thread.Sleep?

Ci sono buone regole per quando usare Task.Delay contro Thread.Sleep ?

• In particolare, esiste un valore minimo per garantire che uno sia efficace / efficiente rispetto all'altro?
• Infine, poiché Task.Delay provoca il cambio di contesto su una macchina a stati asincroni / wait, c'è un sovraccarico nell'usarlo?

Utilizzare Thread.Sleepquando si desidera bloccare il thread corrente.

Utilizzare Task.Delayquando si desidera un ritardo logico senza bloccare il thread corrente.

L'efficienza non dovrebbe essere una preoccupazione fondamentale per questi metodi. Il loro principale utilizzo nel mondo reale è come i tentativi di ripetizione delle operazioni di I / O, che sono nell'ordine dei secondi anziché dei millisecondi.

La differenza più grande tra Task.Delaye Thread.Sleepè che Task.Delaysi intende eseguire in modo asincrono. Non ha senso utilizzare Task.Delaynel codice sincrono. È un'idea MOLTO negativa da utilizzare Thread.Sleepnel codice asincrono.

Normalmente chiamerai Task.Delay() con la awaitparola chiave:

await Task.Delay(5000);

oppure, se si desidera eseguire un codice prima del ritardo:

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

Indovina cosa verrà stampato? In esecuzione per 0,0070048 secondi. Se invece spostiamo quanto await delaysopra Console.WriteLine, verrà stampato In esecuzione per 5.0020168 secondi.

Diamo un'occhiata alla differenza con 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");
    }
}

Prova a prevedere cosa verrà stampato ...

asincrono: avvio
asincrono: in esecuzione per 0,0070048 secondi
sincronizzazione: avvio
asincrono: in esecuzione per 5,0119008 secondi
asincrono:
sincronizzazione completata: in esecuzione per
sincronizzazione 5,000068 secondi : Fine

Inoltre, è interessante notare che Thread.Sleepè molto più preciso, l'accuratezza ms non è davvero un problema, mentre Task.Delaypuò richiedere un minimo di 15-30ms. Il sovraccarico su entrambe le funzioni è minimo rispetto alla precisione in ms che hanno (usa StopwatchClass se hai bisogno di qualcosa di più accurato). Thread.Sleeplega ancora il tuo thread, Task.Delayrilascialo per fare altri lavori mentre aspetti.

se il thread corrente viene ucciso e tu usi Thread.Sleeped è in esecuzione, potresti ottenere un ThreadAbortException. Con Task.Delayte puoi sempre fornire un token di annullamento e ucciderlo con garbo. Questo è uno dei motivi per cui sceglierei Task.Delay. vedi http://social.technet.microsoft.com/wiki/contents/articles/21177.visual-c-thread-sleep-vs-task-delay.aspx

Concordo anche che l'efficienza non è fondamentale in questo caso.

Voglio aggiungere qualcosa In realtà, Task.Delayè un meccanismo di attesa basato sul timer. Se guardi la fonte troverai un riferimento a una Timerclasse che è responsabile del ritardo. D'altra parte, in Thread.Sleeprealtà fa dormire il thread corrente, in questo modo stai solo bloccando e sprecando un thread. Nel modello di programmazione asincrona si dovrebbe sempre usare Task.Delay()se si desidera che qualcosa (continuazione) accada dopo un certo ritardo.