Java Threadpool size and availableProcessors()

问题:

I have a program which runs (all day) tasks in parallel (no I/O in the task to be executed) so I have used Executors.newFixedThreadPool(poolSize) to implement it.

Initially I set the poolSize to Runtime.getRuntime().availableProcessors(), but I was a bit worried to use all the available cores since there are other processes running on the same PC (32 cores).

In particular I have ten other JVM running the same program (on different input data), so I'm a bit worried that there might be a lot of overhead in terms of threads switching amongst the available cores, which could slow down the overall calculations.

How shall I decide the size of the pool for each program / JVM?

Also, in my PC, there are other processes running all the time (Antivirus, Backup, etc.). Shall I take into account these as well?

回答1:

Any advice is going to be dependent upon your particular circumstances. 10 JVMs on 32 cores would suggest 3 threads each (ignoring garbage collection threads, timer tasks etc...)

You also have other tasks running. The scheduler will ensure they're running, but do they have to be responsive ? More responsive than the JVM ? If you're running Linux/Unix then you can also make use of prioritisation (via nice) to ensure particular processes don't hog the CPU.

Finally you're running 10 JVMs. Will that cause paging ? If so, that will be slow and you may be better off running fewer JVMs in order to avoid consuming so much memory.

Just make sure that your key variables are exposed and configurable, and measure various scenarios in order to find the optimal one.

回答2:

How shall I decide the size of the pool for each program / JVM?

You want the number of threads which will get you close to 99% utilisation and no more.

The simplest way to balance the work is to have the process running once, processing multiple files at concurrently and using just one thread pool. You can set up you process as a service if you need to start files via the command line.

If this is impossible for some reason, you will need to guesstimate how much the thread pools should be shrunk by. Try running one process and look at the utilisation. If one is say 40% then I suspect ten processes is over utilised by 400%. i.e then you might reduce the pool size by a factor of 4.

回答3:

Unfortunately, this is a hard thing to know, as programs don't typically know what else is or might be going on on the same box.

the "easy" way out is to make the pool size configurable. this allows the user who controls the program/box to decide how many threads to allocate to your program (presumably using their knowledge of the general workload of the box).

a more complex solution would be to attempt to programmatically determine the current workload of the box and choose the pool size appropriately from that. the efficacy of this solution depends on how accurately you can determine the workload and potentially adapt as it changes over time.

回答4:

Try grepping the processes, check top/task manager and performance monitors to verify if this implementation is actually affecting your machine.

This article seems to contain interesting info about what you are trying to implement: http://www.ibm.com/developerworks/library/j-jtp0730/index.html