Can't get past 2542 Threads in Java on 4GB iMac OSX 10.6.3 Snow Leopard (32bit)

Question

I am running the following program trying to figure out how to configure my JVM to get the maximum number of threads my machine can support. For those that might not know, S

Answer 1

You need to find out the maximum number of threads the operating system supports on your system.

On linux you can do something like :

cat /proc/sys/kernel/threads-max

to get the max, and to set it you can do something like :

echo 10000 > /proc/sys/kernel/threads-max

Also try running with :

-XX:-UseBoundThreads

and report back the results.

Answer 2

According to the Apple Developer doc the thread stack size should be at least 64K, so your -Xss 1014 is ignored. But even with 64K per thread, the thread stack memory consumption comes only to about 160MB, so this shouldn't be the problem. Threads could also consume memory from a more limited pool, or there could simply be limit on the number of thread you can have per process or user.

Answer 3

2542 seems like an arbitrary number:

I shut all programs down except the one terminal window I was running my test from and I got to 2545, that told me it was an arbitrary limit.

To get the number of threads for OSX 10.6.3 you do:

> sysctl kern.num_threads
kern.num_threads: 2560

and

> sysctl kern.num_taskthreads
kern.num_taskthreads: 2560

The 2560 number matches up with the 2542 and 2545 because there are obviously other threads running in the background. According to the official documentation kern.num_taskthreads can not be adjusted in the desktop version of OSX.

Answer 4

Do you think you will have these much thread concurrently up to 1 hour? I don't think so. I have worked in application which processed hundreds of documents, convert them from and to diff. format, generates proper logs in DB and stores specific info also. Then also it finished in seconds.

The thing you should take care about it, code wisely to avoid making too much threads. Instead use a ThreadPool provided by Java, so that same threads can be utilized when needed. that will provide better performance. Also keep synchronization on minimal blocks to avoid bottle necks in your execution.

thanks.