Les vrais avantages de Async-Wait?

Plus tôt, j’ai posté cette question liée à l’application Async-Await chez le client ou au service. Lisez la question avant d’aller de l’avant avec cette question car elle est étroitement liée à la question.

Sur la base de cette réponse, j’ai testé le code pour C # 4.0 (TPL) et C # 5.0 (Async – Await). J’appelle le service en utilisant la version asynchrone et sync de la méthode fournie par le service et en comparant le nombre de threads utilisés dans chaque cas. Voici le code que j’utilise pour tester les ressources utilisées:

METHODE PRINCIPALE

List<Task> tasksList = new List<Task>(); List asyncThreads = new List(); List tplThreads = new List(); Stopwatch watch = new Stopwatch(); watch.Start(); // Call the Async version of the method for (int i = 0; i < 500; i++) { tasksList.Add(GetNameFromServiceAsync("Input" + i.ToString(), asyncThreads)); } Task.WaitAll(tasksList.ToArray()); watch.Stop(); foreach (var item in asyncThreads.Distinct()) { Console.WriteLine(item); } Console.WriteLine("(C# 5.0)Asynchrony Total Threads = " + asyncThreads.Distinct().Count()); Console.WriteLine(watch.ElapsedMilliseconds.ToString()); watch.Restart(); tasksList.Clear(); // Call the normal method for (int i = 0; i < 500; i++) { tasksList.Add(GetNameFromService("Input" + i.ToString(), tplThreads)); } Task.WaitAll(tasksList.ToArray()); watch.Stop(); foreach (var item in tplThreads.Distinct()) { Console.WriteLine(item); } Console.WriteLine("(C# 4.0)TPL Total Threads" + tplThreads.Distinct().Count()); Console.WriteLine(watch.ElapsedMilliseconds.ToString()); 

Async et Sync CAlls Au service

 static async Task GetNameFromServiceAsync(ssortingng name, List threads) { Console.WriteLine(" Start Current Thread : " + System.Threading.Thread.CurrentThread.ManagedThreadId); var task = await client.GetNameAsync(name); threads.Add(System.Threading.Thread.CurrentThread.ManagedThreadId); // Console.WriteLine("End GetNameFromServiceAsync Current Thread : " + System.Threading.Thread.CurrentThread.ManagedThreadId); return task; } static Task GetNameFromService(ssortingng name, List threads) { var task = Task.Factory.StartNew(() => { threads.Add(System.Threading.Thread.CurrentThread.ManagedThreadId); // Console.WriteLine("GetNameFromService Current Thread : " + System.Threading.Thread.CurrentThread.ManagedThreadId); return client.GetName(name); }); return task; } 

Maintenant, j’ai travaillé sur la réponse et trouver les résultats suivants:

  • Si je fais 500 appels au service, il utilise seulement 4-5 threads.
  • Les appels TPL font environ 44 à 45 threads.
  • La durée des appels asynchrones est d’environ 17 à 18 secondes.
  • Le temps pour les appels TPL est environ 42 – 45 secondes.

Je souhaite obtenir des informations sur mes conclusions afin qu’elles puissent également être utiles aux autres membres de la communauté. Est-ce ce que la réponse de ma question précédente ??

MODIFIER

Q. Mon observation conclut que si nous utilisons Async-Await au lieu de Task.Factory.startNew de TPL, il utilisera des threads moindres. COMMENT EST-CE CORRECT? SI NON, ALORS QUELLE EST LA BONNE DIRECTION POUR VENIR AVEC UNE TELLE COMPARAISON?

Q. Comme je suis en train d’apprendre de manière asynchrone – attends, je veux prouver sa valeur par une sorte de comparaison et un code solide.

Le mode async côté client (comparé au code synchrone) améliore généralement la réactivité moyennant un léger coût en mémoire.

L’ async côté serveur (comparé au code synchrone) améliore généralement l’évolutivité en réduisant l’utilisation de la mémoire / des threads. Ces avantages s’appliquent également à l’ async côté client (par rapport au code multithread).

Ce sont deux généralisations extrêmes et il y a certainement des situations où elles sont fausses.

Mettre à jour:

Mon observation conclut que si nous utilisons Async-Await …, cela consumra moins de threads.

async / async code asynchrone maintenable. En eux-mêmes, ils n’ont rien à voir avec la création de threads. Cependant, ils sont souvent utilisés avec Task.Run (ou Task.Factory.StartNew ) pour créer des tâches en arrière-plan.

Pendant que j’apprends asynchrone – attends, je veux prouver sa valeur par une sorte de comparaison et un code solide.

async et await sont des transformations du compilateur. Ils facilitent l’écriture de programmes asynchrones – c’est tout.

Si vous les comparez au code synchrone, vous constaterez généralement une amélioration de la réactivité et / ou de l’évolutivité. Si vous les comparez au code asynchrone existant, ils seront généralement un peu moins efficaces, mais compenseront largement en termes de maintenabilité du code.