Implementations of Java may have radically different behavior when it comes to scheduling.
The Windows XP/98/NT/2000 versions work, more or less, as you would expect. However,
other versions may work quite differently. Most of the inconsistencies arise when you have
threads that are relying on preemptive behavior, instead of cooperatively giving up CPU
time. The safest way to obtain predictable, cross-platform behavior with Java is to use threads
that voluntarily give up control of the CPU.
The following example demonstrates two threads at different priorities, which do not
run on a preemptive platform in the same way as they run on a nonpreemptive platform.
One thread is set two levels above the normal priority, as defined by Thread.NORM_
PRIORITY, and the other is set to two levels below it. The threads are started and allowed
to run for ten seconds. Each thread executes a loop, counting the number of iterations. After
ten seconds, the main thread stops both threads. The number of times that each thread made
it through the loop is then displayed.
// Demonstrate thread priorities.
class clicker implements Runnable {
long click = 0;
Thread t;
private volatile boolean running = true;
public clicker(int p) {
t = new Thread(this);
t.setPriority(p);
}
public void run() {
while (running) {
click++;
}
}
public void stop() {
running = false;
}
public void start() {
t.start();
}
}
class HiLoPri {
public static void main(String args[]) {
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
clicker hi = new clicker(Thread.NORM_PRIORITY + 2);
clicker lo = new clicker(Thread.NORM_PRIORITY - 2);
lo.start();
hi.start();
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
System.out.println("Main thread interrupted.");
}
Search WWH :
