Question

I don’t understand what is wrong with this code. Sometimes two threads start executing the try block. I am creating a new instance of popo every time I call the function. Can please anybody figure out what the problem is?

public class Instance {
  private static AtomicInteger i = new AtomicInteger(0);

  public synchronized void incrementInstance() {
    i.getAndIncrement();
  }

  public synchronized void decrementInstance() {
    i.getAndDecrement();
  }

  public synchronized int getInstances() {
    return i.get();
  }
}

public class popo {
  private static volatile MyMutex instanceMutex = new MyMutex();

  public void doSomething() {
    synchronized (instanceMutex) {
      final Instance no = new Instance();
      if (no.getInstances() > 0) {
         instanceMutex.wait();
      } else {
         no.incrementInstance();
      }
    }

    try {
     // do something
    } finally {
        synchronized (instanceMutex) {
          final Instance no = new Instance();
          if (no.Instances() > 0) {
            no.decrementInstance();
          }
          instanceMutex.notify();
        }
     }
  }
  private static class MyMutex {}
}

Answer 1

I think the code smells all over the place 🙂 Actually, doing things like creating new instances that do nothing more than access a static field make things confusing (see previous responses). So, this is what I suggest:

1. You should avoid using wait/notify if you are writing new code. Take a look to the concurrent package and to the Item69 in the Effective Java book.
2. Based on what I understand from your code, you need a Semaphore like:

static final Semaphore SEMAPHORE = new Semaphore(1);
...

SEMAPHORE.take(); // blocks, only one thread is allowed to proceed

try{
   //critical section
} finally {
    SEMAPHORE.release(); // never blocks, always within a finally block
}

Then you can use the method getQueueLength() to know how many threads are waiting and replace the AtomicInteger you are using. See http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/Semaphore.html

1. Consider using an executor. Then, once you submit the task, you can wait for the Future.
2. If you still want to use wait/notify, make sure to put all the code within the synchronized block and to use the standard idiom (Item69 from Effective Java):

synchronized(instanceMutex) {
    while(< condition does not hold >) {
        obj.wait();
    }

    // Perform required actions
}