KnB notify(), wait(), synchronized block

[Richard Teston]

In the following code:

public class IntCode09{
public static void main(String[] args){
JobRunnable r = new JobRunnable();
Thread t = new Thread(r,"Job 1");
t.start();
synchronized(r){
try{
System.out.println("Thread is currently waiting --> "+ Thread.currentThread().getName());
r.wait();
}catch(InterruptedException ie){}
System.out.println(r.x);
}
}
}
class JobRunnable implements Runnable{
public int x;
public void run(){
synchronized(this){
for(int i=0;i<100;i++){
x+=2;
try{
Thread.sleep(50);
}catch(InterruptedException ie){}
}
notify();
}
}
}

I know when you call wait() method the thread that get holds of the lock releases the lock but in this case when synchronized(r)invoked means the main user-thread acquire the lock on the r object (before r.wait() is been called) which job1 user-thread already acquired the lock.
Isn't it that object has only one lock? Em i missing something out here?

[Dhanashree Mankar]

i think your code is perfectly all right
thread scheduling is platform dependent. so which thread will start executing first we cann't say. i executed this code on my system here main thread is firstly getting a lock on object r . when it enters into wait state child thread gets entry in synchronised method in JobRunnable class.
then it notifies main thread , completes it's execution and then main thread starts and completes.
May be sometimes child thread gets the lock first. In that case when it enters into sleep state ,main thread will get the lock and then will enter into wait. again when child comes out of sleep it will notify main .

[Barkat Mardhani]

I was going through some old thread related posts for more practice. Found this one which I do not completely agree:

May be sometimes child thread gets the lock first. In that case when it enters into sleep state ,main thread will get the lock and then will enter into wait. again when child comes out of sleep it will notify main .

My points:
1. When a thread goes to sleep, it takes lock with it.
2. After child thread will wake from sleep naturally, it will be dead.
3. Then main thread will resume.
4. It will wait for ever because there is no live thread to notify it.

public class Test{
public static void main(String[] args){
JobRunnable r = new JobRunnable();
Thread t = new Thread(r,"Job 1");
t.start();
try{ Thread.sleep(1000); } catch(InterruptedException ie) { }
synchronized(r){
try{
System.out.println("Thread is currently waiting --> "+ Thread.currentThread().getName());
r.wait();
}catch(InterruptedException ie){}
System.out.println(r.x);
}
}
}
class JobRunnable implements Runnable{
public int x;
public void run(){
synchronized(this){
System.out.println("Thread is currently running thread is --> "+ Thread.currentThread().getName());
for(int i=0;i<100;i++){
x+=2;
try{
Thread.sleep(50);
}catch(InterruptedException ie){}
}
notify();
}
}
}