class Test {
    boolean isFirstThread = true;

    private synchronized void printer(int threadNo) {
        if(isFirstThread) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        isFirstThread = false;
        System.out.println(threadNo);
   }

   public void starter() {
        new Thread(){
            @Override()
            public void run() {
                printer(0);
            }
        }.start();

        new Thread(){
            @Override()
            public void run() {
                printer(1);
            }
        }.start();

        new Thread(){
            @Override()
            public void run() {
                printer(2);
            }
        }.start();

        new Thread(){
            @Override()
            public void run() {
                printer(3);
            }
        }.start();
    }
}

No código acima, quando eu chamo o iniciador do main. Eu criei quatro novos threads para chamar uma função sincronizada. Eu sei que a ordem de execução dos threads não pode ser prevista. A menos que todos esperem algum tempo, para que o primeiro encadeamento possa terminar e sair do bloco sincronizado. Nesse caso, espero que todos os threads sejam mantidos em uma fila, então esperava a resposta como
0
1
2
3
Mas consistentemente (eu executei o programa mais de 20 vezes) eu estava obtendo a saída como
0
3
2
1
O que significa que os encadeamentos estão sendo mantidos em uma pilha em vez de em uma fila. Por que é tão? Todas as respostas no resultado do google dizem que é uma fila, mas estou recebendo como uma pilha. Gostaria de saber o motivo por trás da retenção dos threads na pilha (o que é contra-intuitivo) em vez da fila?