Java: Why is the main-thread not progressing?

Question

I ran into some problems with a multi-threaded Java-program and distilled it down to a very simple example - still my puzzlement isn't less!

The example program it shown below. So what does this do (or was intended to do)?. Well, the main() function starts off a simple thread, based on a static, inner class Runnable. This Runnable contains two nested loops, that does a simple calculation on a local variable "z" for a total of 10^12 iterations (10^6 * 10^6), after which it will print out the result and exit. After spawning this worker thread, the main thread goes into a loop of its own where it prints the string "Z" to the console after which it sleeps (using Thread.sleep()) for 1 second, then repeats this over and over.

So running this program, I would expect it to print out "Z" every 1 second while the calculating thread was doing its job.

However, in fact what happens is that the calculating thread is started, and the main thread displays the first "Z" but then nothing happens. It appears to hang in the Thread.sleep call, either infinitely or at least much, much longer than the requested 1000 ms.

Note that this is on a fast, quad-core machine with multi-threading, so there should be no trouble in running the threads simultaneously. The other cores appear as idle in Windows task manager. Also, even on a single-core system I would expect the operating system to periodically preempt the calculating thread, in order to allow the main-thread to print the strings. Further, there's no shared variables or lock between the threads, so they shouldn't be able to block each other.

Even more strangely, it appears to be critical for the behavior, that there are two nested loops in the Runnable. With just one loop, with the same number of iterations, everything works as expected.

I've tested this on Windows 10 64-bit with Java 1.8.0_73.

Can someone explain this behavior?

public class Calculate {
    static class Calc implements Runnable
    {
        @Override
        public void run() {
            int z = 1;
            for(int i = 0; i < 1000000; i++) {      
                for(int j = 0; j < 1000000; j++) {
                    z = 3*z + 1;
                }               
            }
            System.out.println("Result: " + z);
        }
    }

    public static void main(String[] args)  throws Exception
    {
        Thread t = new Thread(new Calc());
        t.start();
        while(true) {
            System.out.println("Z");
            Thread.sleep(1000);
        }
    }
}

Update 1: It has been suggested that this might be a duplicate of Busy loop in other thread delays EDT processing. Many symptoms in my case are the same, but it is hard to tell if they truly are the same cause, because the other problem doesn't appear to have been fully diagnosed. But it is a likely possibility.

Update 2: I have filed a bug report with Oracle. I will post link if it is accepted and I find it.

Update 3: Accepted as bug in Java 8 and 9: https://bugs.openjdk.java.net/browse/JDK-8152267

Answer 1

Seems like your program overflow my machine I also only get Z once (Os x, i7, 16G).

Edit : What you could do to be sure to give a chance to the main Thread to print "z" is yield every time you loop over i :

@Override
public void run() {
    int z = 1;
    for(int i = 0; i < 1000000; i++) {    
        Thread.yield();
        for(int j = 0; j < 1000000; j++) {
            z = 3*z + 1;
        }               
    }
    System.out.println("Result: " + z);
}

Answer 2

As I have put in in "update 3" in the description, this turned out to be a bug in Java 8 and 9. So this is the correct answer to this question: There is nothing wrong with the program, the behavior is caused by bugs in certain versions of Java, causing it to not behave as it should. While suggestions of inserting pauses, yields etc. in the program might be relevant for someone looking for a practical workaround, the "lack of these workarounds" is not the root cause of the problem and do not represent an error in the original program.

Answer 3

Short answer

It is a problem of CPU allocation. To solve it, add the line Thread.currentThread().yield(); after the for (int j=0 ...) loop.

Long answer

I used the following modified program to find the problem

public class Calculate {

    public static final int[] LOOP_SIZES = {
        1000, 5000, 10000, 50000, 65000, 66000, 100000, 500000, 1000000 };

    static class Calc implements Runnable
    {
        private int loopSize;
        public Calc(int loopsize) {
            loopSize = loopsize;
        }
        @Override
        public void run() {
            int z = 1;
            final long startMillis = System.currentTimeMillis();
            for(int i = 0; i < loopSize; i++) {
                for(int j = 0; j < loopSize; j++) {
                    z = 3*z + 1;
                }
                Thread.currentThread().yield();  // comment this line to reproduce problem                                         
            }
            final long endMillis = System.currentTimeMillis();
            final double duration = ((double)( endMillis - startMillis )) / 1000.0;
            System.out.println("Result for " + loopSize +
                               ": " + z +
                               " @ " + duration + " sec");
        }
    }

    public static void main(String[] args)  throws Exception
    {
        Thread tt[] = new Thread[LOOP_SIZES.length];
        for (int i = 0; i < LOOP_SIZES.length; i++) {
            final int ls = LOOP_SIZES[i];
            tt[i] = new Thread(new Calc(ls));
            tt[i].start();
        }
        int nbNonTerminated = 1;
        while(nbNonTerminated > 0) {
            nbNonTerminated = 0;
            for (int j=0; j < tt.length; j++)  {
                printThreadState( tt[j], "Thread " + j );
                if (!tt[j].getState().equals(java.lang.Thread.State.TERMINATED))
                    nbNonTerminated ++;
            }
            printThreadState( Thread.currentThread(), "Main thread");
            System.out.println("Z @ " + System.currentTimeMillis());
            Thread.sleep(1000);
        }
    }

    public static void printThreadState( Thread t, String title ){
        System.out.println( title + ": " + t.getState() );
    }
}

If you run this program, the main thread works as intended (it prints a message every second). If you comment the line with the yield, recompile and run it, the main loop prints a few messages, then blocks. It seems like the JVM allocates almost all CPU to the other threads, rendering the main thread unresponsive.

The number of threads did not seem to change the problem. The problem started to appear when the "loop size" became larger than about 65000. Also, note I did not join threads when they finish.

note: tested on Mac OSX, 2.7.5, 2.5 GHz Core i5.
I also tested it on a Raspberry Pi 2, Raspbian linux 4.1.3 (a much less powerful machine): the problem does not show.

Answer 4

Inside the run method you have no loop, just a simple calculation of z. Thus when you call t.start(); the run method is called once, calculates the z and then you just put the thread to sleep forever.