How many threads should/can be run?
Multithreading
will be of no use in single-core systems unless some threads had to
wait for file/network I/O, DB query completions, UI input or they had
to wait for other threads to produce/consume.
This
is because in a single core system, only one thread is active at a
time.
In
a multicore
system,
true parallelism is achievable because there multiple threads will
really run simultaneously. However, there also, the number of
parallel executions depends upon the number of cores. So a quad core
system will run only 8 parallel threads.
Assuming,
threads involve waiting and the system on which they run is
multi-core, what is the maximum number of threads which can run on a
system?
Every
thread is given some specific amount of stack-size to execute (heap
is shared by threads of same process, so that is not a constraint).
That stack-size per thread is configurable and the default is
different in different systems. The default stack-size per thread
varies from 1 MB to 8 MB. If the machine on which the threads are
running is a 32-bit machine, then it can access a memory space of 2^31=2GB.
So,
the maximum no of threads which can be created = 2GB/8MB ~ 256
threads.
If
you try to create more threads than this, then out-of-memory error
will occur.
Mathematically,
number of threads = total virtual memory / (stack size*1024*1024)
On
linux systems, these values can be checked as:
$
ulimit -a
core
file size (blocks, -c) 0
data
seg size (kbytes, -d) unlimited
file
size (blocks, -f) unlimited
max
locked memory (kbytes, -l) unlimited
max
memory size (kbytes, -m) unlimited
open
files (-n) 1024
pipe
size (512 bytes, -p) 8
stack
size (kbytes, -s) 8192
cpu
time (seconds, -t) unlimited
max
user processes (-u) unlimited
virtual
memory (kbytes, -v) unlimited
Changing stack-size
of a thread
1.
“ulimit” command, for example ulimit -s 192 will reduce
the stack size from 8MB to 192kb.
2.
C applications can call pthread_attr_setstacksize().
3.
Java applications can use “-Xss” to set the stack size.
Remember that switching
thread context is quite expensive and so adding threads to a system
does not linearly scale the performance of the system.
Also,
maximum no of threads depends upon the maximum no of open files. As
seen above in the command ‘ulimit -a’, system places a
limit on the max no of open files too. If each of your threads opens
a file, then this limit can also kill the application.
Similar
restrictions may be placed by other systems like maximum no of
connections imposed by a database etc.
|