Thread doubt?

[Joe San]

Hi Ranchers,

The following question is from K&B book page 738,

Assume the following method is properly synchronized and called from a thread A on an object B

wait(2000);

After calling this method, when will the thread A become a candidate to get another turn at the CPU?

Can anyone help me realize the above through code and I'm little bit scary at the bold portion above. If I can get an explanation in the form of a code that will really help me understand synchronization concept to its depth. Ranchers, please help me...

Thanks in advance for the help.

[Burkhard Hassel]

Hi Jothi,

it means that thread A is in a synchronized block, that has been synchronized on object b.
It enters the waiting room of object b and waits there
a) until some other thread notifies one or all waiting threads in the waiting room of object b and so our thread.
or
b) 2000 milliseconds are over.

Here's an example code. It's a bit long, but shows the two possibilities.
In the part above the sleep in the main method a thread doesn't get notified, and in the part below a thread waits, but becomes notified and ends earlier.

public class Main {
B b = new B();
 
public static void main(String[] args) {
Main main = new Main();
long startMillis = System.currentTimeMillis();
// handing over start point, common object and name
A a = new A(startMillis, main.b, "A");
a.start();
try {
Thread.sleep(5000);
} catch (InterruptedException ie) {
ie.printStackTrace();
}
A other = new A(System.currentTimeMillis(), main.b, "other");
A2 notifier = new A2(System.currentTimeMillis(), main.b, "notifier");
other.start();
notifier.start();
}
}
 
class B { // just for an object named b
}
 
class A extends Thread {
private B b;
 
private long start;
 
A(long start, B commonObject, String name) {
this.start = start;
b = commonObject;
this.setName(name);
}
 
public void run() {
System.out.println("Thread " + this.getName() + " started at 0 ms");
synchronized (b) {
try {
b.wait(2000);
} catch (InterruptedException ie) {
ie.printStackTrace();
}
System.out.print("Thread " + this.getName());
System.out.printf(" after waiting: %d ms%n"
, System.currentTimeMillis() - start);
}
}
}
 
class A2 extends Thread {
private B b;
 
private long start;
 
A2(long start, B commonObject, String name) {
this.start = start;
b = commonObject;
this.setName(name);
}
 
public void run() {
synchronized (b) {
System.out.print("\tThread "+this.getName()
+ " started");
System.out.printf(" at %d ms.%n"
, System.currentTimeMillis()-start);
try {
sleep(300);
} catch (InterruptedException ie) {
ie.printStackTrace();
}
// wakes up a thread that waits at object b
b.notify();
System.out.print("\tThread "+this.getName() 
+ " notified common object at ");
System.out.printf(" at %d ms.%n"
, System.currentTimeMillis()-start);
}
}
}
 

The sleep in the main method only seperates the two versions. I don't provide the output. Try it to see the timing.


Yours,
Bu.

[Joe San]

Bu,

Thanks for the example. Your explanations are really helping me to understand. Particularily, your garbage collection diagram was really understandable and I can now easily tweak out questions related to gc. Hope that after trying out the above code, I will be comfortable with synching threads as well.

Thanks once again.