Когда использовать Task.Delay, когда использовать Thread.Sleep?

Есть хорошие правила для использования Task.Delay против Thread.Sleep ?

• В частности, существует ли минимальное значение для обеспечения того, чтобы один был эффективным / действенным по сравнению с другим?
• Наконец, поскольку Task.Delay вызывает переключение контекста на автомате асинхронного ожидания / ожидания, есть ли издержки его использования?

Используйте, Thread.Sleepкогда вы хотите заблокировать текущий поток.

Используйте, Task.Delayкогда вы хотите, чтобы логическая задержка не блокировала текущий поток.

Эффективность не должна быть первостепенной задачей при использовании этих методов. Их основное реальное использование - таймеры повторов для операций ввода / вывода, которые имеют порядок секунд, а не миллисекунд.

Самое большое различие между Task.Delayи Thread.Sleepзаключается в том, что Task.Delayон предназначен для асинхронной работы. Не имеет смысла использовать Task.Delayв синхронном коде. Это ОЧЕНЬ плохая идея для использования Thread.Sleepв асинхронном коде.

Обычно вы будете звонить Task.Delay() с awaitключевым словом:

await Task.Delay(5000);

или, если вы хотите запустить некоторый код до задержки:

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

Угадайте, что это будет печатать? Запуск за 0,0070048 секунд. Если вместо этого переместить await delayвышеуказанное Console.WriteLine, будет напечатано «Запуск в течение 5.0020168 секунд».

Давайте посмотрим на разницу с 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");
    }
}

Попробуйте предсказать, что это будет печатать ...

асинхронный: запуск
асинхронного: запуск в течение 0,0070048 секунд
синхронизация: запуск
асинхронного: запуск в течение 5,0119008 секунд
асинхронный запуск :
синхронизация: запуск в течение 5,0020168 секунд
синхронизация: выполнено

Кроме того, интересно отметить, что Thread.Sleepэто гораздо более точно, точность мс не является проблемой, хотя Task.Delayможет занять минимум 15-30 мс. Затраты на обе функции минимальны по сравнению с точностью до мс, которую они имеют (используйте StopwatchClass, если вам нужно что-то более точное). Thread.Sleepвсе еще связывает свою Нить, Task.Delayотпустите ее для выполнения другой работы, пока вы ждете.

если текущий поток уничтожен, и вы используете Thread.Sleepего, и он выполняется, то вы можете получить ThreadAbortException. При этом Task.Delayвы всегда можете предоставить токен отмены и изящно убить его. Это одна из причин, я бы выбрал Task.Delay. см. http://social.technet.microsoft.com/wiki/contents/articles/21177.visual-c-thread-sleep-vs-task-delay.aspx

Я также согласен с тем, что в данном случае эффективность не имеет первостепенного значения.

Я хочу кое-что добавить. На самом деле, Task.Delayэто механизм ожидания на основе таймера. Если вы посмотрите на источник, вы найдете ссылку на Timerкласс, который отвечает за задержку. С другой стороны, Thread.Sleepфактически заставляет текущий поток спать, таким образом, вы просто блокируете и тратите один поток. В модели асинхронного программирования вы всегда должны использовать, Task.Delay()если хотите, чтобы что-то (продолжение) произошло после некоторой задержки.