Comment faire pour déterminer le nombre optimal de threads pour les temps de latence élevé des demandes de réseau?

Je suis en train d'écrire un utilitaire qui doit faire des milliers de demandes de réseau. Chaque demande ne reçoit qu'un seul, petit paquet en réponse (similaire à la commande ping), mais peut prendre plus de quelques secondes. Le traitement de chaque réponse complète dans un (simple) de ligne de code.

Le résultat de tout cela est que l'ordinateur n'est pas IO-lié, système de fichier, ou le CPU, il n'est lié que par le temps de latence des réponses.

Ce qui est similaire, mais pas le même que Il y a un moyen pour déterminer le nombre idéal de threads? et Java meilleure façon de déterminer le nombre optimal de threads [dupliquer]... la principale différence est que je ne suis lié par le temps de latence.

Je suis en utilisant un ExecutorService l'objet pour exécuter les threads et un Queue<Future<Integer>> pour suivre les threads qui en ont besoin pour avoir des résultats récupérés:

ExecutorService executorService = Executors.newFixedThreadPool(threadPoolSize);
Queue<Future<Integer>> futures = new LinkedList<Future<Integer>>();

for (int quad3 = 0 ; quad3 < 256 ; ++quad3) {
    for (int quad4 = 0 ; quad4 < 256 ; ++quad4) {
        byte[] quads = { quad1, quad2, (byte)quad3, (byte)quad4 };
        futures.add(executorService.submit(new RetrieverCallable(quads)));
    }
}

... J'ai ensuite retirer tous les éléments dans la file d'attente et de mettre les résultats dans la structure de données:

int[] result = int[65536]
while(!futures.isEmpty()) {
    try {
        results[i] = futures.remove().get();
    } catch (Exception e) {
        addresses[i] = -1;
    }
}

Ma première question est: Est-ce une façon raisonnable de suivre tous les threads? Si thread X prend un certain temps, de nombreux autres threads peut se terminer avant que X n'. Sera le pool de threads d'échappement d'attente pour les fentes ouvertes, ou la ExecutorService objet de gérer le pool de telle manière que les discussions qui ont terminé mais pas encore été traitées être déplacé hors de places disponibles ainsi que les autres threads mon commencer?

Ma deuxième question est ce que les lignes directrices puis-je utiliser pour trouver le nombre optimal de threads pour effectuer ces appels? Je ne sais même pas l'ordre de grandeur des conseils ici. Je sais que ça fonctionne assez bien avec 256 threads, mais semble prendre à peu près le même temps avec 1024 threads. L'utilisation de l'UC est en vol stationnaire autour de 5%, ce qui ne semble pas être un problème. Avec un grand nombre de threads, ce sont tous les indicateurs que je devrais regarder pour comparer les différents numéros? Évidemment, de temps ensemble pour traiter le lot, le temps moyen par thread... quoi d'autre? La mémoire est un problème ici?

OriginalL'auteur seawolf | 2013-10-24