在 object Y 上定义的同步块中访问 object X 是否安全？

Question

There are answers to the question if accessing the state of the object is safe within the synchronized method or block. My question: Is it safe to access an object X within a synchronized block, where synchronized block is on another object Y and there are multiple writers Threads present for X?

public class X{
    private int value = 0;
    /** set method will be invoked by multiple threads**/
    public void set(int v){
       this.value = v;
   }
   public int value(){
       return value;
   }
}

public class Tester{
    private final Object Y = new Object();
    public void test(X x){
        synchronized(Y){
            System.out.println(x.value()); // is it guaranteed that x.value will be read from memory and not from the current thread's cache ?
        }
    }
}      

I know state of the object on which synchronized block is defined is safe to access without a need for volatile, but what if the synchronized block is defined on another object?

Answer 1

IMO you are asking the wrong question. The Java Memory Model doesn't concern itself with objects and classes. It only talks about the visibility of variables .

The visibility rule for synchronized(o) blocks is pretty simple: Whatever one thread does to any variable before it leaves a synchronized(o) block is guaranteed to be visible to any other thread after the other thread subsequently enters a block that is synchronized on the same instance, o .

So, in your example, if you have some X my_x , and some thread A does this:

synchronized(Y) {
    my_x.set(55);
}

Then when some other thread B subsequently calls tester.test(my_x) , thread B will see the value that was stored by thread A.

On the other hand, if thread A calls my_x.set(...) without synchronizing on Y , then Java does not promise when, if ever, the thread B will see the change.

---

Note: Your program openly invites failure by making the lock object, Y , a private member of the Tester class, while making the test(X) function public . That practically begs you (or some other programmer) to make the mistake of calling tester.test(some_random_X) where the some_random_X was set by another thread that did not lock Y .

Answer 2

No it is not safe.

Unrelated to the question:

First problem with the example code:

public void set(int v){
    this.value = v;
}

this is extremely poor code quality and should really be written like this:

public final void setValue(final int value) {
    this.value = value;
}

this has no performance benefit other than addition of the final modifiers may improve bytecode optimization it is just a design pattern for setters.

Second problem with the example code:

public int value(){
    return value;
}

the correct design pattern for a getter is:

public final int getValue() {
    return value;
}

Third problem with the example code:

private final Object Y = new Object();

the field 'Y' is not static and therefore is not a constant, the correct naming convention for this field would be:

private final Object y = new Object();

The forth problem with the example code is the putting braces after parentheses without a space, what i mean by that is instead of doing

){

you should really be doing:

) {