Contoh async / await yang menyebabkan kebuntuan

Saya menemukan beberapa praktik terbaik untuk pemrograman asinkron menggunakan c # 's async/ awaitkeywords (Saya baru mengenal c # 5.0).

Salah satu saran yang diberikan adalah sebagai berikut:

Stabilitas: Ketahui konteks sinkronisasi Anda

... Beberapa konteks sinkronisasi non-reentrant dan single-threaded. Ini berarti hanya satu unit pekerjaan yang dapat dijalankan dalam konteks pada waktu tertentu. Contohnya adalah utas Windows UI atau konteks permintaan ASP.NET. Dalam konteks sinkronisasi utas tunggal ini, Anda mudah menemui jalan buntu. Jika Anda mengeluarkan tugas dari konteks utas tunggal, lalu menunggu tugas itu dalam konteks, kode tunggu Anda mungkin memblokir tugas latar belakang.

public ActionResult ActionAsync()
{
    // DEADLOCK: this blocks on the async task
    var data = GetDataAsync().Result;

    return View(data);
}

private async Task<string> GetDataAsync()
{
    // a very simple async method
    var result = await MyWebService.GetDataAsync();
    return result.ToString();
}

Jika saya mencoba membedahnya sendiri, utas utama muncul ke utas baru MyWebService.GetDataAsync();, tetapi karena utas utama menunggu di sana, utas utama menunggu hasilnya masuk GetDataAsync().Result. Sementara itu, katakanlah data sudah siap. Mengapa utas utama tidak melanjutkan logika kelanjutannya dan mengembalikan hasil string dari GetDataAsync()?

Adakah yang bisa menjelaskan kepada saya mengapa ada kebuntuan dalam contoh di atas? Saya benar-benar tidak tahu apa masalahnya ...

Lihat contoh ini , Stephen punya jawaban yang jelas untuk Anda:

Jadi inilah yang terjadi, dimulai dengan metode tingkat atas ( Button1_Clickuntuk UI / MyController.Getuntuk ASP.NET):

1. Panggilan metode tingkat atas GetJsonAsync(dalam konteks UI / ASP.NET).

2. GetJsonAsyncmemulai permintaan REST dengan memanggil HttpClient.GetStringAsync(masih dalam konteks).

3. GetStringAsyncmengembalikan belum selesai Task, menunjukkan permintaan REST belum selesai.

4. GetJsonAsyncmenunggu Taskdikembalikan oleh GetStringAsync. Konteksnya ditangkap dan akan digunakan untuk melanjutkan menjalankan GetJsonAsyncmetode nanti. GetJsonAsyncmengembalikan yang belum selesai Task, yang menunjukkan bahwa GetJsonAsyncmetode tersebut belum selesai.

5. Metode tingkat atas secara sinkron memblokir pada yang Taskdikembalikan oleh GetJsonAsync. Ini memblokir utas konteks.

6. ... Akhirnya, permintaan REST akan selesai. Ini melengkapi Taskyang dikembalikan oleh GetStringAsync.

7. Kelanjutan untuk GetJsonAsyncsekarang siap dijalankan, dan menunggu konteks tersedia sehingga dapat dijalankan dalam konteks.

8. Kebuntuan . Metode tingkat atas memblokir utas konteks, menunggu GetJsonAsynchingga selesai, dan GetJsonAsyncmenunggu konteks bebas sehingga dapat diselesaikan. Untuk contoh UI, "konteks" adalah konteks UI; untuk contoh ASP.NET, "konteks" adalah konteks permintaan ASP.NET. Jenis kebuntuan ini dapat disebabkan oleh salah satu "konteks".

Tautan lain yang harus Anda baca: Tunggu, dan UI, dan kebuntuan! Astaga!

• Fakta 1: GetDataAsync().Result;akan berjalan saat tugas dikembalikan oleh GetDataAsync()selesai, sementara itu memblokir thread UI
• Fakta 2: Kelanjutan await ( return result.ToString()) diantrekan ke thread UI untuk dieksekusi
• Fakta 3: Tugas yang dikembalikan oleh GetDataAsync()akan selesai saat antrian lanjutannya dijalankan
• Fakta 4: Antrian lanjutan tidak pernah berjalan, karena UI thread diblokir (Fakta 1)

Jalan buntu!

Kebuntuan dapat dipecahkan dengan menyediakan alternatif untuk menghindari Fakta 1 atau Fakta 2.

• Hindari 1,4. Alih-alih memblokir UI thread, gunakan var data = await GetDataAsync()yang memungkinkan thread UI tetap berjalan
• Hindari 2,3. Mengantre kelanjutan menunggu ke utas berbeda yang tidak diblokir, mis. Penggunaan var data = Task.Run(GetDataAsync).Result, yang akan memposting kelanjutan ke konteks sinkronisasi utas threadpool. Ini memungkinkan tugas yang dikembalikan oleh GetDataAsync()selesai.

Ini dijelaskan dengan sangat baik dalam artikel oleh Stephen Toub , sekitar setengah jalan di mana dia menggunakan contoh DelayAsync().

Saya baru saja mengotak-atik masalah ini lagi dalam proyek ASP.NET MVC. Saat Anda ingin memanggil asyncmetode dari a PartialView, Anda tidak diizinkan membuat PartialView async. Anda akan mendapatkan pengecualian jika melakukannya.

Anda dapat menggunakan solusi sederhana berikut dalam skenario di mana Anda ingin memanggil asyncmetode dari metode sinkronisasi:

1. Sebelum panggilan, hapus SynchronizationContext
2. Lakukan panggilan, tidak akan ada lagi kebuntuan disini, tunggu sampai selesai
3. Pulihkan SynchronizationContext

Contoh:

public ActionResult DisplayUserInfo(string userName)
{
    // trick to prevent deadlocks of calling async method 
    // and waiting for on a sync UI thread.
    var syncContext = SynchronizationContext.Current;
    SynchronizationContext.SetSynchronizationContext(null);

    //  this is the async call, wait for the result (!)
    var model = _asyncService.GetUserInfo(Username).Result;

    // restore the context
    SynchronizationContext.SetSynchronizationContext(syncContext);

    return PartialView("_UserInfo", model);
}

Poin utama lainnya adalah Anda tidak boleh memblokir Tasks, dan menggunakan asinkron sepenuhnya untuk mencegah kebuntuan. Maka itu akan menjadi pemblokiran tidak sinkron semua asynchronous.

public async Task<ActionResult> ActionAsync()
{

    var data = await GetDataAsync();

    return View(data);
}

private async Task<string> GetDataAsync()
{
    // a very simple async method
    var result = await MyWebService.GetDataAsync();
    return result.ToString();
}

Solusi yang saya temukan adalah menggunakan Joinmetode ekstensi pada tugas sebelum meminta hasilnya.

Kodenya terlihat seperti ini:

public ActionResult ActionAsync()
{
  var task = GetDataAsync();
  task.Join();
  var data = task.Result;

  return View(data);
}

Dimana metode bergabungnya adalah:

public static class TaskExtensions
{
    public static void Join(this Task task)
    {
        var currentDispatcher = Dispatcher.CurrentDispatcher;
        while (!task.IsCompleted)
        {
            // Make the dispatcher allow this thread to work on other things
            currentDispatcher.Invoke(delegate { }, DispatcherPriority.SystemIdle);
        }
    }
}

Saya tidak cukup masuk ke domain untuk melihat kekurangan dari solusi ini (jika ada)