Is it safe to access an object X within a synchronized block defined on object Y?

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 ?

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.

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:

) {