Threads Code funktioniert nicht wie er sollte

[DaniSahne96]

Hi Community,
ich habe 3 Klassen: DateCommand, CounterCommand und FirstThread

//DateCommand
public class DateCommand implements Runnable
{
    @Override public void run()
    {
        for(int i = 0; i < 20; i++)
        {
            System.out.println(new java.util.Date());
        }
    }
}

//CounterCommand
public class CounterCommand implements Runnable
{
    @Override public void run()
    {
        for(int i = 0; i < 20; i++)
        {
            System.out.println(i);
        }
    }
}

//FirstThread
public class FirstThread
{
    public static void main(String[] args)
    {
        Thread t1 = new Thread(new CounterCommand());
        t1.start();

        Thread t2 = new Thread(new DateCommand());
        t2.start();
    }
}

Folgendes Problem, wenn ich das jetzt ausführe kommt
Tue Jul 31 16:57:27 CEST 2012
...und so weiter, 19mal eben das Datum
1
2
...und so weiter bis 20

Das ganze ist aber ja sequenziell und eben nicht (pseudo)paralell, da ich aber gerade erst Anfange was über Threads zu lernen weis ich nich ob das so gehört oder ob das eben nich so gehört?
Sollte es so nicht sein, woran liegt, bzw was kann man dagegen tun?

//Edit: Zwar stand in Java Insel(hab ich den Code her) das es nicht vorherzusagen ist wann der Threadwechsel stattfindet, allerdings findet bei mir kein(?) Threadwechsel statt und es kommt immer dieses Ergebniss

 

[Mujahiddin]

Versuch mal:

public class FirstThread
{
    public static void main(String[] args)
    {
        Thread t1 = new Thread(new CounterCommand());
        Thread t2 = new Thread(new DateCommand());
        t1.start();
        t2.start();
    }
}

So sollte es klappen.
Die Sache ist, einen Thread zu erzeugen dauert genau so lange wie 20 mal die Schleife durchzulaufen. Deshalb scheint es sequenziell.

 

[Schandro]

Das liegt nur daran das die run-Methoden viel zu schnell abgearbeitet werden. Mach mal etwas was länger dauert (oder ein Thread.sleep) in die run-Methoden, dann wirst du das multi-threading sehen.

 

[bygones]

es laeuft einfach zu schnell... mach mal ein Thread.sleep(100) oder so rein

Versuch mal:

public class FirstThread
{
    public static void main(String[] args)
    {
        Thread t1 = new Thread(new CounterCommand());
        Thread t2 = new Thread(new DateCommand());
        t1.start();
        t2.start();
    }
}

So sollte es klappen.
Die Sache ist, einen Thread zu erzeugen dauert genau so lange wie 20 mal die Schleife durchzulaufen. Deshalb scheint es sequenziell.

nein das aendert auch nix dass es zu schnell laeuft

 

[SlaterB]

zu dem von Mujahiddin:
sicher ist das aber auch nicht, bei so wenigen Befehlen gibts keine sinnvollen Voraussagen,
wobei System.out.println() jeweils immerhin noch gigantisch langsamer ist als etwa nur 20 Zahlen in einer Schleife zusammenzuaddieren,

wenn du noch ein sleep() von 20 ms einbaust, dann hast du Schleifen die tatsächlich über die Zeit agieren
und nicht in einem Augenblick fertig sind

 

[DaniSahne96]

Also ihr meint das gehört so? wenn ich das hier mach

Thread t1 = new Thread(new CounterCommand());
        Thread t2 = new Thread(new DateCommand());
        t1.start();
        t2.start();

passiert auch nix anders. Und wo soll ich das t1.sleep() einfügen?
direkt hinter t1.start() ?

 

[Mujahiddin]

Ja hab die Computer unterschätzt sry :/
Thread.sleep(20); bei jedem Durchlauf der forschleife

for(int i=0; i<20; i++){
System.out.println(i);
Thread.sleep(20);
}

 

[DaniSahne96]

Achso, also das print'en geht so schnell das schon ausgegeben wird wird bevor zum thread gesiwtcht wird?

 

[DaniSahne96]

Also ich hab jetzt in beide for's nach dem println() ein Thread.sleep(20); eingefügt, allerdings hat sich nichts an der ausgabe geändert

 

[Mujahiddin]

public class FirstThread {
	public static void main(String[] args) {
		Thread t1 = new Thread(new CounterCommand());
		Thread t2 = new Thread(new DateCommand());
		
		t1.start();
		t2.start();
	}
}

class CounterCommand implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			System.out.println(i);
			try {
				Thread.sleep(20);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

class DateCommand implements Runnable {
	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			System.out.println(new java.util.Date());
			try {
				Thread.sleep(20);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

Bei mir funktioniert's.