在对象上同步，然后在该对象的字段上同步

Question

有多个线程访问一个对象。为了避免内存一致性错误，我对该对象使用了同步方法。
这是否意味着当我在该对象上同步时，只有对象的字段被同步（而不是对象的字段的字段）？ 例如：

public class Class1 {

    private Object value1;

    public Object getValue1() {
        return this.value1;
    }

    public void setValue1(Object value1) {
        this.value1 = value1;
    }

}

哪个代码是正确的（Class2 或 Class3），为什么？

public class Class2 {

    private final Class1 object1 = new Class1();

    private Object value2;

    public synchronized void setValues(Object value1, Object value2) {
        object1.setValue1(value1);
        this.value2 = value2;
    }

    public synchronized Object[] getValues() {
        return new Object[] { object1.getValue1(), this.value2};
    }

}

public class Class3 {

    private final Class1 object1 = new Class1();

    private Object value2;

    public synchronized void setValues(Object value1, Object value2) {
        synchronized (object1) {
            object1.setValue1(value1);
        }
        this.value2 = value2;
    }

    public synchronized Object[] getValues() {
        Object value1;
        synchronized (object1) {
            value1 = object1.getValue1();
        }
        return new Object[] { value1, this.value2};
    }

}

更具体：

Class2 obj = new Class2();

// thread 1
obj.setValues(..., ...);

// thread 2
Object[] values = obj.getValues();

由于setValues 和getValues 都是同步的，所以this.value2 = value2; 和return new Object[] {..., this.value2}; 在Class2 中将存在happens-before 关系。
但是object1 呢？不能保证this.value1 = value1; 在Class1 中发生在return this.value1; 之前。不是吗？

Answer 1

它们都是正确的，但这只是因为您使用它们的具体方式（除了您正在创建的实例的方法之外，没有什么可以使用object1 或value2，因为object1 或@ 987654324@ 和实例专用）。您的主要问题的答案：

这是否意味着当我在该对象上同步时，仅同步对象的字段（而不是对象字段的字段）？

..是是，仅访问该对象的字段，而不是其字段的字段，是同步的。

这是一个可以实际证明问题的示例：

class Foo {
    Class1 c1;

    Foo(Class1 c) {
        this.c1 = c;
    }

    synchronized Object getValue1() {
        return c1.getValue1();
    }

    synchronized void setValue1(Object newValue) {
        c1.setValue1(newValue);
    }
}

这样，Foo 的两个实例可能共享Class1 的相同实例：

Class1 c1 = new Class1();
Foo f1 = new Foo(c1);
Foo f2 = new Foo(c2);

...由于同步仅同步对Foo 实例的访问，因此您可能对他们都在使用的Class1 实例具有非同步访问权限。