Join() -Methode und die komplette Java-Referenz 9. Ausgabe

Question

// Using join() to wait for threads to finish. 
class NewThread implements Runnable { 
    String name; // name of thread 
    Thread t; 
    NewThread(String threadname) { 
     name = threadname; 
     t = new Thread(this, name); 
     System.out.println("New thread: " + t); 
     t.start(); // Start the thread 
    } 
    // This is the entry point for thread. 
    public void run() { 
     try { 
      for (int i = 5; i > 0; i--) { 
       System.out.println(name + ": " + i); 
       Thread.sleep(1000); 
      } 
     } catch (InterruptedException e) { 
      System.out.println(name + " interrupted."); 
     } 
     System.out.println(name + " exiting."); 
    } 
} 
class DemoJoin { 
    public static void main(String args[]) { 
     NewThread ob1 = new NewThread("One"); 
     NewThread ob2 = new NewThread("Two"); 
     NewThread ob3 = new NewThread("Three"); 

     System.out.println("Thread One is alive: " + ob1.t.isAlive()); 
     System.out.println("Thread Two is alive: " + ob2.t.isAlive()); 
     System.out.println("Thread Three is alive: " + ob3.t.isAlive()); 
     // wait for threads to finish 
     try { 
      System.out.println("Waiting for threads to finish."); 
      ob1.t.join(); 
      ob2.t.join(); 
      ob3.t.join(); 
     } catch (InterruptedException e) { 
      System.out.println("Main thread Interrupted"); 
     } 
     System.out.println("Thread One is alive: " + ob1.t.isAlive()); 
     System.out.println("Thread Two is alive: " + ob2.t.isAlive()); 
     System.out.println("Thread Three is alive: " + ob3.t.isAlive()); 
     System.out.println("Main thread exiting."); 
    } 
} 

Hallo, da. Ich habe ein Problem mit diesem Code-Frieden aus "The Complete Java Reference - 9. Ausgabe". Ich erhalte immer unterschiedliche Ausgaben, wenn ich diesen Code ausführe. Hier ist das Beispiel:

New thread: Thread[One,5,main] 
New thread: Thread[Two,5,main] 
New thread: Thread[Three,5,main] 
One: 5 
Thread One is alive: true 
Thread Two is alive: true 
Thread Three is alive: true 
Waiting for threads to finish. 
Two: 5 
Three: 5 
One: 4 
Three: 4 
Two: 4 
One: 3 
Two: 3 
Three: 3 
One: 2 
Two: 2 
Three: 2 
One: 1 
Three: 1 
Two: 1 
One exiting. 
Two exiting. 
Three exiting. 
Thread One is alive: false 
Thread Two is alive: false 
Thread Three is alive: false 
Main thread exiting. 

Der Ausgang im Buch ist:

New thread: Thread[One,5,main] 
New thread: Thread[Two,5,main] 
New thread: Thread[Three,5,main] 
Thread One is alive: true 
Thread Two is alive: true 
Thread Three is alive: true 
Waiting for threads to finish. 
One: 5 
Two: 5 
Three: 5 
One: 4 
Two: 4 
Three: 4 
One: 3 
Two: 3 
Three: 3 
One: 2 
Two: 2 
Three: 2 
One: 1 
Two: 1 
Three: 1 
Two exiting. 
Three exiting. 
One exiting. 
Thread One is alive: false 
Thread Two is alive: false 
Thread Three is alive: false 
Main thread exiting. 

Jetzt verstehe ich, wie Threads arbeiten, aber ich verstehe nicht ganz, warum meine neue Themen an der gleichzeitig starten mit meinem Hauptthema. Kann mir jemand dabei helfen? Ty.

EDIT: Sollte der Hauptthread nicht bis join(), sleep() oder einer anderen bekannten Methode ausgeführt werden, und wenn diese Methode "passiert", sollte Thread :: running den nächsten aus der Ready-Queue nehmen ?

EDIT: Dieser Code:

// Create a second thread. 
class NewThread implements Runnable { 
Thread t; 
NewThread() { 
// Create a new, second thread 
t = new Thread(this, "Demo Thread"); 
System.out.println("Child thread: " + t); 
t.start(); // Start the thread 
} 
// This is the entry point for the second thread. 
public void run() { 
try { 
for(int i = 5; i > 0; i--) { 
System.out.println("Child Thread: " + i); 
Thread.sleep(500); 
} 
} catch (InterruptedException e) { 
System.out.println("Child interrupted."); 
} 
System.out.println("Exiting child thread."); 
} 
} 

class ThreadDemo { 
public static void main(String args[ ]) { 
new NewThread(); // create a new thread 
try { 
for(int i = 5; i > 0; i--) { 
System.out.println("Main Thread: " + i); 
Thread.sleep(1000); 
} 
} catch (InterruptedException e) { 
System.out.println("Main thread interrupted."); 
} 
System.out.println("Main thread exiting."); 
} 
} 

funktioniert immer gleich. Woher? Es ist das gleiche Zeug, ist zweite Thread starten() - ed in Konstruktor, aber dieser Code das gleiche Ergebnis jedes Mal: ​​

Child thread: Thread[Demo Thread,5,main] 
Main Thread: 5 
Child Thread: 5 
Child Thread: 4 
Main Thread: 4 
Child Thread: 3 
Child Thread: 2 
Main Thread: 3 
Child Thread: 1 
Exiting child thread. 
Main Thread: 2 
Main Thread: 1 
Main thread exiting. 

Answer 1

Da der neue Thread so schnell laufen beginnt, wie start() genannt wird.

Der Haupt-Thread erstellt den ersten Thread und startet ihn. Es ist jetzt ein Rennen zwischen dem Hauptthread, der die anderen zwei Threads startet und die Wartemeldung gegen den ersten Thread druckt, der seinen Countdown startet.

Wer gewinnt das Rennen? Beliebig und hängt von der Hardware ab.