Pourquoi ma méthode C# asynchrone se bloque-t-elle lors de l'accès aux résultats des tâches ?

La raison pour laquelle la méthode asynchrone C# se bloque lors de l'accès aux résultats de la tâche

Lors de l'utilisation des mots-clés async et await de C# pour la programmation asynchrone, certaines constructions peuvent provoquer un comportement inattendu et des blocages potentiels.

Considérez le scénario suivant : une application multiniveau utilise une méthode utilitaire de base de données étendue ExecuteAsync qui exécute de manière asynchrone une requête SQL et renvoie les résultats. La méthode de couche intermédiaire GetTotalAsync appelle ExecuteAsync pour récupérer les données et stocke le résultat dans la variable asyncTask. Enfin, les opérations de l'interface utilisateur tentent d'accéder aux résultats de manière synchrone à l'aide de asyncTask.Result. Cependant, l'application se bloque indéfiniment.

Cause de l'impasse

Le problème vient de l'utilisation de GetTotalAsync dans la méthode await. Par défaut, les suites des méthodes asynchrones sont distribuées sur le même SynchronizationContext qui a démarré la méthode. Dans ce cas, lors de l'utilisation de await sur le thread UI, la suite (return result;) est également programmée pour s'exécuter sur le thread UI.

Lorsque asyncTask.Result est appelé sur le thread de l'interface utilisateur, il bloque le thread une fois la tâche terminée. Cependant, les continuations planifiées sur le thread de l'interface utilisateur ne peuvent pas s'exécuter tant que asyncTask.Result n'est pas terminé. Cela crée une impasse dans laquelle aucun des threads ne peut continuer l'exécution.

Solution

Afin de sortir de cette impasse, il existe plusieurs méthodes :

1. Supprimer le mot-clé asynchrone :

Éliminer l'utilisation de await et réécrire les méthodes ExecuteAsync et GetTotalAsync comme des méthodes purement asynchrones qui n'attendent pas :

<code class="language-csharp">public static Task<T> ExecuteAsync<T>(this OurDBConn dataSource, Func<OurDBConn, T> function)
{
    // ... (代码保持不变)
}

public static Task<ResultClass> GetTotalAsync(...)
{
    // ... (代码保持不变)
}</code>

2. Utilisez ConfigureAwait :

Utilisez ConfigureAwait(false) pour spécifier que les continuations ne doivent pas être planifiées sur le fil de discussion de l'interface utilisateur :

<code class="language-csharp">public static async Task<ResultClass> GetTotalAsync(...)
{
    var resultTask = this.DBConnection.ExecuteAsync<ResultClass>(
        ds => ds.Execute("select slow running data into result"));

    return await resultTask.ConfigureAwait(false);
}</code>

Notez que cette approche nécessite une spécification explicite de await sur toutes les ConfigureAwait(false) opérations pouvant conduire à une impasse.

3. Utilisez SynchronizationContext :

Créez un SynchronizationContext spécifique pour les opérations asynchrones et assurez-vous que toutes les opérations await utilisent ce contexte, évitant ainsi les conflits avec le thread de l'interface utilisateur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!