Why Thread execution is giving different output?

Question

I was trying to test/learn a few basic things in threading(Java) and came across a simple but confusing output. Following are my classes

public class CopyMaster implements Runnable{

    @Override
    public void run() {
        System.out.println("Run called from Copy Master for thread "+Thread.currentThread().getName());
    }

}

Main Class from where I am invoking threads

public class Main {

    public static void main(String[] args) {
        Thread[] threadArray = new Thread[4];
        for(int i=0; i<threadArray.length; i++){
            threadArray[i] = new Thread(new CopyMaster());
        }
        for(Thread t : threadArray){
            //[Line of intrest]System.out.println("Starting Thread "+t.getName());
            t.start();
        }
    }
}

OP(With Line of Interest un-commented)

Starting Thread Thread-0
Starting Thread Thread-1
Run called from Copy Master for thread Thread-0
Starting Thread Thread-2
Run called from Copy Master for thread Thread-1
Starting Thread Thread-3
Run called from Copy Master for thread Thread-2
Run called from Copy Master for thread Thread-3

OP(With Line of Interest commented)

Run called from Copy Master for thread Thread-2
Run called from Copy Master for thread Thread-3
Run called from Copy Master for thread Thread-0
Run called from Copy Master for thread Thread-1

I have tried running the code multiple times and observed that the sequence of print-outs are random in commented line of interest and in un-commented one its proper(in sequence)...

Why is it behaving like that?//EDITED as this confuses what i want to mean

EDIT:

I understand that threads behaves unpredictably but my main question is why it maintains oredr ALWAYS in one case and why random behavior is there in other case?

Answer 1

This is precisely the behaviour of multithreading in Java, unpredictable.

for(Thread t : threadArray){
 //[Line of intrest]System.out.println("Starting Thread "+t.getName()); 

the above line runs in main thread --> so output is always in order (though other output lines can come in between)

t.start(); 

The above line starts each thread (prepares thread for execution, but the run method might not be called immediately). Nobody can predict which thread's run() will execute first. It is totally left to the JVM and underlying OS. }

If you want the output to be ordered, use join() to wait until other thread terminates.

EDIT :

OP(With Line of Interest un-commented)

Starting Thread Thread-0    --> executed in main thread --> 0--> in order
Starting Thread Thread-1   --> main thread --> 1 --> in order
Run called from Copy Master for thread Thread-0 --> executed in thread-0.
Starting Thread Thread-2    --> executed in main. --> 2 -> in order
Run called from Copy Master for thread Thread-1 --> executed in thread-1
Starting Thread Thread-3 --> main --> 3 --> in order
Run called from Copy Master for thread Thread-2 -->executed in thread-2.
Run called from Copy Master for thread Thread-3 --> executed in thread-3.

Note : Starting Thread Thread-0 is printed in the main thread. So, the next line thread.start() might not even have been executed. The logs are misleading.

The below lines actually suggest how threads ran. These logs aren't misleading.

OP(With Line of Interest commented)

Run called from Copy Master for thread Thread-2
Run called from Copy Master for thread Thread-3
Run called from Copy Master for thread Thread-0
Run called from Copy Master for thread Thread-1

Answer 2

Thread interleaving is not random (in the sense of a uniform random number generator), but unpredictable.

In this particular case, the sequential execution if the main thread prints is probably caused by all involved threads writing to System.out, whose methods are synchronized. Therefore, only one thread can write to the console at any given time (which is why we see interleaving of lines rather than individual characters), while the other threads wanting to print wait in a queue until the other thread has exit the monitor. Apparently, the JVM implementation you use ensures that the threads enter the monitor in the same order the have entered that queue, which being the first action in the worker threads, happens very soon after they have started, and therefore in the same order.

Put differently, in this particular program, the heavy lock contention, on this particular JVM implementation, on this operating system, causes the threads to executed in a particular order with high probability. On other JVM implementations, other operating systems, or even slightly modified programs, the behavior may be totally different. Therefore, you should not assume a particular order, even if your tests never observe a different ordering.

Answer 3

Its because there is no guarantee that a thread runs immediately after it starts in your case. You have to synchronize it explictly.

Look at Why is run() not immediately called when start() called on a thread object in java

Answer 4

Sometimes thread can produce different output. This is because we don't know which thread is running at which moment in time. It is based on JVM so it is unpredictable.