Können Sie sicher auf einem Java-Methodenparameter synchronisieren?

Question

Nehmen Sie diesen Code:

public class MyClass {
    private final Object _lock = new Object();
    private final MyMutableClass _mutableObject = new MyMutableClass()

    public void myMethod() {
        synchronized(_lock) { // wir synchronisieren auf der Instanzvariable _lock
            // mach etwas mit mutableVar 
            // (d.h. rufe eine "set"-Methode auf _mutableObject auf)
        }
    }
}

Stellen Sie sich nun vor, dass der Code in myMethod() an eine Hilfsklasse delegiert wird, der Sie das Schloss übergeben:

public class HelperClass {
    public helperMethod(Object lockVar, MyMutableClass mutableVar) {
        synchronized(lockVar) { // wir synchronisieren jetzt auf einem Methodenparameter, 
                                // jeder Thread hat seine eigene Kopie
            // mach etwas mit mutableVar 
            // (d.h. rufe eine "set"-Methode auf mutableVar auf)
        }
    }
}

Kann "myMethod" umgeschrieben werden, um die HelperClass zu verwenden, indem Sie ihr Schloss übergeben, damit alles weiterhin thread-sicher ist? d.h.,

public void myMethod() {
    _helperObject.helperMethod(_lock, _mutableObject);
}

Ich bin mir nicht sicher, weil Java das lockVar per Wert übergibt und jeder Thread eine separate Kopie von lockVar erhält (obwohl jede Kopie auf dasselbe Objekt im Heap zeigt). Ich denke, die Frage kommt darauf an, wie das 'synchronized'-Schlüsselwort funktioniert - sperrt es die Variable oder den Wert im Heap, auf den die Variable verweist?

Answer 1

Die Synchronisation erfolgt an Objekten, nicht an Variablen.

Variablen/Mitglieder enthalten manchmal Objekte und es ist das resultierende Objekt, das in der Variable x enthalten ist, auf das tatsächlich mit synchronized(x) synchronisiert wird.

Es gibt noch ein paar andere Probleme mit der Thread-Sichtbarkeit von Variablen (z.B. könnte ein "veraltetes" Objekt aus einer Variable gelesen werden), aber das trifft hier nicht zu: Es findet keine Neuweisung von _lock statt und die Sichtbarkeit der anfänglichen ("finalen") Zuweisung ist garantiert. Daher ist es garantiert, dass in diesem Fall der Methodenparameter immer das richtige (gleiche) Objekt enthält, das für die Synchronisation verwendet wird.

Wenn sich jedoch das verwendete Sperr-Objekt ändert (wobei vermutlich _lock nicht final ist), dann müssten die entsprechenden Werte/Thread-Sichtbarkeit neu bewertet werden, aber sonst unterscheidet es sich nicht von einem beliebigen Zugriff zwischen Threads.

Frohes Programmieren.