public class Reader extends Thread {
  Calculator c;
  public Reader(Calculator calc, String name) {
     c = calc;
     setName(name);
  }

  public void run() {
     synchronized(c) {
        try {
           System.out.println(getName()+" Waiting for calculation...");
           c.wait();
        } catch (InterruptedException e) {}
     }
     System.out.println( getName()+" cal.total: " + c.total);
  }

  public static void main(String [] args) {
     Calculator calculator = new Calculator();

     new Reader(calculator, "1").start();
     new Reader(calculator, "2").start();
     new Reader(calculator, "3").start();
     new Reader(calculator, "4").start();
     new Reader(calculator, "5").start();

      calculator.start();
  }
}

class Calculator extends Thread {
  int total;

  public void run() {

    System.out.println("Starting calculating ...");

    synchronized(this)
    {
      for (int i = 0; i < 100; i++) {
        total += i;
      }
      try {
         wait(1000);
      } catch (InterruptedException e ) {}

    }

  }
}

nov1 wrote:
When a thread exits, it will issue a notify()/notifyAll() on objects from which it has occurred a lock.

public class Reader
extends Thread 
{
    Calculator c;
    
    public Reader(Calculator calc, String name) 
    {
        c = calc;
        setName(name);
    }
    
    public void run() 
    {
        synchronized(c.lock) 
//        synchronized(c)
        {
            try 
            {
                System.out.println(getName()+" Waiting for calculation...");
                c.lock.wait();
//                c.wait();
            }
            catch (InterruptedException e) 
            {}
        }
        System.out.println( getName() + " cal.total: " + c.total);
    }
    
    public static void main(String [] args) 
    {
        Calculator calculator = new Calculator();
        
        calculator.start();
        
        new Reader(calculator, "1").start();
        new Reader(calculator, "2").start();
        new Reader(calculator, "3").start();
        new Reader(calculator, "4").start();
        new Reader(calculator, "5").start();
    }
}

class Calculator
extends Thread
{
    public Object lock = new Object();
    
    int total;
    
    public void run() 
    {
        try 
        {
            Thread.sleep(1000);
        }
        catch (InterruptedException e ) 
        {}
        
        System.out.println("Starting calculating ...");
        
        synchronized(this.lock) 
//        synchronized(this) 
        {
            for(int i = 0; i < 100; i++) 
            {
                total += i;
            }
        }
    }
}

nov1 wrote:
There are three issues here:

1, The mechanism of a dying thread releasing locked resources
2, The mechanism of a dying thread notifying other threads
3, The criteria of objects being selected for step 1 and 2

rostone wrote:
Maybe it is correct.But it can not explain this phenomena.
If we comment the "synchronized" sentence as below:

class Calculator extends Thread
{
int total;
public void run()
{
System.out.println("Starting calculating ...");
/*
synchronized(this)
{
for (int i = 0; i < 100; i++)
{
total += i;
}
try
{
wait(1000);
}
catch (InterruptedException e )
{
}
}*/
}
}

The calculator thread didn't lock any object.So it would not call any notify as you expected when it expired.

But you can see the same result.

nov1 wrote:
There are three issues here:

1, The mechanism of a dying thread releasing locked resources
2, The mechanism of a dying thread notifying other threads
3, The criteria of objects being selected for step 1 and 2

I do not want to talk too much about low level implementation, let us focus on things at API level.

Java use keyword synchronized to explicitly lock on an object, lock is put when entering synchronized method or block, and released when exiting the method or block. Keyword synchronized has a built-in function which to notify other threads who also use keyword synchronized.

Wait and notify rely on synchronized machanism, an object is not allowed to wait or notify if it has yet been keyword synchronized, namely not been locked by keyword synchronized. But wait/notify is different from a lock, because wait/notify is not a lock but a communication among threads.

Now it's clear that wait/notify is a communication tool among threads. Keyword synchronized IMPLICITLY use this tool automatically talk with other threads' keyword synchronized. But it does not affect threads who EXPLICITLY use wait/notify.

Besides keyword synchronized and explicit wait/notify calls, another implicit client of this communication tool is a dying thread.

As to my knowledge, for step 3, only the object on which the dying thread was running would be selected. On this object, the dying thread will issue a notify to other threads who have been forced sleep by either keyword synchronized or wait method. The purpose of the last message is to avoid dead lucks.

This means I was wrong on one thing, I said:

"When a thread exits, it will issue a notify()/notifyAll() on objects from which it has occurred a lock."

A dying thread does not issue a notify for objects it once locked. I can testify it by following program:

It does not issue a notify for object c.lock, though it had a lock on it.

public class Reader
extends Thread 
{
    Calculator c;
    
    public Reader(Calculator calc, String name) 
    {
        c = calc;
        setName(name);
    }
    
    public void run() 
    {
        synchronized(c.lock) 
//        synchronized
        {
            try 
            {
                System.out.println(getName()+" Waiting for calculation...");
                c.lock.wait();
//                c.wait();
            }
            catch (InterruptedException e) 
            {}
        }
        System.out.println( getName() + " cal.total: " + c.total);
    }
    
    public static void main(String [] args) 
    {
        Calculator calculator = new Calculator();
        
        calculator.start();
        
        new Reader(calculator, "1").start();
        new Reader(calculator, "2").start();
        new Reader(calculator, "3").start();
        new Reader(calculator, "4").start();
        new Reader(calculator, "5").start();
    }
}

class Calculator
extends Thread
{
    public Object lock = new Object();
    
    int total;
    
    public void run() 
    {
        try 
        {
            Thread.sleep(1000);
        }
        catch (InterruptedException e ) 
        {}
        
        System.out.println("Starting calculating ...");
        
        synchronized(this.lock) 
//        synchronized(this) 
        {
            for(int i = 0; i < 100; i++) 
            {
                total += i;
            }
        }
    }
}