Thread synchronisierung

[Mortal_Shadow]

Hi,

ich bin gerade am mich in Threads einarbeiten.
Mein Problem ist folgendes:
Ich habe eine Klasse ConnectionManager, die dazu dient andere Computer im Netzwerk zu finden.
Sie hat die Methoden:

public void startBroadcast(){
     if (broadcastThread == null){ 
         broadcastThread = new UDP_BroadcastThread();
         broadcastThread.setDaemon(true);
         broadcastThread.start();
         }
}

public void stopBroadcast(){
    if (broadcastThread != null){
	broadcastThread.running = false;
	broadcastThread = null;
	}
}

public void startListening(Runnable notifier){
    if (listenThread == null){
	fnotifier = notifier;
	listenThread = new UDP_ListenThread();
	listenThread.setDaemon(true);
	listenThread.start();	
	}
}
	    
public void stopListening(){
    if (listenThread != null){
	listenThread.running = false;
	ip_list.clear();
	listenThread = null;	
	fnotifier = null;
	}
}

Der BroadcastThread sendet periodisch eine "hallo-hier-bin-ich" nachricht.
Wenn der ListenThread diese empfängt, fügt er den absender der ip-list hinzu und führt dann die runnable fnotifier aus.
Problem:
Wenn ich stopListening aufrufe und fnotifier null gesetzt wird, während der andere thread versucht, diesen aufzurufen, kann ich eine null-pointer-exception kriegen.

Ansatz: Monitor verwenden.
Wenn ListenThread eine Nachricht kriegt, betritt er den Monitor, überprüft ob running == true und wenn ja ruft er fnotifier auf. Anschliesend verlässt er den Monitor wieder.

Aber: Wie genau mache ich das?
Wenn ich schreibe: public synchronised void stopListening()...
und: public synchronised void neueNachricht()...
reicht das?

 

[Mortal_Shadow]

Recht viele Leser ohne eine Antwort.
Mein Problem ist halt, dass es heist: "Jedes Objekt der Klasse agiert dann als Monitor für seine Attribute. "
Aber es sind ja zwei verschiedene Objekte, vor deren methoden ich synchronised setze und zwei monitore, die sich nicht gegenseitig blockieren wäre natürlich sinnlos.

 

[SlaterB]

> Wenn ich stopListening aufrufe und fnotifier null gesetzt wird, während der andere thread versucht, diesen aufzurufen, kann ich eine null-pointer-exception kriegen.


was bedeutet es 'einen fnotifier aufzurufen'? das ist ganz schön ungenau,

im geposteten Code kann es hinsichtlich fnotifier nicht zu einer NullPointerException kommen,
entweder die Variable wird gesetzt oder auf null gesetzt, sonst passiert da nix,

wichtig für dich ist vielleicht:
wenn man an einer Stelle eine Variable, die auf ein Objekt X zeigt, auf null setzt,
so sind davon alle anderen Variablen oder schwebenden Parameterübergaben nicht betroffen, das Objekt selber wird nicht zerstört,
wenn ein anderer Thread damit gerade arbeitet (Methoden ausführt), dann muss es nicht unbedingt Probleme geben

 

[Mortal_Shadow]

Ahhh, mir fällt grad was auf.
Das Problem hatte ich, weil java mal bei einer nicht initiierten Variable gemeckert hat.
Wenn fnotifier null ist und ich fnotifier.run aufrufe, passiert einfach gar nichts.
Somit ist synchronisation hier überflüssig.

Interessehalber, würde ich dennoch gern wissen, ob synchronised hier verhindert, dass fnotifier aufgerufen wird, auch wenn es null ist.

 

[SlaterB]

wenn eine oder beide Methoden synchronisiert wird, dann bedeutet dass, das nicht zwei Thread gleichzeitig in den Methoden drin sein können, sondern nacheinander,
das ist doch ein einfaches Prinzip, daraus kannst du dir alle Konsequenzen ableiten

 

[Mortal_Shadow]

Auf einem Objekt kann gleichzeitig nur eine synhronized
Methode bzw. ein synhronizedAbschnitt aktiv werden.

Es sind aber halt zwei verschiedene Objekte.
Daher die Frage: Ist in jedem Programm nur ein Monitor aktiv, oder pro Objekt einer?

Ich verstehe auch die Arbeitsweise eines Monitors nicht komplett, d.h.
Wie sichert sich ein Monitor gegen doppelten zugriff?
Er funktioniert ja so:
Prüfe, ob ein anderer Thread drauf zugreift.
Wenn nein, dann blockiere und greife selber drauf zu.

Was verhindert aber folgendes Szenario:
Prüfe, ob ein anderer Thread drauf zugreift.
-> Zurückgeliefert wird nein.
-> In diesem Moment wird ein anderer Thread aktiv.
-> Der erste hat noch nicht das flag gesetzt, das er zugriff hat, daher greift der zweite nun zu.
-> Der zweite wird unterbrochen und der erste greift gleichzeitig wie der zweite zu.

 

[Empire Phoenix]

guck mal hier:
KR & KM Research Group: Praktische Informatik II
folie von Prozesse bis Deadlocks wäre da erstmal wichtig.

Danach kannste dann halbwegs sinnvoll weiterarbeiten, wenn du die grundlagen kennst.

Aber zur frage, synchronized im methoden namen macht synchronized(this){methodencode} sinnlich, sprich dein monitor ist dein object.

 

[Mortal_Shadow]

Ufff, viel zu lesen, genau das richtige für mich, danke!!