Java création de thread frais généraux

Voici un exemple microbenchmark:

public class ThreadSpawningPerformanceTest {
static long test(final int threadCount, final int workAmountPerThread) throws InterruptedException {
Thread[] tt = new Thread[threadCount];
final int[] aa = new int[tt.length];
System.out.print("Creating "+tt.length+" Thread objects... ");
long t0 = System.nanoTime(), t00 = t0;
for (int i = 0; i < tt.length; i++) { 
final int j = i;
tt[i] = new Thread() {
public void run() {
int k = j;
for (int l = 0; l < workAmountPerThread; l++) {
k += k*k+l;
}
aa[j] = k;
}
};
}
System.out.println(" Done in "+(System.nanoTime()-t0)*1E-6+" ms.");
System.out.print("Starting "+tt.length+" threads with "+workAmountPerThread+" steps of work per thread... ");
t0 = System.nanoTime();
for (int i = 0; i < tt.length; i++) { 
tt[i].start();
}
System.out.println(" Done in "+(System.nanoTime()-t0)*1E-6+" ms.");
System.out.print("Joining "+tt.length+" threads... ");
t0 = System.nanoTime();
for (int i = 0; i < tt.length; i++) { 
tt[i].join();
}
System.out.println(" Done in "+(System.nanoTime()-t0)*1E-6+" ms.");
long totalTime = System.nanoTime()-t00;
int checkSum = 0; //display checksum in order to give the JVM no chance to optimize out the contents of the run() method and possibly even thread creation
for (int a : aa) {
checkSum += a;
}
System.out.println("Checksum: "+checkSum);
System.out.println("Total time: "+totalTime*1E-6+" ms");
System.out.println();
return totalTime;
}
public static void main(String[] kr) throws InterruptedException {
int workAmount = 100000000;
int[] threadCount = new int[]{1, 2, 10, 100, 1000, 10000, 100000};
int trialCount = 2;
long[][] time = new long[threadCount.length][trialCount];
for (int j = 0; j < trialCount; j++) {
for (int i = 0; i < threadCount.length; i++) {
time[i][j] = test(threadCount[i], workAmount/threadCount[i]); 
}
}
System.out.print("Number of threads ");
for (long t : threadCount) {
System.out.print("\t"+t);
}
System.out.println();
for (int j = 0; j < trialCount; j++) {
System.out.print((j+1)+". trial time (ms)");
for (int i = 0; i < threadCount.length; i++) {
System.out.print("\t"+Math.round(time[i][j]*1E-6));
}
System.out.println();
}
}
}

Les résultats sur une version 64 bits de Windows 7 32-bit Java de Sun 1.6.0_21 Client VM sur un Intel Core 2 Duo E6400 @2.13 GHz sont comme suit:

Number of threads  1    2    10   100  1000 10000 100000
1. trial time (ms) 346  181  179  191  286  1229  11308
2. trial time (ms) 346  181  187  189  281  1224  10651

Conclusions: les Deux fils à faire le travail presque deux fois plus rapide qu'un, comme prévu depuis mon ordinateur est doté de deux cœurs. Mon ordinateur peut se reproduire près de 10000 threads par seconde, j'. e. de création de thread frais généraux est de 0,1 millisecondes. Donc, sur une telle machine, un couple de centaines de nouveaux threads par seconde pose négligeable, les frais généraux (comme on peut aussi le voir en comparant les chiffres dans les colonnes 2 et 100 threads).

• pour votre référence, vous pouvez utiliser JMeter + un profiler, ce qui devrait vous donner une vue globale sur le comportement dans ces lourds chargé de l'environnement. Juste le laisser fonctionner pendant une heure et surveiller la mémoire, cpu, etc. Si rien ne se brise et que le cpu(s) n'a pas de surchauffe, c'est ok 🙂

• peut-être vous pouvez obtenir un thread pool, ou personnaliser (étendre) celui que vous utilisez en ajoutant un peu de code pour avoir les InheritableThreadLocals définir à chaque fois qu'un Thread est acquise à partir du fil de la piscine.
  Chaque Thread a ces colis-privé propriétés:

  /* ThreadLocal values pertaining to this thread. This map is maintained
  * by the ThreadLocal class. */
  ThreadLocal.ThreadLocalMap threadLocals = null;
  /*
  * InheritableThreadLocal values pertaining to this thread. This map is
  * maintained by the InheritableThreadLocal class.  
  */ 
  ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

  Vous pouvez utiliser ces (eh bien, avec la réflexion), en combinaison avec la Thread.currentThread() d'avoir le comportement souhaité. Cependant, c'est un peu ad-jarret, et en outre, je ne peux pas dire si elle (la réflexion) ne pas introduire encore plus de frais généraux que de créer les threads.