Veri vantaggi di Async-Await?

Question

In precedenza ho postato la domanda this relativa all'applicazione di Async-Await al client o al servizio. Leggi la domanda prima di andare avanti con questa domanda poiché è strettamente correlata alla domanda.

Sulla base della risposta ho testato il codice per C# 4.0 (TPL) e C# 5.0 (Async - Attesa). Sto chiamando il servizio usando la versione asincrona e sincronizzata del metodo fornito dal servizio e confrontando il numero di thread utilizzati in ciascun caso. seguito è il codice che sto usando per testare le risorse utilizzate:

Metodo principale

List<Task<string>> tasksList = new List<Task<string>>(); 
List<int> asyncThreads = new List<int>(); 
List<int> tplThreads = new List<int>(); 
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()); 

asincrona e Sync chiamate al servizio

static async Task<string> GetNameFromServiceAsync(string name, List<int> 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<string> GetNameFromService(string name, List<int> threads) 
{ 

    var task = Task<string>.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; 
} 

Ora ho ha lavorato sulla risposta e ha trovato i seguenti risultati:

• Se faccio 500 chiamate al servizio usa solo 4-5 thread.
• Le chiamate TPL producono circa 44-45 thread.
• Il tempo per le chiamate asincrone è di circa 17 - 18 secondi
• Il tempo per le chiamate TPL è di circa 42 - 45 secondi.

Voglio avere un feedback sulle mie scoperte in modo che possa essere utile anche agli altri membri della comunità. E 'questa la risposta della mia precedente domanda ??

EDIT

D. La mia osservazione conclude che se usiamo Async-Await invece di Task.Factory.startNew di TPL, allora si consumano discussioni minori. QUANTO CORRETTO È QUESTO? SE NO, QUINDI QUAL È LA GIUSTA SENSA DI RAGGIUNGERE UN CONFRONTO TALE?

Q. Mentre sto imparando async - attendo, voglio dimostrare il suo valore con una sorta di confronto e codice solido.

Answer 1

lato client async (rispetto al codice sincrono) generalmente migliora la reattività con un leggero costo di memoria.

Lato server async (rispetto al codice sincrono) generalmente migliora la scalabilità riducendo l'utilizzo di memoria/thread. Questi vantaggi si applicano anche al lato client async (rispetto al codice multithread).

Entrambe queste sono generalizzazioni estreme e ci sono certamente situazioni in cui si sbagliano.

Aggiornamento:

La mia osservazione conclude che se usiamo Async-aspettano ..., allora si consumano discussioni minori.

async/await codice di abilitazione asincrono mantenibile. Di per sé, non hanno nulla a che fare con la creazione di thread.Tuttavia, vengono spesso utilizzati con Task.Run (o Task.Factory.StartNew) per creare attività in background.

Mentre sto imparando asincrono - attendo, voglio dimostrare il suo valore con una sorta di confronto e codice solido.

async e await sono trasformazioni del compilatore. Rendono più facile scrivere programmi asincroni, questo è tutto.

Se li si confronta con il codice sincrono, di solito si riscontrano reattività e/o scalabilità migliorate. Se li si confronta con il codice asincrono esistente, di solito saranno leggermente meno efficienti ma più che compensati in termini di manutenibilità del codice.