notify() question from Nikos

[Nidhi Sar]

Hi,

This is a question from Niko's on Threads. What is the result of the following code:

class Job extends Thread {
	private Integer number = 0;

	public void run() {
		synchronized (this) { // line 2
			for (int i = 1; i < 1000000; i++) {
				number++;
			}
			notify();
		}
	}

	public Integer getNumber() {
		return number;
	}
}

public class Stub {
	public static void main(String[] args) throws Exception {
		Job thread = new Job();
		thread.start();
		synchronized (thread) { // line 1
			thread.wait();
		}
		System.out.println(thread.getNumber());
	}
}

    

The possible choices are:
a. It prints 0.
b. It prints 999999.
c. The output is not guaranteed to be any of the above.

The answer is choice b.

But b is guaranteed only if line 1 executes before line 2 and the main thread gets the lock on thread object BEFORE the second thread. That cannot be guaranteed. If the reverse happens & line 2 executes first, the program will basically hang at thread.wait() [since notify() has already happened, and wait() doesn't know that].

So shouldn't the answer be choice c?

[Ankit Garg]

Seems a valid reason to me. To get a guaranteed behavior, the thread.start() statement should be inside the synchronized block in main method...

[Venu Chakravorty]

Taken from K & B (SCJP 1.6) page no.: 748 and 749:

1.  class ThreadA { 
 2.     public static void main(String [] args) { 
 3.        ThreadB b = new ThreadB(); 
 4.        b.start(); 
 5.        
 6.        synchronized(b) { 
 7.           try { 
 8.              System.out.println("Waiting for b to complete..."); 
 9.             b.wait(); 
10.           } catch (InterruptedException e) {} 
11.           System.out.println("Total is: " + b.total); 
12.        } 
13.     } 
14.  } 
15.  
16.  class ThreadB extends Thread {   
17.     int total;
18.     
19.     public void run() { 
20.        synchronized(this) { 
21.           for(int i=0;i<100;i++) { 
22.              total += i; 
23.           } 
24.           notify(); 
25.        } 
26.     } 
27.  } 

This program contains two objects with threads: ThreadA contains the main
thread and ThreadB has a thread that calculates the sum of all numbers from 0
through 99. As soon as line 4 calls the start() method, ThreadA will continue
with the next line of code in its own class, which means it could get to line 11
before ThreadB has finished the calculation. To prevent this, we use the wait()
method in line 9.

Even it is stated that "As soon as line 4 calls the start() method, ThreadA will continue with the next line of code in its own class...". What I do not understand is, how can we be so sure?