Should I synchronize constructor?

Question

Consider a class that represents a simple cell:

class Cell {
    private int x;

    Cell(int x) {
        this.x = x;
    }

    int getX() {
        return x;
    }

    void setX(int x) {
        this.x = x;
    }
}

If I want to make it thread-safe, should I only make the methods synchronized or the constructor too?

class Cell {
    private int x;

    Cell(int x) {
        synchronized(this) { // <- Is this synchronization necessary?
            this.x = x;
        }
    }

    synchronized int getX() {
        return x;
    }

    synchronized void setX(int x) {
        this.x = x;
    }
}

If yes, why are there no synchronized blocks in java.util.Vector constructors?

Answer 1

As per the JLS#8.8.3

There is no practical need for a constructor to be synchronized, because it would lock the object under construction, which is normally not made available to other threads until all constructors for the object have completed their work.

So that implies the reference is being synchronized prior to be accessible.

Since you are correctly synchronizing, it would be said writes that occur in the constructor would happen-before the object is published, so long as the synchronization is consistent on said field

In your case since getX() and setX() are both synchronized, the synchronization is consistent and you do not need to sync in the constructor.

---

Now, would you ever need to synchronize(this) on the constructor? No, as the JLS mentions it is implicitly synchronizing without you knowing about it.

Answer 2

This brings up an important tangential point - you should never allow a reference to an object to escape from its constructor, as this would allow access to a partially constructed object.

So assuming that you follow this iron law of programming, you never need to synchronize a constructor, as no method, concurrent or otherwise, can access an object before the constructor returns. Thus synchronizing makes no logical sense.

Answer 3

No, you don't need to synchronize the constructor, because as long as you are in the constructor, the reference cannot be leaked to another thread.

Besides that:

1. Consider making your class immutable. Then no synchronisation is needed.
2. I'd rather not make a simple class like this synchronzid but leave synchronisation to the user of the classs. You don't need synchronisation, if the same object is only accessed from one thread.

Answer 4

You don't required for your situation.

1. if you are accessing the sharable data then you need to wrap by sych block.

In your case, you are accessing the instance variable which is only accessible / visible to only one thread since you are in constructor. You will call constructor , you are allocating the memory and end of method call returning unique pointer to calling method so the pointer/instance is unique for the Thread.

Once the pointer received. if the pointer /object variable shared in multiple threads like this.

Object obj = new Object();
Thread t1 = new Thread(new x(obj)); 
Thread t2 = new Thread(new x(obj));

Class x implements runnable{
 Object obj;
 x (Object obj){
   this.obj = obj;
 }

run() {
 // do some operation on Obj  -
}
}

}

in this case obj is shared across multiple threads , so your instance variable x subject for race condition. So you have make sure to wrap in other methods.

Thats why vector constructor is not having sycn block but other method does.

Assume you have one static variable in this class . then it is required to wrap by sync block since it is accessible to any one.

Answer 5

Constructors should never be synchronized because I guess it is not practical.(When will you need to call a same constructor from different places at a same time?)

Here is the further information: