Re: Understanding java.lang.Object.wait()
Aria <maps.this.address@gmail.com> writes:
On Jun 27, 1:21 am, Owen Jacobson <angrybald...@gmail.com> wrote:
On Jun 26, 7:01 pm, Aria <maps.this.addr...@gmail.com> wrote:
Now, I understand that notifyAll() ONLY notifies other threads
blocking on this object that the current thread is done with the
object is "ready" to release the lock. That is the actual release of
the lock occurs AFTER the code is out of synchronized block.
Having said that, what exactly happens when the waiting threads
receive such notification? That is:
// Other threads running block
public void run() {
synchronized (obj) {
while (some condition not being met) {
try {
obj.wait();
// (1)
} catch (InterruptedException ie) { }
// Some code to process
}
}
}
When "ALL THE THREADS" receive such signal, do they all "get out" of
wait() method and then whoever wins the contention would gets the lock
and the rest are put on the waiting list once they "failed" the
condition?
No, they come out of the wait, but halt at the next statement (1), because
they do not have the lock. They don't get to "condition" yet.
It's a little hard to interpret this, but it sounds right.
When you call notifyAll on an object, every thread that's wait()ing on
that object resumes and tries to reaquire the monitors they held,
blocking if necessary until another thread releases those monitors.
The contract for a monitor is that at most one thread can hold it at a
time; this is enforced by the JVM.
If several threads that held the same monitor are awoken at the same
time, they will run "one at a time" through the parts of their
executions that hold that monitor. None of them will be put back to
waiting on the object.
But since they are all in a synchronized block, only one can run - the one who
owns the monitor.
So according to your statement, every time blocking threads are
signaled, ALL of them gets out of obj.wait(), "try" to acquire the
lock on the object, and only one would prevail. Which brings us to the
question I asked, they ALL get to their line (1) after each
notification and only put on the waiting list due to the while
(condition not being met). Is that a correct interpretation?
No. As above, they do not wait because they do another while-iteration, but
because they are in a synchronized block and wait for the lock immediately
after the wait.
[...]
So my question pretty much boils down to this: When a notification
occurs, do ALL waiting threads execute line [b](1)[/b] regardless of
whether win the contention and only to be put back on the waiting list
after failing the while (condition not being met)?
No. Only one executes it. Why don't you write a simple test program?
public static void main(String[] argv) {
final Object o = new Object();
Thread t1 = new Thread() {
public void run() {
synchronized (o) {
try {
o.wait();
System.out.println(this);
Thread.sleep(1000);
}
catch (InterruptedException e) {
}
}
}
};
t1.start();
Thread t2 = ... // as t1
Thread t3 = new Thread() {
public void run() {
synchronized (o) {
o.notifyAll();
}
}
};
t3.start();
}
You will see the prints come in 1s separated, your interpretation would expect
them to show up immediately.
Michael