Écrit multithread méthodes utilisant async/await dans .Net 4.5

J'ai une petite requête.

J'avoue que je n'ai pas utiliser le multithreading bien avant .Net 4.5, mais avec la nouvelle async/await fonctionnalité j'ai décidé de lui donner un essai. J'ai commencé à expérimenter avec elle et tout semble très bien, mais je n'ai pas pu trouver une solution à mon "problème" n'importe où sur le web.

Tout le monde donc expliquer comment await peut être utilisé avec le récemment transformé les méthodes de la .Net plate-forme (par exemple,WriteAsync(), ReadAsync() etc...), mais que si je voulais l'utiliser pour mes propres méthodes? Par exemple, disons que je suis de l'exécution d'une extrêmement coûteux de calcul et veulent tous de mon 4 cœurs de travailler sur elle. Je voudrais avoir quelque chose de similaire à ceci:

async Task DoLotsOfWork<T>(T[] data, int start, int end)
{
    //Do very expensive work
}

Mais depuis je n'ai pas de await mot-clé là, la méthode est traitée comme une synchrone un. Je voudrais l'appeler 4 fois à partir de l'extérieur de sorte qu'il peut fonctionner sur tous mes cœurs, alors que je l'affichage de quelque chose de sensible, de l'utilisateur(par exemple, "Veuillez patienter..."). La seule solution que j'ai pu comprendre, c'était d'ajouter un await Task.Yield(); dans le début de la méthode. Quelque chose comme ceci:

async Task DoLotsOfWork<T>(T[] data, int start, int end)
{
    await Task.Yield();
    //Do very expensive work
}

Dans ce cas, la méthode se comportent comme je l'attendez. Mais est-il une meilleure solution pour cela? Je pense qu'il devrait être plus facile/plus sensible que d'écrire exactement cette ligne de code. Je comprends que je peux créer un Task/Thread objet et l'appel de la Start() méthode, mais qui nécessite encore plus de travail. J'ai juste pensé que, avec le nouveau async/await fonctionnalité de ce genre de chose serait plus facile.

  • La nouvelle async / await modèle n'offre pas de multithreading. Il donne seulement plus propre code pour les opérations de manutention qui bloquent votre thread courant.
  • Les mots clés ne signifie pas "utiliser tous les cœurs". Ils ont juste dire que le compilateur et l'environnement d'exécution d'une opération peut être effectuée sur un sperate fil. Si il y a un 4 les opérations qui peuvent être exécutées simultanément, ils pourraient être exécuté sur 4 différents cœurs.
  • Vous voulez prendre un coup d'oeil à cette l'asynchronie vs simultanéité, async attendent N'aide PAS pour le multithreading. Il est utile pour même unique, fourrés machines.
  • Ok. Donc, en d'autres termes - ne pas utiliser async/await pour multithreding. Je comprends maintenant. Je vous remercie.
  • Ce n'est pas que de ne pas utiliser, mais vous ne pouvez pas l'utiliser pour cela. Il n'était pas censé le faire, donc il ne peut pas le faire.
  • Vous pouvez certainement utiliser attendent en collaboration avec le code multithread, vous avez juste besoin d'un mécanisme pour démarrer l'exécution du code dans un autre thread, une fois que vous l'avez fait par d'autres moyens, async/await peut vous aider à gérer plus efficacement.

InformationsquelleAutor Milcho | 2013-03-07
  1. 14

    Donc, pour commencer, vous aurez besoin d'une méthode qui ne le très cher travailler en mode synchrone:

    public void DoLotsOfWork<T>(T[] data, int start, int end) 
{
    Thread.Sleep(5000);//placeholder for real work
}

    Ensuite, nous pouvons utiliser Task.Run pour démarrer plusieurs instances de ce travail dans un pool de threads thread.

    List<Task> tasks = new List<Task>();
for(int i = 0; i < 4; i++)
{
    tasks.Add(Task.Run(()=>DoLotsOfWork(data, start, end));
}

    Alors nous pouvons faire un non-bloquant attendre jusqu'à ce que tous d'entre eux sont en fait:

    await Task.WhenAll(tasks);
    • Vous pouvez également utiliser le Parallel classe, qui est conçu pour le traitement en parallèle.
    • le problème est que les méthodes parallèles bloc jusqu'à ce que les résultats sont faits de sorte que vous finissez par avoir besoin de jeter le Parallel.For ou Foreach dans un Task.Run si vous êtes actuellement dans, disons, une INTERFACE utilisateur contexte et ne peuvent pas bloquer jusqu'à ce que les tâches sont terminées.
    • Vrai. Mais l'avantage de Parallel est-il automatiquement la partition de travail pour faire le meilleur usage de vos cœurs disponibles. Comme vous l'avez dit, vous pouvez l'envelopper dans Task.Run pour obtenir un Task représentant en parallèle, un travail.
    • Si, à partir de l'une des Task.Run(() => myFunction()); j'ai un myFunction() pour retourner une valeur, comment puis-je gérer cela?
    • Avoir un List<Task<T>> et stocker le résultat de await Task.Whenall dans une variable.
    InformationsquelleAutor Servy