Kapan harus menggunakan Task.Delay, kapan harus menggunakan Thread. Tidur?

Apakah ada aturan yang baik untuk kapan menggunakan Task.Delay versus Thread.Tidur ?

• Secara khusus, adakah nilai minimum untuk menyediakan agar satu menjadi efektif / efisien di atas yang lain?
• Terakhir, karena Task.Delay menyebabkan pengalihan konteks pada mesin status async / wait, apakah ada overhead untuk menggunakannya?

Gunakan Thread.Sleepsaat Anda ingin memblokir utas saat ini.

Gunakan Task.Delaysaat Anda menginginkan penundaan logis tanpa memblokir utas saat ini.

Efisiensi seharusnya tidak menjadi perhatian utama dengan metode ini. Penggunaan dunia nyata utama mereka adalah sebagai coba lagi timer untuk operasi I / O, yang berada di urutan detik daripada milidetik.

Perbedaan terbesar antara Task.Delaydan Thread.Sleepadalah yang Task.Delaydimaksudkan untuk berjalan secara tidak sinkron. Tidak masuk akal untuk menggunakan Task.Delaykode sinkron. Ini adalah ide yang SANGAT buruk untuk digunakan Thread.Sleepdalam kode asinkron.

Biasanya Anda akan menelepon Task.Delay() dengan awaitkata kunci:

await Task.Delay(5000);

atau, jika Anda ingin menjalankan beberapa kode sebelum penundaan:

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

Coba tebak ini akan mencetak? Berjalan selama 0,0070048 detik. Jika kita memindahkan yang di await delayatas Console.WriteLine, itu akan mencetak Running selama 5.0020168 detik.

Mari kita lihat perbedaannya dengan 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");
    }
}

Coba tebak apa yang akan dicetak ini ...

async: Memulai
async: Menjalankan
sinkronisasi 0,0070048 detik : Memulai
async: Menjalankan selama 5,0119008 detik
async: Selesai
sinkronisasi: Menjalankan untuk
sinkronisasi 5,2020168 detik : Selesai

Juga, menarik untuk diperhatikan bahwa Thread.Sleepjauh lebih akurat, akurasi ms tidak benar-benar masalah, sementara Task.Delaydapat mengambil minimal 15-30ms. Overhead pada kedua fungsi minimal dibandingkan dengan akurasi ms yang dimilikinya (gunakan StopwatchKelas jika Anda membutuhkan sesuatu yang lebih akurat).Thread.Sleepmasih mengikat Thread Anda, Task.Delaylepaskan untuk melakukan pekerjaan lain saat Anda menunggu.

jika utas saat ini terbunuh dan Anda gunakan Thread.Sleepdan sedang dieksekusi maka Anda mungkin mendapatkan ThreadAbortException. Dengan Task.DelayAnda selalu dapat memberikan token pembatalan dan dengan anggun membunuhnya. Itulah salah satu alasan saya akan memilih Task.Delay. lihat http://social.technet.microsoft.com/wiki/contents/articles/21177.visual-c-thread-sleep-vs-task-delay.aspx

Saya juga setuju efisiensi bukan yang terpenting dalam kasus ini.

Saya ingin menambahkan sesuatu. Sebenarnya, Task.Delaymekanisme menunggu berbasis timer. Jika Anda melihat sumbernya, Anda akan menemukan referensi ke Timerkelas yang bertanggung jawab atas keterlambatan tersebut. Di sisi lain Thread.Sleepsebenarnya membuat utas saat ini tertidur, dengan cara itu Anda hanya memblokir dan membuang satu utas. Dalam model pemrograman async Anda harus selalu menggunakan Task.Delay()jika Anda menginginkan sesuatu (kelanjutan) terjadi setelah beberapa penundaan.