我到底需要同步什么，对象或对象内部的数据

Question

Suppose I have a class [X] (and its object [xObject]) and within it two Integers [A] and [B]. I have two threads One modifies [A] and other modifies [B]. Now, since both threads change the value of [xObject], should I be synchronizing access to [xObject] or just [A] and [B] because they have different memory location(actually). And where this FALL ends,, like should I access two different locations in an array simultaneously, or inside an arrayList?

Answer 1

not sure what you mean about arrays etc. But if your changing two different values and not reading them in the other thread you do not need to synchronize.

If you are changing value of variable xObject.a in thread 1 and reading it in thread 2 or some other thread 3 then you might get stale reads unless you make a as volatile in class X.

Or use one of the synching utilities in java.util.concurrent package. Can google around or search in stackoverflow for examples of that.

Answer 2

If you have two independent int properties, you don't need to synchronize at all: the only reason to synchronize is to ensure consistency when more than one memory location is involved. With independent locations volatile is sufficient to ensure cross-thread visibility of your changes.

For example, if your int properties are not independent, you need to synchronize. Let's say one property represents the current value, and the other represents the max value. Setting the current value that's greater than the max throws an exception; setting the max value greater than the current value changes the current value to the new max.

public class Test {
    int current = 10;
    int max = 100;
    public synchronized int getMax() { return max; }
    public synchronized int getCurrent() { return max; }
    public synchronized void setCurrent(int c) {
        if (c > max) throw new IllegalStateException();
        current = c;
    }
    public synchronized void setMax(int m) {
        max = m;
        if (current > m) current = m;
    }
}

The decision for arrays and collections is more complex: if you access array elements, but the array itself stays fixed, and array elements are independent, you can skip synchronization. However, if elements are not independent, or if the collection is more complex (say, an array list or a hash table) then you need to synchronize, because collection operations may change the collection structurally, breaking consistency.

Answer 3

If your class is going to be used in a multi-threaded environment, I think its a good practice to lock any data that is made available using getters or public access.

That way you are not forcing the users(code that uses your class as API) to know or consider specific rules("should not modify A if you are accessing B") etc. One can straight away use the methods available without being bothered about which data item needs to be synchronized on. Also less documentation ;)

Answer 4

It depends on what intermediate states a client should never see.

For example, if there is any combination of A and B that is not allowed for the object, then you should synchronize over both accesses:

class Person {
  private final Object _lock = new Object(); // for synchronization

  private int _age;
  private boolean _married;

  public void setAge(int age) {
    if (age <= 0) throw new IllegalArgumentException();

    synchronized(_lock) {
        // age < 18 implies !married
        _age = age;
        if (age < 18) married = false;
    }
  }
}

You might want to do that even if A and B are independent from each other:

class ComplexNumber {
  private final Object _lockRe = new Object();
  private final Object _lockIm = new Object();
  private int _re, _im;

  ...

  public void setValue(int re, int im) {
    synchronized(_lockRe) { _re = re; }
    synchronized(_lockIm) { _im = im; }
  }
}

If you do

ComplexNumber c = new ComplexNumber(0, 0);
c.setValue(1, 2);

then a thread might see (1,0), which was never set: this may be acceptable or not, depending on your application.