# Thread Scheduler Java 5.0?



## mathiasj (17. Sep 2012)

Hallo,

ich habe das Jaa Buch "Java von Kopf bis Fuß", was von Java 5.0 handelt. Ich hatte gerade Threads, und dort wird beschrieben, dass man nicht vorraussagen kann, wie der Thread Scheduler arbeitet. Als Beispiel wird folgender Code gegeben: 


```
public class ThreadTestLauf {
  
  public static void main(String[] args) {
    
    Runnable threadJob = new MeinRunnable();
    Thread mainThread = new Thread(threadJob);
    
    mainThread.start();
    
    System.out.println("zurück in main");
  }
}

class MeinRunnable implements Runnable {
  
  public void run() {
    los();
  }
  
  public void los() {
    System.out.println("Oben auf dem Stack");
  }
}
```

Und dann sollte laut Buch bei jedem mal Kompilieren eine andere Reihenfolge entstehen(Also es hängt vom Zufall ab, ob als erstes zurück in main oder oben auf dem Stack dasteht). Wenn ich das Programm aber oft kompiliere ist immer dieselbe Ausgabe. Liegt das daran, dass der Scheduler in nach Java 5.0 verbessert wurde? Oder einfach nur Zufall?

LG,
mathiasj


----------



## SlaterB (17. Sep 2012)

vom Kompilieren hängt es schon mal gar nicht ab, da erzeugen alle Kompiler der Welt (nahezu) gleichen festen Quellcode,
bei mehreren Ausführungen des Programms kann es theoretisch unterschiedlich sein,
aber wie du erkannt hast nicht unbedingt der Fall, 

besser oder schlechter ist das nicht zu nennen, 
jede Kombination Hardware + Betriebssystem + JVM hat anderes Verhalten,
kommt der neue Thread gleich dran und kann den Befehl ausführen oder schafft erst der main-Thread seine Ausgabe

bei mir kommt "zurück in main" immer als erstes in bisherigen Tests, 
wenn aber diese Zeile mehrfach wiederholt, dann kommt bei mir die "Oben auf dem Stack"-Ausgabe meist an zweiter Stelle,
manchmal aber auch erst am Ende nach paar mal "zurück in main", insofern ein bisschen Zufall

davon abhängig machen sollte man sich sowieo nicht machen, durch z.B. Synchronisation steuern, dann ist es im Grunde auch egal

edit:
schreibe ich

```
public class Test {
    static int c = 0;

    public static void main(String[] args)  {
        ThreadTestLauf.main(null);
    }
}


class ThreadTestLauf {
    public static void main(String[] args)  {

        Runnable threadJob = new MeinRunnable();
        Thread mainThread = new Thread(threadJob);

        mainThread.start();

        System.out.println("zurück in main " + Test.c);
        System.out.println("zurück in main " + Test.c);
        System.out.println("zurück in main " + Test.c);

    }
}


class MeinRunnable     implements Runnable {

    public void run()     {
        Test.c++;
        los();
    }

    public void los()   {
        System.out.println("Oben auf dem Stack");
    }
}
```
dann kommt auf einmal "Oben auf dem Stack" häufiger nach vorne, geradezu standardmäßig, alles im Fluss..,
dass c erhöht wird und dann erst eine main-Ausgabe, gibts dagegen nicht (bisher)


----------



## mathiasj (17. Sep 2012)

Ah, ok, danke 
In meinem Buch ist das auch nur ein Beispiel, warum man das vermeiden soll; ich hab mich nur gewundert.

Danke!

LG,
mathiasj


----------

