J'expérimente avec quelques constructions de multithreading, mais de toute façon il semble que le multithreading n'est pas plus rapide qu'un seul thread. Je l'ai réduit à un test très simple avec une boucle imbriquée (1000x1000) dans laquelle le système ne compte que.
Ci-dessous j'ai posté le code pour les threads simples et multithread et comment ils sont exécutés.
Le résultat est que le thread unique termine la boucle dans environ 110 ms, tandis que les deux threads prennent également environ 112 ms .
Je ne pense pas que le problème soit la surcharge du multithreading. Si je ne soumets que l'un des deux Runnables à ThreadPoolExecutor, il s'exécute dans la moitié du temps du thread unique, ce qui est logique. Mais ajouter que Runnable deuxième le rend 10 fois plus lent. Les deux cœurs 3.00Ghz fonctionnent à 100%.
Je pense que cela peut être spécifique au PC, car le PC de quelqu'un d'autre a montré des résultats à double vitesse sur le multithreading. Mais alors, que puis-je faire à ce sujet? J'ai un Intel Pentium 4 3.00GHz (2 processeurs) et Java jre6.
Code d'essai:Multithreading pas plus rapide qu'un simple thread (test de boucle simple)
// Single thread:
long start = System.nanoTime(); // Start timer
final int[] i = new int[1]; // This is to keep the test fair (see below)
int i = 0;
for(int x=0; x<10000; x++)
{
for(int y=0; y<10000; y++)
{
i++; // Just counting...
}
}
int i0[0] = i;
long end = System.nanoTime(); // Stop timer
Ce code est exécuté dans environ 110 ms .
// Two threads:
start = System.nanoTime(); // Start timer
// Two of the same kind of variables to count with as in the single thread.
final int[] i1 = new int [1];
final int[] i2 = new int [1];
// First partial task (0-5000)
Thread t1 = new Thread() {
@Override
public void run()
{
int i = 0;
for(int x=0; x<5000; x++)
for(int y=0; y<10000; y++)
i++;
i1[0] = i;
}
};
// Second partial task (5000-10000)
Thread t2 = new Thread() {
@Override
public void run()
{
int i = 0;
for(int x=5000; x<10000; x++)
for(int y=0; y<10000; y++)
i++;
int i2[0] = i;
}
};
// Start threads
t1.start();
t2.start();
// Wait for completion
try{
t1.join();
t2.join();
}catch(Exception e){
e.printStackTrace();
}
end = System.nanoTime(); // Stop timer
Ce code est exécuté en environ 112 ms . Edit: J'ai changé les Runnables en Threads et je me suis débarrassé de l'ExecutorService (pour simplifier le problème).
Edit: a essayé quelques suggestions
Alors, avez-vous essayé les suggestions? –
Ah, Pentium4 - voir ma mise à jour réponse :) – snemarch