Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Hallo, ich möchte 2 Threads parallel starten und jeden jeweils 2000ms pausieren. (Thread.sleep)
Leider funktioniert mein LösungsAnsatz nicht.
Java:
package de.threads;
import de.threads.Stoppuhr;
public class Main {
public static void main(String[] args) {
Stoppuhr s = new Stoppuhr(2000);
Stoppuhr s2 = new Stoppuhr(2000);
long st = System.currentTimeMillis();
s.start();
s2.start();
long ste = System.currentTimeMillis();
long f = ste-st;
System.out.println (f);
}
}
Java:
package de.threads;
import de.threads.Stoppuhr;
public class Stoppuhr extends Thread {
int time;
public Stoppuhr(int time){
this.time = time;
}
@Override
public void run(){
System.out.println ("Thread1");
try {
Thread.sleep(time);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
Er misst bei diesem Code nur wenige ms.
Wenn ich in der Main nur ein Objekt habe und 2 mal Thread.start ausführe
Java:
package de.threads;
import de.threads.Stoppuhr;
public class Main {
public static void main(String[] args) {
Stoppuhr s = new Stoppuhr(2000);
long st = System.currentTimeMillis();
s.start();
s.start();
long ste = System.currentTimeMillis();
long f = ste-st;
System.out.println (f);
}
}
Dann kommt java.lang.IllegalThreadStateException
Jedes Tutorial welches im Internet bisher fand war sehr schlecht und hat nichts richtig erklärt.
5ms 10ms 15ms
main ---+--------+---------[Zeitmessung]--
| |start() ca. 2s
s2 | +---------------------------------- ... ------ Ende
|start() ca. 2s
s +------------------------------------------- ... ------ Ende
Du siehst, die Zeitmessung passiert quasi unmittelbar nach dem Start (die ms sind natürlich rein fiktiv).
Du willst aber etwas wie
Code:
5ms 5ms 10ms
main ---+--------+---------+ +--+ +---[Zeitmessung]
| |start() | 2s | |join()|
s2 | +---------)----- ... ----- Ende ) +......+
|start() |join() 2s |
s +------------------+----- ... ----- Ende-+
Der Main-Thread wartet per join() auf die Beendigung von Thread s. Danach wartet der Main-Thread per join() auf die Beendigung von Thread s2 (falls dieser schon beendet ist, wird natürlich nicht gewartet). Dann erfolgt die Zeitmessung.
Ich hab mich gerade nochmal mit der Thematik auseinander gesetzt und festgestellt, dass ich nicht weiter komme.
Ich starte einen neuen Thread mit Hilfe des Runnable Interfaces.
Um die Zeit zu messen benutze ich eine simple Methode die System.currentTimeMillis() zum Start in eine long Variable speichert und zum Ende des Threads wird dann für den jeweiligen Thread genau das selbe in eine jeweilige long Variable getan.
Anschließend zieh ich die Anfangszeiten von den EndZeiten ab.
Damit das funktioniert muss ich allerdings darauf warten, bis beide Threads fertig sind.
Das Problem ist allerdings, dass ich nicht weiß wie. Momentan teste ich 2 verschiedene Primzahl Methoden und habe ein Thread.sleep eingefügt der ausreichend lange wartet um dann erst die benötigte Zeit zu messen.
Ich habe versucht mich in join() einzulesen aber leider durchsuche ich entweder die falschen Quellen oder ich verstehe einfach garnichts von Programmierung.
Man soll die start Methode überschreiben und darin ein join() einfügen.
Aber intellij zeigt mir nicht an, dass ich eine Start Methode überschreiben kann.
Also wenn Du zwei Algorithmen vergleichen willst, dann würde ich das nicht in parallelen Threads machen sondern die beiden Algorithmen nacheinander prüfen.
Und Du musst nichts überschreiben. Du rufst in dem Haupt-Thread lediglich auf Deinen Thread Instanzen join auf. Das wäre dann, wenn man es in Deinen Code einbauen würde:
Java:
package de.threads;
import de.threads.Stoppuhr;
public class Main {
public static void main(String[] args) {
Stoppuhr s = new Stoppuhr(2000);
Stoppuhr s2 = new Stoppuhr(2000);
long st = System.currentTimeMillis();
s.start();
s2.start();
// Die Joins
s.join();
s2.join();
long ste = System.currentTimeMillis();
long f = ste-st;
System.out.println (f);
}
}
Angenommen, der Haupt-Thread hat einen untergeordneten Thread erstellt, um eine Aufgabe auszuführen. Irgendwann benötigt der Haupt-Thread dann die Ergebnisse der Arbeit, die von einem untergeordneten Thread ausgeführt wurde. Aber der untergeordnete Thread hat seine Arbeit noch nicht beendet. Was...
Nein, aber ich sehe es als best practice an, wenn ich auf einen Thread warten will, dass ich das dann per join und nicht per sleep mache. Er muss hier nicht warten - vorausgesetzt, er hat nicht noch was anderes vor.
