0

How can another waiter thread enter the synchronized block, if a waiter thread is already waiting in that block waiting for the notify call?

I have tested with other examples and all other threads seem to wait to enter the synchronized block when one of the threads is in synchronized block and the new thread enters the synchronized block right after the old one leaves the block:

class ThreadClassNotifier implements Runnable {

private Message msg;

public ThreadClassNotifier(Message msg) {
    this.msg = msg;
}

@Override
public void run() {
    String name = Thread.currentThread().getName();
    System.out.println(name+" started");
    try {
        Thread.sleep(1000);
        synchronized (msg) {
            msg.setMsg(name+" Notifier work done");
            msg.notify();
            // msg.notifyAll();
        }
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

}

}

class ThreadClassWaiter implements Runnable {

private Message msg;

public ThreadClassWaiter(Message m){
    this.msg=m;
}

@Override
public void run() {
    String name = Thread.currentThread().getName();
    synchronized (msg) {
        try{
            System.out.println(name+" waiting to get notified at time:"+System.currentTimeMillis());
            Thread.sleep(10000);
            msg.wait();
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(name+" waiter thread got notified at time:"+System.currentTimeMillis());
        //process the message now
        System.out.println(name+" processed: "+msg.getMsg());
    }
}

}

public class ThreadMain {
    public static void main(String[] args) throws InterruptedException {
      Message msg = new Message("process it");
      ThreadClassWaiter waiter = new ThreadClassWaiter(msg);
      new Thread(waiter,"waiter").start();

      ThreadClassWaiter waiter1 = new ThreadClassWaiter(msg);
      new Thread(waiter1, "waiter1").start();
      System.out.println("All the threads are started");

  }

}

1 Answer 1

2

"how come another waiter thread enter the synchronized block,if already a waiter thread is waiting in that block waiting for notify call?"

From the java docs for Object.wait()

The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.

Sign up to request clarification or add additional context in comments.

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.