wait/notify. Why all threads are getting notified?

Question

Here is a code snippet

public class ITC3 extends Thread {
  private ITC4 it;

  public ITC3(ITC4 it){
    this.it = it;
  }
  public static void main(String[] args) {
    ITC4 itr = new ITC4();
    System.out.println("name is:" + itr.getName());
    ITC3 i = new ITC3(itr);
    ITC3 ii = new ITC3(itr);


    i.start(); ii.start();
    //iii.start();
    try{
      Thread.sleep(1000);
    }catch(InterruptedException ie){}
    itr.start();
  }

  public void run(){
    synchronized (it){
      try{

        System.out.println("Waiting - " + Thread.currentThread().getName());
        it.wait();
        System.out.println("Notified " + Thread.currentThread().getName());
      }catch (InterruptedException ie){}
    }
  }
}

class ITC4 extends Thread{
  public void run(){
    try{
      System.out.println("Sleeping : " + this);
      Thread.sleep(3000);
      synchronized (this){
        this.notify();
      }
    }catch(InterruptedException ie){}
  }
}

Output given is

Output: 
Waiting - Thread-1 
Waiting - Thread-2 
Sleeping : Thread[Thread-0,5,main] 
Notified Thread-1 
Notified Thread-2

In this all threads are getting notified. I am unable to understand the whole output in this case.

Why all threads are getting notified?
Why Sleeping is printing `Thread[Thread-0,5,main]
Pretty lost in whole working of the program.

Any pointers would be helpful.

Thanks.

See also: http://stackoverflow.com/questions/16955006/java-synchronization-is-doing-auto-notify-on-exit-is-this-expected — Raedwald, Aug 09 '13 at 12:20
By the way, this code will never do anything sensible because your `synchronized` blocks don't protect any shared state. — David Schwartz, Aug 28 '17 at 09:30

Marko Topolnik · Accepted Answer · 2013-08-09T11:25:08.540

3

You are synchronizing on an instance of Thread. If you check the documentation, you'll see that the Thread instance is notified when its run method completes. This is how the join mechanism is implemented.

You execute one explicit notify call (the one we see in the code), and another implicit notifyAll when the thread is done. You could even remove your explicit notify and the behavior wouldn't change due to the implicit notifyAll at the end.

edited Aug 09 '13 at 11:25

answered Aug 09 '13 at 11:13

Marko Topolnik

195,646
29
319
436

i have a question as the itr instances is shared between two threads, will two threads block each other? – benz Aug 09 '13 at 11:16
I don't understand what you mean by "block each other". They are two threads waiting on the same monitor. – Marko Topolnik Aug 09 '13 at 11:17
they two are waiting at the same Object, so one should get notified not both, because we are not using notifyAll() here. – benz Aug 09 '13 at 11:19
Exactly. My answer explains the rest. – Marko Topolnik Aug 09 '13 at 11:19
where in documentation it is written that Thread() instance is notified when run() method completes. I am just trying to check the javadoc. can you provide me the reference of it? – benz Aug 09 '13 at 11:21
It's documented in the `join` method. Check the link in my answer under the text "the documentation". – Marko Topolnik Aug 09 '13 at 11:24
thankyou very much. I understood the whole concept now. Thankyou so much. – benz Aug 09 '13 at 11:27
I am sorry i had commented itr.start(). Anyhow thankyou very much. – benz Aug 09 '13 at 11:36

score 1 · Answer 2 · answered Aug 09 '13 at 11:24

1

already answered, but you should not syncronize on Thread object.
Thread's toString() method returns names of all threads in his ThreadGroup, not only name of current thread.

answered Aug 09 '13 at 11:24

Alexander Kudrevatykh

870
1
5
13

wait/notify. Why all threads are getting notified?

2 Answers2