Hallo zusammen,
leider habe ich keinen Vernünftigen Titel für dieses Thema gefunden.
Wir haben eine Aufgabe in der wir Züge in eine Zug Station die entweder nach Osten oder Westen fahren kann bringen sollen. Es dürfen immer nur 3 Züge in die selbe Richtung auf in dieser Zug Station sich befinden.
Nun hieß es dass die Züge sich überholen können. Kann mir das jemand erklären? Hier einmal mein Code:
Main:
Train:
RailAB:
Mir fällt gerade auch auf dass notify() doch auch zu einem Deadlock führen könnte (Irgendwann) oder wieder Denkfehler?
Wenn alle Threads sich in der Queue befinden würden und wir einen east Thread bräuchten doch wecken einen west Thread dann leg sich dieser Thread erneut schlafen und wir warten ewig.
leider habe ich keinen Vernünftigen Titel für dieses Thema gefunden.
Wir haben eine Aufgabe in der wir Züge in eine Zug Station die entweder nach Osten oder Westen fahren kann bringen sollen. Es dürfen immer nur 3 Züge in die selbe Richtung auf in dieser Zug Station sich befinden.
Nun hieß es dass die Züge sich überholen können. Kann mir das jemand erklären? Hier einmal mein Code:
Main:
Java:
public class Main {
public static void main(String[] args) {
RailAB rail = new RailAB(3,3,3);
int anz = 100;
Train[] trains = new Train[anz];
for(int i = 0; i < anz; i++) {
trains[i] = new Train(rail, i + 1);
trains[i].start();
}
}
}
Train:
Java:
public class Train extends Thread {
private RailAB ab;
private int id;
public Train(RailAB ab, int id) {
this.ab = ab;
this.id = id;
}
public void run() {
int random = (int) (Math.random() * 10 + 1);
if (random < 5) {
System.out.println("Zug nach Osten " + id);
ab.goWest();
}
else {
System.out.println("Zug nach Westen " + id);
ab.goEast();
}
System.out.println("Zug verlaesst AB " + id);
ab.leaveAB();
}
}
RailAB:
Java:
public class RailAB {
private int max;
private int east;
private int west;
RailAB() {
this(0,0,0);
}
RailAB(int max, int east, int west) {
this.max = max;
this.east = east;
this.west = west;
}
public synchronized void goEast() {
//Wenn Osten 0, dann haben wir 3 Ost Zuege.
//Wenn Westen != max, dann zu erst ein West Zug und wir muessen West komplett fuellen!
while (east == 0 || west != max) {
try {
this.wait();
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
east--;
System.out.println("RailAB Osten: " + east);
}
public synchronized void goWest() {
while(west == 0 || east != max) {
try {
this.wait();
}
catch(InterruptedException ex) {
ex.printStackTrace();
}
}
west--;
System.out.println("RailAB Westen: " + west);
}
public synchronized void leaveAB() {
if(east < max)
east++;
else if(west < max)
west++;
notify();
}
}
Mir fällt gerade auch auf dass notify() doch auch zu einem Deadlock führen könnte (Irgendwann) oder wieder Denkfehler?
Wenn alle Threads sich in der Queue befinden würden und wir einen east Thread bräuchten doch wecken einen west Thread dann leg sich dieser Thread erneut schlafen und wir warten ewig.
Zuletzt bearbeitet: