Konsistenz zweier Listen in zwei Klassen

[Wolfsbein]

Hallo

ich habe hier ein kleines Problem mit einer Konsistenzbeziehung:

// Klasse 1
public boolean hinzufuegen(Typ1 typ) {
liste.add(typ);
typ.hinzufuegen(this);
}

// Klasse 2
public boolean hinzufuegen(Typ2 typ) {
liste.add(typ)
// typ.hinzufuegen(this);
}

Wie man sieht habe ich die letzte Zeile schon auskommentiert, da ich so einen deadlock erzeugen würde. Wie kann ich das möglichst einfach realisieren?
Ich habe bereits an ein Flag gedacht, das vor dem Aufruf gesetzt wird und der Klasse mitteilt ob der Aufruf extern (vom anderen Typ) oder intern (vom eigenen Typ) kommt. Nur sollte das doch auch eleganter gehen? Kann ich sowas wie object.caller() machen? Danke.
EDIT: Code richtig gestellt.

 

[torsch2711]

Hallo,

ich weiss jetzt nicht ob ich das Problem richtig verstanden habe, aber wie wäre es mit dem synchronized keyword.

In Java gibt es eine Methodik, riskante abschnitte mit einem synchronized block zu umgeben und somit ein konsistenzproblem zu verhindern. Sprich das auch inkonsistente Daten entstehen.

In deinem fall müsstest du die Add funktion mit einem einem synchronized keyword versehen. Den entsprechenden Teil deiner add Funktion mit einem synchronized {} zu umgeben würde hier nicht viel helfen.

Zusätzlich Frage: ist dieses liste-objekt immer von der selben klasse? (in diesem fall würde ich list sagen.) Wenn ja, wie gesagt, würde ich dir vorschlagen, das du vielleicht das list-objekt erweiterst mit einer add methode, die Synchronized ist und einfach nur das übergebene Objekt an deine superklasse weitergibt.

Hilft Dir das weiter?

Falls nicht, schau mal hier.

http://mindprod.com/jgloss/synchronized.htm
http://java.sun.com/docs/books/tutorial/together/bingo/synchronized.html

Ich hoffe das hilft dir weiter


Grüsse

Torsten

 

[Wolfsbein]

Synchronisieren muss ich die Funktionen nicht. Die Klassen sind unabhängig. Ich möchte nur, dass wenn ich ein Objekt A erzeuge in der anderen Klasse B ein Attribut von A in einer Liste gespeichert wird und umgekehrt.

 

[Christian Fein]

Synchronisieren muss ich die Funktionen nicht. Die Klassen sind unabhängig. Ich möchte nur, dass wenn ich ein Objekt A erzeuge in der anderen Klasse B ein Attribut von A in einer Liste gespeichert wird und umgekehrt.

Wie kommst du auf die Idee das hier ein Deadlock entsteht?

 

[torsch2711]

Aha, dann stimmt aber dein code snippet nicht oder?


// Klasse 1
public boolean hinzufuegen(Typ1 typ) {
liste.add(typ);
typ.hinzufuegen(this);
}

// Klasse 2
public boolean hinzufuegen(Typ2 typ) {
liste.add(typ)
// typ.hinzufuegen(this);
}



müsste dann jeweils die typen vertauscht sein.

Okay. dann würde ich dir empfehlen ein flag mit zu übergeben, sprich wenn typ1 ein objekt hinzufügt, das singalisiert dass wenn du es zu type 2 hinzufügst nicht in das typ.hinzufügen läuft, sprich:

<modified Code-Snippet>
// Klasse 1
public boolean hinzufuegen(Typ2 typ, boolean calledbyanothertype) {
liste.add(typ);
if (!calledbyanothertype) typ.hinzufuegen(this, true);
}

// Klasse 2
public boolean hinzufuegen(Typ1 typ, boolean calledbyanothertype) {
liste.add(typ)
if (!calledbyanothertype)typ.hinzufuegen(this,true);
}
</modified Code-Snippet>

normales hinzufügen durch: typ1.hinzufügen(typ2, false);

Ich denke, das wird dir so helfen.


Grüsse Torsten

 

[torsch2711]

@Christian:

Der "Deadlock" entsteht, wenn er die Typenbezeichnung richtig gemacht hätte, sprich klasse1 bekommt ein Objekt der Klasse 2 hinzugefügt, dann läuft er so ziemlich in eine Endlosschleife rein, bis es zu einem überlauf kommt. Es ist kein Deadlock im klassischen sinne und ich würde eher auf einen Überlauf überschwenken.

Grüsse Torsten

 

[Wolfsbein]

Ihr habt recht ein deadlock im klassichen Sinn ist es nicht (ich habe ja keine Threads). Aber ich werde es dann wohl mit einem Flag machen.

 

[Christian Fein]

@Christian:

Der "Deadlock" entsteht, wenn er die Typenbezeichnung richtig gemacht hätte, sprich klasse1 bekommt ein Objekt der Klasse 2 hinzugefügt, dann läuft er so ziemlich in eine Endlosschleife rein, bis es zu einem überlauf kommt. Es ist kein Deadlock im klassischen sinne und ich würde eher auf einen Überlauf überschwenken.

Grüsse Torsten

// Klasse 2
public boolean hinzufuegen(Typ2 typ) {
liste.add(typ)
// typ.hinzufuegen(this); <----- jetzt sehe ich das Auskommentierte

 

[torsch2711]

Du könntest aber auch noch eine etwas umständlichere Variante machen:

Du definierst eine Methode

boolean calledfromme=false; //Ich weiss dummer name, aber ich versuchs halt mal so.

private void switchCallStatus(){
calledfromme=!calledfromme;
}

private boolean getCallStatus() {
return calledfromme;
}

im code sagst du dann (Klasse 2 äquivalent)
public boolean hinzufuegen(Typ1 typ) {
if (!getCallStatus()) {
liste.add(typ)
switchCallStatus();
typ.hinzufuegen(this);
}
else switchCallStatus();
}

wobei der Aufruf so geht:


typ1.add(typ2);


Das ist allerdings sehr umständlich und ich würde dir der kürze wegen die Flagübergabe empfehlen (und der Übersichtlichkeit wegen).


EDIT:*okay, schon selbst reingelegt, habs kurz modifiziert.*

Grüsse

Torsten.