An operating system executes multiple processes in a manner similar
to that for multi-threading, except that
each process stack refers to a different program in memory rather
than code within a single program. The Java Virtual Machine (JVM),
of course, controls the threading within the Java programs, just
as the machine OS controls multiple processes.
In some JVM designs, threads can be assigned to native kernel processes
in the OS. Furthermore, for operating systems such as Solaris and
Windows NT that can control multiple processors, the threads can
actually run on different processors and thus provide true parallel
Whether its for multithreading or multiprocessing, the two basic
designs for this context switching, i.e. the shifting of threads/processes
in and out of a processor, include
- preemptive or time-slicing - give each thread
a fixed amount of time.
- non-preemptive or cooperative - a thread decides
itself when to surrender control
Generally, the preemptive approach is the most flexible and robust.
A misbehaving thread cannot hog all the resources or hang the processor.
Unfortunately, the context switching is not specified for Java and
so different JVM implementations do it differently. Thus you should
design your multi-threaded code for either possibility if you want
it to be suitable for broad distribution. This means adding yield()or
calls to release control at suitable points in the thread code.
Latest update: Nov. 8, 2004