Low Java limite das roscas único processo no Red Hat Linux

Question

Eu estou enfrentando um problema em uma máquina de teste de corrida Red Hat Linux (versão do kernel é 2.4.21-37.ELsmp) usando Java 1.6 (1.6.0_02 ou 1.6.0_04). O problema é, uma vez que um certo número de tópicos são criados em um único grupo de discussão, o sistema operacional não quer ou não para criar mais.

Este parece ser específica para tópicos Java criando, como o programa C thread-limite era capaz de criar cerca de 1.5k tópicos. Além disso, isso não acontece com um Java 1.4 JVM ... ele pode criar mais de 1.4k tópicos, embora eles são, obviamente, ser tratados de forma diferente em relação ao OS.

Neste caso, o número de threads que está cortando a é de apenas 29 threads. Esta é testável com um simples programa Java que apenas cria tópicos até que ele recebe um erro e, em seguida, imprime o número de tópicos que criou. O erro é um

java.lang.OutOfMemoryError: unable to create new native thread

Este parece ser afetado por coisas tais como o número de threads em uso por outros processos ou usuários ou a quantidade total de memória do sistema está usando no momento. Definições de JVM como Xms, Xmx e Xss parecem não mudar nada ou (o que é esperado, considerando o problema parece estar com criação de thread OS nativo).

A saída do "ulimit -a" é a seguinte:

core file size        (blocks, -c) 0
data seg size         (kbytes, -d) unlimited
file size             (blocks, -f) unlimited
max locked memory     (kbytes, -l) 4
max memory size       (kbytes, -m) unlimited
open files                    (-n) 1024
pipe size          (512 bytes, -p) 8
stack size            (kbytes, -s) 10240
cpu time             (seconds, -t) unlimited
max user processes            (-u) 7168
virtual memory        (kbytes, -v) unlimited

O limite de processo de usuário não parece ser o problema. Busca de informações sobre o que poderia ser errado não apareceu muito, mas este post parece indicar que pelo menos alguns kernels Red Hat limitar um processo a 300 MB de memória alocada para a pilha, e em 10 MB por segmento de pilha, parece que a questão poderia estar lá (embora pareça estranho e improvável quanto bem).

Eu tentei mudar o tamanho da pilha com "ulimit -s" para testar isso, mas qualquer valor diferente de 10240 e que a JVM não começar com um erro de:

Error occurred during initialization of VM
Cannot create VM thread. Out of system resources.

Eu geralmente pode contornar Linux, mas eu realmente não sei muito sobre a configuração do sistema, e eu não tenho sido capaz de encontrar qualquer coisa especificamente abordar este tipo de situação. Algumas ideias sobre o que as configurações do sistema ou JVM poderia estar causando isso seria apreciada.

Edições : Executar o programa thread-limite mencionada por plinto , não houve falha até que tentou criar o segmento 1529.

O problema também não ocorrer usando um 1.4 JVM (ocorre com 1.6.0_02 e 1.6.0_04 JVMs, não pode teste com um 1.5 JVM no momento).

O código para o teste de rosca que estou usando é a seguinte:

public class ThreadTest {

   public static void main(String[] pArgs) throws Exception {

      try {
         // keep spawning new threads forever
         while (true) {
            new TestThread().start();
         }
      }
      // when out of memory error is reached, print out the number of
      // successful threads spawned and exit
      catch ( OutOfMemoryError e ) {
         System.out.println(TestThread.CREATE_COUNT);
         System.exit(-1);
      }
   }

   static class TestThread extends Thread {
      private static int CREATE_COUNT = 0;
      public TestThread() {
         CREATE_COUNT++;
      }
      // make the thread wait for eternity after being spawned
      public void run() {
         try {
            sleep(Integer.MAX_VALUE);
         }
         // even if there is an interruption, dont do anything
         catch (InterruptedException e) {
         }
      }
   }
}

Se você executar este com um 1.4 JVM que irá pendurar quando ele não pode criar mais threads e exigem um kill -9 (pelo menos ele fez por mim).

Mais Edit:

Acontece que o sistema que está a ter o problema está usando as LinuxThreads modelo de segmentação enquanto outro sistema que funciona bem é usando o modelo NPTL.

Answer 1

A atualização do kernel para uma versão mais recente (2.6.something) com NPTL threading fixo isso.

Answer 2

Você já olhou para este recurso ? Ele afirma que você deve ser capaz de execução thread-limite para encontrar o número máximo de threads e pode ajustá-lo através da compilação de glibc.

Answer 3

Este é com Ubuntu Linux (1GB RAM)

dsm@localhost:~$ javac ThreadTest.java 
dsm@localhost:~$ java ThreadTest 
8113
dsm@localhost:~$ java -version
java version "1.6.0_07"
Java(TM) SE Runtime Environment (build 1.6.0_07-b06)
Java HotSpot(TM) Client VM (build 10.0-b23, mixed mode, sharing)
dsm@localhost:~$ 

Answer 4

Você pode experimentá-lo com o JRockit JVM? IIRC, ele tinha um modelo de segmentação diferente do que o estoque Sun JVM.

Answer 5

As configurações /etc/security/limits.d/90-nproc.conf pode ser substituindo suas configurações /etc/security/limits.conf. Isso pode fazer com que a legislação sobre o sistema de uma maneira diferente mostrado na ulimit -u.

https://bugzilla.redhat.com/show_bug.cgi?id=823030