HttpWebRequest - puis-je faire plusieurs appels à la sametime à partir de plusieurs threads

Pour être honnête, je ne crois pas que le multi-threading, vous êtes en essayant de faire va vous recevoir tout de gains de performance. Et de voir qu'il n'y a pas de seuil pour le nombre de threads que vous pourriez être la création d'ici le potentiel pour le pire rendement qu'un seul thread (séquentiel) opération existe.

La situation idéale est que vous avez un travail asynchrone flux. lorsque la boucle est quelque chose comme ceci:

GetAsyncRequest
MakeAsyncRequest
ReceiveResponseAsync
ProcessResponse
WaitForAllRequestProcessingToComplete(En Option)

Tels que le résultat de chaque étape se nourrit dans la prochaine (si il y a un résultat) et à la prochaine. Et vous traitez les réponses dès que vous les recevez, plutôt que l'accumulation (joindre/bloquer) toutes les réponses avant de continuer à les traiter. Ce genre de chose peut être fait facilement avec les Tâches et les ContinueWith .NET 4.0 et voir que vous avez de l'utiliser .NET 4.0 j'aimerais vous suggérons fortement de le faire, comme décrit ci-dessus.

Mais, si vous n'êtes pas en mesure de convertir votre traitement dans un async flux de travail, alors...

La méthode indiquée ci-dessous est la méthode qui fait l'appel à l'Url et renvoie une réponse. La méthode utilise les appels Asynchrones mais bloque depuis votre conception semble être en tant que tel.

static string GetWebResponse(string url, NameValueCollection parameters)
{
var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
httpWebRequest.ContentType = "application/x-www-form-urlencoded";
httpWebRequest.Method = "POST";
var sb = new StringBuilder();
foreach (var key in parameters.AllKeys)
sb.Append(key + "=" + parameters[key] + "&");
sb.Length = sb.Length - 1;
byte[] requestBytes = Encoding.UTF8.GetBytes(sb.ToString());
httpWebRequest.ContentLength = requestBytes.Length;
using (var requestStream = httpWebRequest.GetRequestStream())
{
requestStream.Write(requestBytes, 0, requestBytes.Length);
requestStream.Close();
}
Task<WebResponse> responseTask = Task.Factory.FromAsync<WebResponse>(httpWebRequest.BeginGetResponse, httpWebRequest.EndGetResponse, null);
using (var responseStream = responseTask.Result.GetResponseStream())
{
var reader = new StreamReader(responseStream);
return reader.ReadToEnd();
}
}

Vous souhaitez appeler comme ceci:

  ServicePointManager.DefaultConnectionLimit = 20;//Please test different numbers here
var tasks = new List<Task<string>>();
for (int i = 1990; i < 2090; i++)
{
var postParameters = new NameValueCollection();
postParameters.Add("data", i.ToString());
tasks.Add(Task.Factory.StartNew(() => { return GetWebResponse("http://www.abc123.com", postParameters); }));
}
Task.WaitAll(tasks.ToArray());
//At this point tasks[0].Result will be the result (The Response) of the first task
//tasks[1].Result will be the result of the second task and so on.

Voir si cela fonctionne pour vous.

Si vous avez vraiment besoin de multi-threaded capacité, bien sûr, vu que vous avez frapper un seul site, il faudrait mesurer la performance des prestations depuis le site doit être en mesure de gérer l'assaut des demandes et sur le client le coût de la création de threads, uniquement pour faire quelques I/O bound tâche pourrait être trop coûteux et à la fin avec pas de gains de performance.

D'ailleurs, sans réglage de DefaultConnectionLimit dans le ServicePointManager, vous ne serez jamais plus de 2 threads soit car vous allez à l'encontre de l'un de domaine et la limite par défaut est de 2 threads par domaine.

Je collerais avec le code que j'ai présenté et si il y a un problème de performance alors je le regarde faire d'une autre manière.

Edit:
lors de l'utilisation d'e/S Asynchrone vous n'êtes pas à l'aide de threads de travail, mais I/O fil. Donc, fondamentalement, vous ne voulez pas utiliser QueueUserWorkItem (pour créer des threads) ou vous n'êtes pas créer des threads de vous-même.

Le code que j'ai présenté est à l'aide d'e/S Asynchrone et s'apprête à exécuter de multiples demandes simutaneously et aussi vite que possible.

Pour la boucle (dans le deuxième exemple de code) va finir presque immédiatement, même si, dans l'exemple il fait une boucle pour 100 itérations, et puis attendre que toutes les demandes d'e/S à la fin. Le pool de threads et OS pour gérer l'exécution de l'I/O un emploi le plus rapidement et le plus vite possible. En fait, parce que ces emplois sont I/O bound, vous ne verrez pas votre utilisation de l'UC aller jusqu'soit (sauf si vous êtes en train de faire en cpu, travail par la suite).

Il suffit de jouer avec le ServiceManager.DefaultConnectionLimit pour obtenir plus d'accélération en cas de besoin. Notez que cela affecte le service (le serveur), car si vous faites beaucoup de requêtes simultanées que le serveur vous appelez devient très chargé et qui ne peut pas être quelque chose que vous voulez. C'est donc un équilibre dont vous avez besoin de faire la grève.

Après l'appel à la Tâche.WaitAll, vous pouvez parcourir vos tâches de collecte et d'obtenir les résultats de chaque tâche à l'aide de la syntaxe indiquée dans la ligne de commentaire dans le code.

OriginalL'auteur Shiv Kumar