synchronized( obj ) block in java when obj can be null

Question

• I have a java synchronized( obj ) {... } block which works fine.
• I want to extend its behavior so that whenever synchronized( obj == null ) is called, the entire block is skipped.
• Currently I get a null pointer exception.
• Is there any way to achieve this with synchronized(... ) {... } block?

Answer 1

There is no simple way to achieve this directly through the sync block.

You either do some if magic before the block or you delegate this whole thing to a dedcated class or method. In all cases, the actual lock monitor must never be null .

An example, instead of having the actual monitor being null , you move this logic one below and wrap the class.

public class NullableMonitor {
    private Object monitor;

    // constructor

    public boolean isPresent() {
        return monitor != null;
    }

    // dont forget the synchronized
    public synchronized void setMonitor(Object monitor) {
        this.monitor = monitor;
    }
}

And then in your sync block you use this as monitor.

final NullableMonitor monitor = new NullableMonitor(myObject);
...
synchronized (monitor) {
    if (monitor.isPresent()) {
        return;
    }
    ...
}

It is critical though that the setter in NullableMonitor is synchronized on itself, otherwise someone can mess with the monitor between entering and the if-check.

This has as consequence though that you can not call it from within your sync block.

---

Note that your overall concept seems to be flawed and appears very dangerous. There is a reason why people are saying that a monitor/lock for a sync must never be null and should always be final . The monitor should not be changed, you can easily mess up your logic and run into different issues by that.

Answer 2

private void doStuff(Object lock) {
    if (lock == null) return;
    synchronized(lock) {
        // doStuff
    }
}

I think the easiest way is to define a private method handling this logic. Furthermore one could replace the task to execute with a functional interface and pass the behavoir as a parameter for multiple usage.

interface Wrapper<R,T> {
    public abstract R execute(List<T> args) throws Exception;
}

Wrapper<String, String> wrapper = new Wrapper() {
    @Override
    public String execute(List<String> input) {
        // business code
    }
}

private <R,T> R doStuff(Object lock, Wrapper<R,T> w) throws Exception {
    if (lock == null) return null;
    synchronized(lock) {
        return w.execute();
    }
}

If you do not rely on a dedicated lock object, you can also use:

synchronized(this){..} // this refers to instance of this class
synchronized(MyClass.class){..} // for static usecase

Answer 3

The tricky thing is that the object reference may change between the null check and the synchronization. So I would suggest the following:

    var freezeObj = obj; // assuming obj is volatile
    if (freezeObj != null) {
      synchronized (freezeObj) {
        // ...
      }
    }

Answer 4

It would be better to use Lock class from java instead of Object class..

  public void doStuff(Lock lock){
      lock.lock();
      //doStuff
      lock.unlock();
  }