Sto sperimentando alcune costruzioni multithreading, ma in qualche modo sembra che il multithreading non sia più veloce di un singolo thread. L'ho ristretto a un test molto semplice con un loop annidato (1000x1000) in cui il sistema conta solo.
Di seguito ho pubblicato il codice sia per il threading singolo che per il multithreading e come vengono eseguiti.
Il risultato è che il thread singolo completa il ciclo in circa 110 ms, mentre i due thread richiedono circa 112 ms.
Non penso che il problema sia il sovraccarico del multithreading. Se invio uno solo dei due Runnables al ThreadPoolExecutor, viene eseguito in metà del tempo del thread singolo, il che ha senso. Ma aggiungere che il secondo Runnable lo rende 10 volte più lento. Entrambi i core da 3.00 Ghz funzionano al 100%.
Penso che potrebbe essere specifico per il PC, in quanto il PC di qualcun altro mostrava risultati a doppia velocità sul multithreading. Ma allora, cosa posso fare a riguardo? Ho un Intel Pentium 4 3.00 GHz (2 CPU) e Java jre6. Codice
prova:Multithreading non più veloce del singolo thread (test ad anello semplice)
// 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
Questo codice viene eseguito in circa 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
Questo codice viene eseguito in circa 112 ms .
Edit: ho cambiato il Runnables per Fili e sono liberato del ExecutorService (per semplicità del problema).
Edit: ha provato alcuni suggerimenti
Quindi, hai provato i suggerimenti? –
Ah, Pentium4 - guarda la mia risposta aggiornata :) – snemarch