Attente synchrone d'une opération asynchrone, et pourquoi Wait() fige le programme ici

Question

Préface : Je cherche une explication, pas seulement une solution. Je connais déjà la solution.

Bien que j'aie passé plusieurs jours à étudier les articles de MSDN sur le modèle asynchrone basé sur les tâches (TAP), async et await, je suis encore un peu perdu sur certains détails plus fins.

J'écris un enregistreur pour Windows Store Apps, et je veux prendre en charge l'enregistrement asynchrone et synchrone. Les méthodes asynchrones suivent le TAP, les méthodes synchrones devraient cacher tout cela, et ressembler et fonctionner comme des méthodes ordinaires.

Il s'agit de la méthode de base de la journalisation asynchrone :

private async Task WriteToLogAsync(string text)
{
    StorageFolder folder = ApplicationData.Current.LocalFolder;
    StorageFile file = await folder.CreateFileAsync("log.log",
        CreationCollisionOption.OpenIfExists);
    await FileIO.AppendTextAsync(file, text,
        Windows.Storage.Streams.UnicodeEncoding.Utf8);
}

Maintenant, la méthode synchrone correspondante...

Version 1 :

private void WriteToLog(string text)
{
    Task task = WriteToLogAsync(text);
    task.Wait();
}

Cela semble correct, mais cela ne fonctionne pas. L'ensemble du programme se fige indéfiniment.

Version 2 :

Hmm Peut-être que la tâche n'a pas été lancée ?

private void WriteToLog(string text)
{
    Task task = WriteToLogAsync(text);
    task.Start();
    task.Wait();
}

Cela jette InvalidOperationException: Start may not be called on a promise-style task.

Version 3 :

Hmm Task.RunSynchronously Cela semble prometteur.

private void WriteToLog(string text)
{
    Task task = WriteToLogAsync(text);
    task.RunSynchronously();
}

Cela jette InvalidOperationException: RunSynchronously may not be called on a task not bound to a delegate, such as the task returned from an asynchronous method.

Version 4 (la solution) :

private void WriteToLog(string text)
{
    var task = Task.Run(async () => { await WriteToLogAsync(text); });
    task.Wait();
}

Cela fonctionne. Donc, 2 et 3 sont les mauvais outils. Mais 1 ? Qu'est-ce qui ne va pas avec 1 et quelle est la différence avec 4 ? Pourquoi 1 provoque-t-il un blocage ? Y a-t-il un problème avec l'objet tâche ? Y a-t-il un blocage non évident ?

Answer 1

El await à l'intérieur de votre méthode asynchrone essaie de revenir au thread de l'interface utilisateur.

Puisque le thread de l'interface utilisateur est occupé à attendre que la tâche entière se termine, vous avez un blocage.

Déplacer l'appel asynchrone vers Task.Run() résout le problème.
Comme l'appel asynchrone s'exécute maintenant sur un thread de pool, il n'essaie pas de revenir sur le thread de l'interface utilisateur, et tout fonctionne donc.

Alternativement, vous pouvez appeler StartAsTask().ConfigureAwait(false) avant d'attendre l'opération interne pour qu'elle revienne au pool de threads plutôt qu'au thread de l'interface utilisateur, ce qui évite complètement le blocage.

Answer 2

Appel à async du code synchrone peut être assez délicat.

J'explique le toutes les raisons de cette impasse sur mon blog . En bref, il y a un "contexte" qui est sauvegardé par défaut au début de chaque opération de l await et utilisé pour reprendre la méthode.

Ainsi, si cette fonction est appelée dans un contexte d'interface utilisateur, lorsque la fonction await s'achève, le async tente de réintégrer ce contexte pour poursuivre son exécution. Malheureusement, le code utilisant Wait (ou Result ) bloquera un thread dans ce contexte, de sorte que l'option async ne peut pas se terminer.

Les directives pour éviter cela sont les suivantes :

1. Utilisez ConfigureAwait(continueOnCapturedContext: false) autant que possible. Cela permet à votre async de poursuivre l'exécution des méthodes sans avoir à entrer à nouveau dans le contexte.
2. Utilisez async jusqu'au bout. Utilisez await au lieu de Result o Wait .

Si votre méthode est naturellement asynchrone, alors vous ne devriez (probablement) pas exposer un wrapper synchrone .

Answer 3

Voici ce que j'ai fait

private void myEvent_Handler(object sender, SomeEvent e)
{
  // I dont know how many times this event will fire
  Task t = new Task(() =>
  {
    if (something == true) 
    {
        DoSomething(e);  
    }
  });
  t.RunSynchronously();
}

fonctionne parfaitement et ne bloque pas le thread de l'interface utilisateur

Answer 4

Avec un petit contexte de synchronisation personnalisé, la fonction sync peut attendre l'achèvement de la fonction async, sans créer d'impasse. Voici un petit exemple pour une application WinForms.

Imports System.Threading
Imports System.Runtime.CompilerServices

Public Class Form1

    Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
        SyncMethod()
    End Sub

    ' waiting inside Sync method for finishing async method
    Public Sub SyncMethod()
        Dim sc As New SC
        sc.WaitForTask(AsyncMethod())
        sc.Release()
    End Sub

    Public Async Function AsyncMethod() As Task(Of Boolean)
        Await Task.Delay(1000)
        Return True
    End Function

End Class

Public Class SC
    Inherits SynchronizationContext

    Dim OldContext As SynchronizationContext
    Dim ContextThread As Thread

    Sub New()
        OldContext = SynchronizationContext.Current
        ContextThread = Thread.CurrentThread
        SynchronizationContext.SetSynchronizationContext(Me)
    End Sub

    Dim DataAcquired As New Object
    Dim WorkWaitingCount As Long = 0
    Dim ExtProc As SendOrPostCallback
    Dim ExtProcArg As Object

    <MethodImpl(MethodImplOptions.Synchronized)>
    Public Overrides Sub Post(d As SendOrPostCallback, state As Object)
        Interlocked.Increment(WorkWaitingCount)
        Monitor.Enter(DataAcquired)
        ExtProc = d
        ExtProcArg = state
        AwakeThread()
        Monitor.Wait(DataAcquired)
        Monitor.Exit(DataAcquired)
    End Sub

    Dim ThreadSleep As Long = 0

    Private Sub AwakeThread()
        If Interlocked.Read(ThreadSleep) > 0 Then ContextThread.Resume()
    End Sub

    Public Sub WaitForTask(Tsk As Task)
        Dim aw = Tsk.GetAwaiter

        If aw.IsCompleted Then Exit Sub

        While Interlocked.Read(WorkWaitingCount) > 0 Or aw.IsCompleted = False
            If Interlocked.Read(WorkWaitingCount) = 0 Then
                Interlocked.Increment(ThreadSleep)
                ContextThread.Suspend()
                Interlocked.Decrement(ThreadSleep)
            Else
                Interlocked.Decrement(WorkWaitingCount)
                Monitor.Enter(DataAcquired)
                Dim Proc = ExtProc
                Dim ProcArg = ExtProcArg
                Monitor.Pulse(DataAcquired)
                Monitor.Exit(DataAcquired)
                Proc(ProcArg)
            End If
        End While

    End Sub

     Public Sub Release()
         SynchronizationContext.SetSynchronizationContext(OldContext)
     End Sub

End Class

Answer 5

Pour moi, c'est la meilleure solution :

AsyncMethod(<params>).ConfigureAwait(true).GetAwaiter().GetResult();

Fonctionne également sur UI-Content sans problèmes de blocage et de répartiteur, et aussi de CTOR.