Verklemmung Threads

[Sonnenblume123]

Hallo,

ich soll die Verklemmung in diesem Programm finden:

public class Wave {
    static class Friend {
        private final String name;

        public Friend(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        public synchronized void wave(Friend waver) {
            String tempname = waver.getName();
            System.out.format("%s: %s has waved to me!%n", this.name, tempname);
            waver.waveback(this);
        }

        public synchronized void waveback(Friend waver) {
            String tempname = waver.getName();
            System.out.format("%s: %s has waved back to me!%n", this.name, tempname);
        }
    }

    public static void main(String[] args) {
        final Friend friendA = new Friend("FriendA");
        final Friend friendB = new Friend("FriendB");
       
        new Thread(new Runnable() {
            public void run() {
                friendA.wave(friendB);
            }
        }).start();
       
        new Thread(new Runnable() {
            public void run() {
                friendB.wave(friendA);
            }
        }).start();
    }
}

Nachdem ich die Klasse ausgeführt habe, hab ich gesehen, dass nur die Methode wave ausgeführt wird(beziehungsweise es bei waveBack klemmt), weil in der Konsole steht nur:
FriendA: FriendB has waved to me!
FriendB: FriendA has waved to me!

Nun frag ich mich warum es da zu einer Verklemmung kommt.
Weil der Ablauf ist so:
friendA ruft wave aus, dann wird der Name von friendB in tempname gespeichert, dann der Satz ausgegeben und dann wird waveback aufgerufen. Nun kann friendB auf die Methode wave zugreifen. Und führt sie aus (sieht man an der Ausgabe von dem Satz). Kann aber waveback nicht aufrufen, da friendA da noch ist (synchronized). Jetzt frag ich mich aber, warum friendA da immer noch ist.
Würde mich über eure Hilfe freuen

 

[httpdigest]

Nun frag ich mich warum es da zu einer Verklemmung kommt.

Wenn Thread1 in friendA.wave() ist, sperrt Thread1 friendA. Das heißt, kein anderer Thread kann währenddessen auf friendA synchronisieren.
Dasselbe macht Thread2 mit friendB durch den Aufruf von friendB.wave().
Nun versucht aber Thread1 innerhalb von friendA.wave() die Methode friendB.waveback() aufzurufen. Das geht nicht, da Thread2 aktuell durch friendB.wave() einen Lock auf friendB hält.
Und genauso versucht Thread2 innerhalb von friendB.wave() die Methode friendA.waveback() aufzurufen, was nicht geht, weil Thread1 ja durch friendA.wave() einen Lock auf friendA hält.

 

[Xyz1]

Wahrscheinlich über Friend other_waver synchronisieren ich hab aber nicht genau hingesehen!!

 

[Xyz1]

overflow gibt es auch so an.
Habe aber weiß noch nicht genau, ob sich dein Problem auch darauf "verkleinern" lässt.

Bearbeitung: Was soll denn richtigerweise geschehen?

 

[Xyz1]

@Sonnenblume123 Du musst Dir das so vorstellen


lock a wird zweimal angefordert und lock b wird zweimal angefordert => Verklemmung

 

[mkdrive2]

Da die Methoden "synchronized" markiert sind, gibt es zwei Locks (FriendA und FriendB), die sich gegenseitig blockieren. Wenn aber nur ein Lock verwendet wird, wie z.B. "getClass()" der Friend-Klasse, dann kann jeder Thread nacheinander ausgeführt werden. ("this.getClass()" ist immer das selbe Objekt, egal von welchem Friend-Objekt es ausgeführt wird!! Genauso wie wenn es ein static-Variable in der Friend-Klasse geben würde.)

public class Wave {
    static class Friend {
        private final String name;

        public Friend(String name) {
            this.name = name;
        }

        public String getName() {
            return this.name;
        }

        public void wave(Friend waver) {
            synchronized (this.getClass()) {
                String tempname = waver.getName();
                System.out.format("%s: %s has waved to me!%n", this.name, tempname);
                waver.waveback(this);
            }
        }

        public void waveback(Friend waver) {
            synchronized (this.getClass()) {
                String tempname = waver.getName();
                System.out.format("%s: %s has waved back to me!%n", this.name, tempname);
            }
        }
    }

    public static void main(String[] args) {
        final Friend friendA = new Friend("FriendA");
        final Friend friendB = new Friend("FriendB");
       
        new Thread(new Runnable() {
            public void run() {
                friendA.wave(friendB);
            }
        }).start();
       
        new Thread(new Runnable() {
            public void run() {
                friendB.wave(friendA);
            }
        }).start();
    }
}

 

[Xyz1]

@mkdrive2 jetzt kann aber nur noch 'geordnet' gegrüßt werden, das heißt beide können sich nicht gleichzeitig zuwinken und oder gleichzeitig zurück-zuwinken.

 

[mkdrive2]

@DerWissende: Stimmt. Man könnte die synchronized-Blöcke aufteilen. Dann wäre es genauso wie wenn es keine synchronized-Blöcke gäbe... :-/

 

[mihe7]

Dann wäre es genauso wie wenn es keine synchronized-Blöcke gäbe... :-/

Das ist - zumindest theoretisch - nicht richtig, weil es AFAIK keine Zusicherung gibt, dass System.out thread-safe wäre.

 

[Xyz1]

Mihe ist matialisch und denkt immer gleich an Zerstückelung ...... so weit habe ich gar nicht gedacht!

 

[Sonnenblume123]

Vielen Dank an euch alle
@DerWissende war echt eine hilfreiche Darstellung!

 

[Xyz1]

Das finde ich auch und danke für die Blumen (sorry, voll das blöde Wortspiel )