Why thread with lower priority get longer CPU time than thread with higher priority in this code

Question

I'm reading Threads from Java The complete Reference - Herbert Schildt (TATA McGRAW HILL). And in this example form book, Thread with lower priority should give lower value of clicks than Thread with higher priority. But what i got

low-priority thread 3000255895
hi-priority thread  2857361716

according to book it is something like this (difference)

low-priority thread 4408112
hi-priority thread  589626904

code

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 Priority {
    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); 
        hi.start();
        lo.start();
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            System.out.println("main thread interrupted");
        }

        lo.stop();
        hi.stop();

        try {
            hi.t.join();
            lo.t.join();
        } catch (InterruptedException e) {
            System.out.println("interrupted exception catched in main");
        }

        System.out.println("low-priority thread " + lo.click);
        System.out.println("hi-priority thread " + hi.click);
    }
}

I'm on Intel® Core™ i3-2310M CPU @ 2.10GHz × 4 with Ubuntu 13.04

with Thread.sleep(50000);

low-priority thread 14849893875
hi-priority thread 14224080358

Is it not a big difference

I also try with priority HI = 10 and LOw = 1, But result nearly same.

UPDATE: After running with 100 threads 50 with priority = 1 and 50 with priority = 10 result is

here time = clicks values

high = 82 time = 110117529
low =  83 time = 102549208
high = 84 time = 110905795
low =  85 time = 99100530
high = 86 time = 105012756
low =  87 time = 110195297
high = 88 time = 102820088
low =  89 time = 97814606
high = 90 time = 99990839
low =  91 time = 102326356
high = 92 time = 98656119
low =  93 time = 98127243
high = 94 time = 97097823
low =  95 time = 103604394
high = 96 time = 93632744
low =  97 time = 99032550
high = 98 time = 103879116
low =  99 time = 97179029

With 1000 Threads Take 4-5 min. to complete, all 4 cores at 100%

low =  977 time = 23593983
high = 978 time = 23998970
low =  979 time = 23879458
high = 980 time = 22775297
low =  981 time = 21297504
high = 982 time = 22464600
low =  983 time = 20301501
high = 984 time = 19073992
low =  985 time = 19450707
high = 986 time = 19317769
low =  987 time = 18454648
high = 988 time = 17901939
low =  989 time = 16976661
high = 990 time = 17360728
low =  991 time = 16813824
high = 992 time = 15531501
low =  993 time = 14659965
high = 994 time = 12833364
low =  995 time = 13708670
high = 996 time = 13348568
low =  997 time = 12947993
high = 998 time = 12749436
low =  999 time = 9804643

Unpredictable output for each thread.

Answer 1

Apart from Thread priorities being a gray area under most implementations and platforms, other things you could look into are :

1. In all probability, click is not going to contain the exact number of invocations. This should have been an AtomicLong. So how large do you want the difference to be ? +-2 isn't a big difference either.

2. Run one thread with MIN_PRIORITY and other thread with MAX_PRIORITY. Calculate the difference. Repeat the above experiment with 10, 100, 1000 threads. 50% of them with MIN_PRIORITY and other 50% with MAX_PRIORITY. Your results if you post will be surely enlightening

Edit Interesting, let me submit my sample program. I am under OpenJDK6 and the thread priorities :MIN_PRIORITY and MAX_PRIORITY doesn't seem to matter much. The number of clicks with the high level thread is slightly more than the number of clicks with low priority thread.

import java.util.concurrent.atomic.AtomicLong;


class Clicker implements Runnable {
    AtomicLong click = new AtomicLong();
    Thread t;
    private volatile boolean running = true;

    public Clicker (int p) {
        t  = new Thread(this);
        t.setPriority(p);
    }

    public void run() {
        while(running) {
            click.incrementAndGet();
            longOP();
        }
    }

    private void longOP() {
        outer:
        for (int i = 2; i <= 10000 && running; i++) {
            final int NUM = i;
            for (int j = 2; j * j <= NUM && running; j++) {
                if (NUM % j == 0) {
                    continue outer;
                }
            }
            System.out.print("[" + NUM + "],");
        }
        System.out.println();
        for (int i = -90; i <= 90 && running; i++) {
            double rad = Math.toRadians(i);
            double value = Math.sqrt(Math.abs(Math.pow(Math.PI * Math.sin(rad), 10.0))) + Math.tan(rad) * Math.cos(rad); //lol
            System.out.print("[" + i + " " + value + "],");
        }

    }

    public void stop() {
        running = false;
    }

    public void start() {
        t.start();
    }
}

public class Priority {
    public static void main(String args[]) {
        Thread.currentThread().setPriority(Thread.MAX_PRIORITY);

        final int MAX_THREADS = 1000;
        final long MAX_RUN_TIME = 60 * 1000; //millis

        Clicker clickHi[] = new Clicker[MAX_THREADS];
        Clicker clickLow[] = new Clicker[MAX_THREADS];
        for (int i = 0; i < MAX_THREADS; ++i) {
            clickHi[i] = new Clicker(Thread.MAX_PRIORITY);
            clickLow[i] = new Clicker(Thread.MIN_PRIORITY); 

            clickHi[i].start();
            clickLow[i].start();
        }


        try {
            Thread.sleep(MAX_RUN_TIME);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("main thread interrupted");
        }

        for (int i = 0; i < MAX_THREADS; ++i) {
            clickHi[i].stop();
            clickLow[i].stop();
        }

        for (int i = 0; i < MAX_THREADS; ++i) {
            try {
                clickHi[i].t.join();
                clickLow[i].t.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("interrupted exception catched in main");
            }
        }

        long totalLowClicks = 0, totalHighClicks = 0;
        for (int i = 0; i < MAX_THREADS; ++i) {
            totalLowClicks += clickLow[i].click.longValue();
            totalHighClicks += clickHi[i].click.longValue();

            System.out.println("low-priority thread " + clickLow[i].click);
            System.out.println("hi-priority thread " + clickHi[i].click);
        }

        System.out.println("Sum of LOW clicks : " + totalLowClicks);
        System.out.println("Sum of HI  clicks : " + totalHighClicks);
    }
}

The above program is cpu intensive. You may encounter Out Of Memory Errors. But just for fun, post your result.

Answer 2

I suspect the example figures will be somewhat dependent upon both your platform and the author's (does the example run upon a single core?). The JVM thread prioritisation is OS/platform-specific. From this interesting document

Linux priorities

Under Linux, you have to go through more hoops to get thread priorities to function at all, although in the end, they may be more useful than under Windows. In Linux:

• thread priorities only work as of Java 6 onwards;
• for them to work, you must be running as root (or with root privileges via setuid);
• the JVM parameter -XX:UseThreadPriorities must be included

So check your Java version, your Java invocation and your privileges. I suspect (!) you only satisfy one of those criteria (your Java/JVM version).