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:
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.