Perché il CTP asincrone sta eseguendo male?
-
28-10-2019 - |
Domanda
Non capisco davvero perché await
e async
Non migliorare le prestazioni del mio codice qui Come dovrebbero.
Sebbene scettico, ho pensato che il compilatore avrebbe dovuto riscrivere il mio metodo in modo che i download fossero fatti in parallelo ... ma sembra che non stia realmente accadendo.
(io fare capito che await
e async
non creare thread separati; Tuttavia, il sistema operativo dovrebbe fare i download in parallelo e richiamare il mio codice nel thread originale - non è vero?)
Sto usando async
e await
improprio? Qual è il modo corretto di usarli?
Codice:
using System;
using System.Net;
using System.Threading;
using System.Threading.Tasks;
static class Program
{
static int SumPageSizesSync(string[] uris)
{
int total = 0;
var wc = new WebClient();
foreach (var uri in uris)
{
total += wc.DownloadData(uri).Length;
Console.WriteLine("Received synchronized data...");
}
return total;
}
static async Task<int> SumPageSizesAsync(string[] uris)
{
int total = 0;
var wc = new WebClient();
foreach (var uri in uris)
{
var data = await wc.DownloadDataTaskAsync(uri);
Console.WriteLine("Received async'd CTP data...");
total += data.Length;
}
return total;
}
static int SumPageSizesManual(string[] uris)
{
int total = 0;
int remaining = 0;
foreach (var uri in uris)
{
Interlocked.Increment(ref remaining);
var wc = new WebClient();
wc.DownloadDataCompleted += (s, e) =>
{
Console.WriteLine("Received manually async data...");
Interlocked.Add(ref total, e.Result.Length);
Interlocked.Decrement(ref remaining);
};
wc.DownloadDataAsync(new Uri(uri));
}
while (remaining > 0) { Thread.Sleep(25); }
return total;
}
static void Main(string[] args)
{
var uris = new string[]
{
// Just found a slow site, to demonstrate the problem :)
"http://www.europeanchamber.com.cn/view/home",
"http://www.europeanchamber.com.cn/view/home",
"http://www.europeanchamber.com.cn/view/home",
"http://www.europeanchamber.com.cn/view/home",
"http://www.europeanchamber.com.cn/view/home",
};
{
var start = Environment.TickCount;
SumPageSizesSync(uris);
Console.WriteLine("Synchronous: {0} milliseconds", Environment.TickCount - start);
}
{
var start = Environment.TickCount;
SumPageSizesManual(uris);
Console.WriteLine("Manual: {0} milliseconds", Environment.TickCount - start);
}
{
var start = Environment.TickCount;
SumPageSizesAsync(uris).Wait();
Console.WriteLine("Async CTP: {0} milliseconds", Environment.TickCount - start);
}
}
}
Produzione:
Received synchronized data...
Received synchronized data...
Received synchronized data...
Received synchronized data...
Received synchronized data...
Synchronous: 14336 milliseconds
Received manually async data...
Received manually async data...
Received manually async data...
Received manually async data...
Received manually async data...
Manual: 8627 milliseconds // Almost twice as fast...
Received async'd CTP data...
Received async'd CTP data...
Received async'd CTP data...
Received async'd CTP data...
Received async'd CTP data...
Async CTP: 13073 milliseconds // Why so slow??
Soluzione
La risposta di Chris è quasi corretta, ma introduce una condizione di gara e blocca in modo sincrono su tutti i compiti.
Come regola generale, è meglio non utilizzare le continue delle attività se lo hai await
/async
a disposizione. Inoltre, non usare WaitAny
/ WaitAll
- il async
gli equivalenti sono WhenAny
e WhenAll
.
Lo scriverei in questo modo:
static async Task<int> SumPageSizesAsync(IEnumerable<string> uris)
{
// Start one Task<byte[]> for each download.
var tasks = uris.Select(uri => new WebClient().DownloadDataTaskAsync(uri));
// Asynchronously wait for them all to complete.
var results = await TaskEx.WhenAll(tasks);
// Calculate the sum.
return results.Sum(result => result.Length);
}
Altri suggerimenti
Potrei legare male al tuo codice, ma sembra che tu stia lanciando un thread di sfondo per fare la lettura dell'asincronizza Nulla sulla parte "asincrima" del tuo codice è in realtà asincrone. Prova questo:
static async Task<int> SumPageSizesAsync(string[] uris)
{
int total = 0;
var wc = new WebClient();
var tasks = new List<Task<byte[]>>();
foreach (var uri in uris)
{
tasks
.Add(wc.DownloadDataTaskAsync(uri).ContinueWith(() => { total += data.Length;
}));
}
Task.WaitAll(tasks);
return total;
}
E usalo così:
{
var start = Environment.TickCount;
await SumPageSizesAsync(uris);
Console.WriteLine("Async CTP: {0} milliseconds", Environment.TickCount - start);
}
Potrei sbagliarmi: la roba asincrimale è nuova e non ho familiarità al 100%, ma il tempismo simile alla versione di sincronizzazione sembra farmi uscire.