Quand utiliser Task.Delay, quand utiliser Thread.Sleep?

Existe-t-il de bonnes règles pour savoir quand utiliser Task.Delay contre Thread.Sleep ?

• Plus précisément, existe-t-il une valeur minimale à prévoir pour que l'un soit efficace / efficient par rapport à l'autre?
• Enfin, étant donné que Task.Delay provoque un changement de contexte sur une machine d'état asynchrone / attente, y a-t-il un surcoût lié à son utilisation?

À utiliser Thread.Sleeplorsque vous souhaitez bloquer le thread actuel.

À utiliser Task.Delaylorsque vous souhaitez un délai logique sans bloquer le thread actuel.

L'efficacité ne doit pas être une préoccupation primordiale avec ces méthodes. Leur utilisation principale dans le monde réel est la temporisation des nouvelles tentatives pour les opérations d'E / S, qui sont de l'ordre des secondes plutôt que des millisecondes.

La plus grande différence entre Task.Delayet Thread.Sleepest qu'il Task.Delayest destiné à s'exécuter de manière asynchrone. Cela n'a aucun sens d'utiliser Task.Delaydu code synchrone. C'est une TRÈS mauvaise idée à utiliser Thread.Sleepen code asynchrone.

Normalement, vous appelez Task.Delay() avec le awaitmot - clé:

await Task.Delay(5000);

ou, si vous souhaitez exécuter du code avant le délai:

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

Devinez ce que cela va imprimer? Fonctionne pendant 0,0070048 secondes. Si nous déplaçons ce qui await delayprécède à la Console.WriteLineplace, il imprimera Running pendant 5.0020168 secondes.

Regardons la différence avec 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");
    }
}

Essayez de prédire ce que cela va imprimer ...

async: Démarrage
async: Fonctionnement pendant 0.0070048 secondes de
synchronisation: Démarrage
async: Fonctionnement pendant 5.0119008 secondes
async: Terminé
sync: Fonctionnement pendant 5.0020168 secondes
sync: Terminé

En outre, il est intéressant de noter que Thread.Sleepc'est beaucoup plus précis, la précision ms n'est pas vraiment un problème, alors qu'elle Task.Delaypeut prendre 15-30 ms minimum. Les frais généraux sur les deux fonctions sont minimes par rapport à la précision en ms qu'ils ont (utilisez StopwatchClass si vous avez besoin de quelque chose de plus précis). Thread.Sleepattache toujours votre fil, Task.Delayrelâchez-le pour effectuer d'autres travaux pendant que vous attendez.

si le thread actuel est tué et que vous l'utilisez Thread.Sleepet qu'il s'exécute, vous pouvez obtenir un ThreadAbortException. Avec Task.Delayvous pouvez toujours fournir un jeton d'annulation et le tuer gracieusement. C'est une des raisons pour lesquelles je choisirais Task.Delay. voir http://social.technet.microsoft.com/wiki/contents/articles/21177.visual-c-thread-sleep-vs-task-delay.aspx

Je conviens également que l'efficacité n'est pas primordiale dans ce cas.

Je veux ajouter quelque chose. En fait, Task.Delayest un mécanisme d'attente basé sur une minuterie. Si vous regardez la source, vous trouverez une référence à une Timerclasse qui est responsable du retard. D'un autre côté, Thread.Sleeple thread actuel se met en veille, de cette façon vous bloquez et gaspillez un thread. Dans le modèle de programmation asynchrone, vous devez toujours utiliser Task.Delay()si vous voulez que quelque chose (suite) se produise après un certain retard.