Static members need special synchronization blocks?

Question

I have a class which looks something like this:

public class Test {

private static final Object someObject = new Object();

public void doSomething()
{
 synchronized (someObject) {
  System.out.println(someObject.toString());
 }
}

}

Can I consider the object to be synchronized, or is there a problem since it is a static member?

Edit: note that different threads might be accessing doSomething() and the object must be accessed in a thread-safe manner in that case.

Answer 1

By using a static object as your monitor object, only one thread using ANY instance of the Test class can get into the sync block. If the monitor object was not a static object, other threads holding different instances of the Test class could get into the sync block.

Answer 2

Here someObject is acting as a lock (monitor) for all objects of type Test. That is, if doSomething() is invoked on two separate instances of Test, one will block before the other completes. This is different from a synchronized method which which is mostly equivalent to the code above with someObject replaced by this.

Changing someObject to non-static will result in per--instance locking. This is essentially the "private lock object" idiom as described in item 70 of Effective Java.

Answer 3

A common pattern for getting a class-specific instance-independent lock like this is to use the Class object itself:

public class Test {
  public void doSomething() {
    synchronized (Test.class) {
      // something
    }
  }
}

which is effectively what a synchronized static method does. Of course if you want more than one lock like this, you'll need to declare them as static fields as in your example.