Guten Tag zusammen,
ich hab eine Aufgabe bekommen, bin absoluter Anfänger in der Thread-Welt (Parallelität) und wüsste gerne wie man sauber einen Thread beenden lassen kann.
Mein vorgehen war dieses hier:
erst einmal die Schleife
################
Hier die Barrier Klasse:
Nun findet man im Netz einiges darüber doch ich weiß nicht ob wir einen AtomicBoolean nutzen dürfen. Der erste Versuch war mit einem normalen Boolean in der Barrier Klasse der dann auf false geschaltet wurde. Doch dort wurde als Begründung angegeben das die Threads dann nicht vernünftig beendet worden wären. Nun habe ich von einem Kommilitonen erfahren das er das von außerhalb macht. Des weiteren meinte er das die while(true) Schleife dann zu einer while(variable) Schleife geändert werden soll und die variable "einfach" auf false gesetzt werden kann.
MyClass.variable = false (Damit lässt sich der Thread von außerhalb anhalten) Wie genau sieht so etwas aus.
Hat jemand eine Idee oder sind meine Ansätze zu weit her geholt oder zu abstrakt? Den Falschen Code kann ich auch gerne bei bedarf noch Posten 🙂
ich hab eine Aufgabe bekommen, bin absoluter Anfänger in der Thread-Welt (Parallelität) und wüsste gerne wie man sauber einen Thread beenden lassen kann.
Mein vorgehen war dieses hier:
erst einmal die Schleife
Java:
while (true) {
char quit = (char) br.read();
if (quit == 'q')
for (Barrier b : arr)
b.stopRunning();
System.exit(0);
}Hier die Barrier Klasse:
Java:
import java.util.concurrent.atomic.AtomicBoolean;
public class Barrier extends Thread {
private String name;
private int begin, end, open, close, count;
private AtomicBoolean running = new AtomicBoolean(true);
Barrier(String name, int begin, int end, int open, int close, int count) {
this.name = name;
this.begin = begin;
this.end = end;
this.open = open;
this.close = close;
this.count = count;
}
public String getBarrierName() {
return name;
}
public int getBegin() {
return begin;
}
public int getEnd() {
return end;
}
public int getOpen() {
return open;
}
public int getClose() {
return close;
}
public AtomicBoolean getRunning() {
return running;
}
public void setBarrierName(String name) {
this.name = name;
}
public void setBegin(int begin) {
this.begin = begin;
}
public void setEnd(int end) {
this.end = end;
}
public void setOpen(int open) {
this.open = open;
}
public void setClose(int close) {
this.close = close;
}
public void setRunning(AtomicBoolean running) {
this.running = running;
}
public void stopRunning() {
running.set(false);
}
public void run() {
for (; count != 0 && running.get(); count--) {
try {
System.out.println("Barrier " + name + " start opening");
sleep(open);
System.out.println("Barrier " + name + " end opening");
sleep(end);
System.out.println("Barrier " + name + " start closing");
sleep(close);
System.out.println("Barrier " + name + " end closing");
sleep(begin);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}Nun findet man im Netz einiges darüber doch ich weiß nicht ob wir einen AtomicBoolean nutzen dürfen. Der erste Versuch war mit einem normalen Boolean in der Barrier Klasse der dann auf false geschaltet wurde. Doch dort wurde als Begründung angegeben das die Threads dann nicht vernünftig beendet worden wären. Nun habe ich von einem Kommilitonen erfahren das er das von außerhalb macht. Des weiteren meinte er das die while(true) Schleife dann zu einer while(variable) Schleife geändert werden soll und die variable "einfach" auf false gesetzt werden kann.
MyClass.variable = false (Damit lässt sich der Thread von außerhalb anhalten) Wie genau sieht so etwas aus.
Hat jemand eine Idee oder sind meine Ansätze zu weit her geholt oder zu abstrakt? Den Falschen Code kann ich auch gerne bei bedarf noch Posten 🙂
