Why does java Thread execute after the independent code?

I am new to java and learning multi-threading. I wrote the following code.

class BackgroundTask implements Runnable {
	private int counter = 0;

	public int getCounter() {
		return counter;
	}

	public void setCounter(int counter) {
		this.counter = counter;
	}

	@Override
	public void run() {
		System.out.println("Thread started");
		while (true) {
			this.setCounter(this.getCounter() + 1);
		}
	}

}

public class Main {

	public static void main(String[] args) {

		BackgroundTask bgTask = new BackgroundTask();

		Thread bgCount = new Thread(bgTask);

		try {
			
			bgCount.start();
			System.out.println("counter in background is running");
			
			bgCount.interrupt();
			System.out.println(bgTask.getCounter());

		} catch (Exception e) {
			System.out.println(e.getMessage());
		}

	}
}

Output of the code:

counter in background is running
0
Thread started

Q.1 why is bgCount.start() executing after the print statement when it is written before it?

Q.2 Why did the thread start after calling the getCounter() method?

Edit: Thanks everyone for all the cool answers, now I understand the concept of threads.

When you do things in two different threads, they are unsynchronized unless you force some kind of synchronization. One thread might execute first or the other thread might or they might interleave in unpredictable ways. That's kind of the point of threads.

Explanation

> Q.1 why is bgCount.start() executing after the print statement when it is written before it?

It is not, this is an incorrect conclusion. start() is executed exactly when you have written it. It just does not necessarily mean that the thread immediatly starts. The OS scheduler determines when to start a thread. The only guarantee that you get is that it will eventually start, so maybe now, maybe in a hour, maybe next year. Obviously, in practice it will usually be almost instant. But that does not mean it is executed as the very next thing.

> Q.2 Why did the thread start after calling the getCounter() method?
As explained before, the OS scheduler decides. You just had bad luck. Seriously, you have no control over this and should not do any assumptions on this.

Multi-threading

If you have multiple threads and they have a series of operations to execute, the OS scheduler is completely free to decide how to interleave the operations. That also means that not interleaving anything is valid as well.

Lets take a look at an example with thread A and B that have 2 operations to execute each. The following orders of executions are all valid outcomes of the scheduler:

A.1
A.2
B.1
B.2

A.1
B.1
A.2
B.2

A.1
B.1
B.2
A.2

B.1
B.2
A.1
A.2

B.1
A.1
B.2
A.2

B.1
A.1
A.2
B.2

So you must not make any assumptions about when a thread starts and especially not about in which order operations are executed in regards to other threads. It might be fully interleaved, might be sequential, might be partially interleaved, everything could happen.

If you want to take control over the mechanism, the correct tool is synchronization. With that you can tell that you want to wait for a certain thing to happen first in another thread before you continue. A very simple example for your above code would be to wait until bgCount is fully done before continuing to print the count. You can do so by using join():

bgCount.start();
System.out.println("counter in background is running");
        
bgCount.join(); // waiting until down
System.out.println(bgTask.getCounter());

However, if you do it like that, you defeated the purpose of having a thread in the first place. There is no benefit in computing something in-parallel if you completely block the other thread and wait. Then it is basically just like executing something in the ordinary sequential way.