¿Cuándo usar Task.Delay, cuándo usar Thread.Sleep?

¿Hay buenas reglas para cuándo usar Task.Delay versus Thread.Sleep ?

• Específicamente, ¿hay un valor mínimo para que uno sea efectivo / eficiente sobre el otro?
• Por último, dado que Task.Delay provoca el cambio de contexto en una máquina de estado asíncrono / espera, ¿hay algún gasto adicional por usarlo?

Úselo Thread.Sleepcuando desee bloquear el hilo actual.

Úselo Task.Delaycuando desee un retraso lógico sin bloquear el hilo actual.

La eficiencia no debe ser una preocupación primordial con estos métodos. Su uso principal en el mundo real es como temporizadores de reintento para operaciones de E / S, que son del orden de segundos en lugar de milisegundos.

La mayor diferencia entre Task.Delayy Thread.Sleepes que Task.Delayestá destinado a ejecutarse de forma asincrónica. No tiene sentido usarlo Task.Delayen código síncrono. Es una idea MUY mala usar Thread.Sleepen código asincrónico.

Normalmente llamarás Task.Delay() con la awaitpalabra clave:

await Task.Delay(5000);

o, si desea ejecutar algún código antes del retraso:

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

¿Adivina qué imprimirá esto? Corriendo por 0.0070048 segundos. Si movemos lo await delayanterior Console.WriteLine, se imprimirá Running durante 5.0020168 segundos.

Veamos la diferencia 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");
    }
}

Intenta predecir lo que esto imprimirá ...

asíncrono: inicio
asíncrono: ejecución de 0.0070048 segundos
sincronización: inicio
asíncrono: ejecución de 5.0119008 segundos
asíncrono: finalización de
sincronización: ejecución de 5.0020168 segundos
sincronización: finalizado

Además, es interesante notar que Thread.Sleepes mucho más preciso, la precisión de ms no es realmente un problema, mientras que Task.Delaypuede tomar un mínimo de 15-30 ms. La sobrecarga en ambas funciones es mínima en comparación con la precisión de ms que tienen (use StopwatchClass si necesita algo más preciso). Thread.Sleepaún ata tu hilo, Task.Delaysuéltalo para hacer otro trabajo mientras esperas.

si el subproceso actual se elimina y lo usa Thread.Sleepy se está ejecutando, entonces podría obtener un ThreadAbortException. Con Task.Delayusted siempre puede proporcionar un token de cancelación y matarlo con gracia. Esa es una razón por la que elegiría Task.Delay. ver http://social.technet.microsoft.com/wiki/contents/articles/21177.visual-c-thread-sleep-vs-task-delay.aspx

También estoy de acuerdo en que la eficiencia no es primordial en este caso.

Quiero agregar algo En realidad, Task.Delayes un mecanismo de espera basado en temporizador. Si observa la fuente , encontrará una referencia a una Timerclase responsable del retraso. Por otro lado, en Thread.Sleeprealidad hace que el hilo actual se suspenda, de esa manera solo está bloqueando y desperdiciando un hilo. En el modelo de programación asíncrona, siempre debe usar Task.Delay()si desea que algo (continuación) suceda después de algún retraso.