Nombre maximal de threads dans une JVM?

Il y aura des limites imposées par votre système d'exploitation et la configuration du matériel.

Pour augmenter le nombre de threads simultanés vous devriez baisser la valeur par défaut stacksize java -Xss 64k.

• Un Oracle 32 bits JVM va par défaut à 320kb taille de la pile par thread.
  • Pour une JVM 32 bits avec 2 go de mémoire adressable cela vous donnera un maximum de 6,5 k-threads.
• Un Oracle 64 bits JVM va par défaut à 1M taille de la pile par thread.
  • Pour chaque gigaoctet de mémoire, vous obtiendrez 1024 threads en utilisant les valeurs par défaut.
• Pour Linux uniquement:
  • ulimit -a va vous donner la configuration de la limite, pour l'utilisateur, les processus et la mémoire
  • Vous obtenez seulement 32k unique PIDs dans linux cat /proc/sys/kernel/pid_max - un maximum de 32 ko processus.
  • Vous obtiendrez seulement 255 k enregistrés fils cat /proc/sys/kernel/threads-max

OriginalL'auteur flob

La vraie question devrait être pas le nombre de threads que vous pouvez créer, mais combien de threads de s'exécuter efficacement. Trop de threads et vous causer de la raclée, trop peu et de moins en moins de temps de calcul.

D'abord, la question, combien de temps à vivre est votre fil. Bref vivre threads sont à peine en vaut la chandelle. De gros calculs d'autre part tout à fait logique.

Seconde, la quantité de mémoire chaque thread consommer. Prendre la quantité de mémoire chaque thread demande et divisé par la quantité de mémoire disponible. Vous ne devez pas créer plus de threads que de ce.

Troisièmement, combien de Processeurs disponibles. Vous ne devez pas créer plus de threads que de Processeurs. En effet, il faut tenir compte d'au moins un de moins que le nombre de threads. Sur un ordinateur portable windows avec 4 Processeurs, vous ne devriez jamais avoir plus de 3 filets si l'efficacité du traitement est nécessaire.

Enfin, quel est votre fil. Si il lit et écrit sur un disque dur, alors vous pouvez avoir plus de threads que le nombre de Processeurs, car il faudra attendre le périphérique de répondre. Considérons la méthode suivante au moment de décider le nombre de threads:

public static int recommendedThreadCount()
{
    int mRtnValue = 0;
    Runtime runtime = Runtime.getRuntime();
    long maxMemory = runtime.maxMemory();
    long mTotalMemory = runtime.totalMemory();
    long freeMemory = runtime.freeMemory();
    int mAvailableProcessors = runtime.availableProcessors();

    long mTotalFreeMemory = freeMemory + (maxMemory - mTotalMemory);
    mRtnValue = (int)(mTotalFreeMemory/4200000000l);

    int mNoOfThreads = mAvailableProcessors-1;
    if(mNoOfThreads < mRtnValue) mRtnValue = mNoOfThreads;

    return mRtnValue;
}

OriginalL'auteur ray

Maximum limite de thread dépend principalement du matériel, de l'OS et Java taille de la pile.

Le facteur suivant joue un rôle très important pour identifier max limite de thread:-

1. Adresse virtuelle du processus limite (2^32 pour 32-bit architecture et 2^64 pour 64-bit architecture)
2. Java taille de la pile (peut être déterminer par la commande java -XX:+PrintFlagsFinal -version | grep -iE 'ThreadStackSize'
3. Max PID limite (peut être déterminer par la commande "cat /proc/sys/kernel/pid_max")
4. Max limite de processus ulimit -u

Donc max de thread limite MINIMUM de ((processus de l'espace d'adressage virtuel/java taille de la pile), Max PID limite, Max limite de processus)

par exemple, si Max processus limite est 2048 et c'est le minimum de tous les ci-dessus mentionné trois-facteur processus java ne sera pas en mesure de créer un thread de plus.

Pour le vérifier, on peut créer de la simple application java dans lequel il/elle peut créer un thread dans une boucle et de voir combien il peut aller.

Exemple:

---

private static Object lock = new Object();
private static int counter = 0;

public static void main(String[] _args) {
 while (true) {
  new Thread(new Runnable() {
   public void run() {
    synchronized(lock) {
     counter += 1;
     System.err.println("New thread #" + counter);
    }
    while (true) {
     try {
      Thread.sleep(3000);
     } catch (Exception _e) {
      _e.printStackTrace();
     }
    }
   }
  }).start();
 }
}
}

OriginalL'auteur Rahul Sharma