Question

I was wondering why threads spontaneously awake from wait() in java.
Is it a design decision? Is it a compromise?

EDIT: (from Java Concurrency in Practice, p. 300)

wait is even allowed to return
“spuriously” – not in response to any
thread calling notify.

Further the authors state:

this is like a toaster with a loose
connection that makes the bell go off
when the toast is ready but also
sometimes when it is not ready.

This is why you always have to code like

synchronized(this){
    while(!condition)
        wait();
    }
}

and never

synchronized(this){
    if(!condition){
        wait();
    }
}

Even if the condition transitions only from
false to true.

Answer 1

These spontaneous wakeups are also called “spurious wakeups”. In the Java specification, the spurious wakeups are permitted (though not encouraged) for jvm implementations.

The reason they are permitted is because many implementations may be based on pthreads (POSIX threads), that have this behaviour. Why?

Wikipedia:

According to David R. Butenhof’s
Programming with POSIX Threads ISBN
0-201-63392-2: “This means that when
you wait on a condition variable, the
wait may (occasionally) return when no
thread specifically broadcast or
signalled that condition variable.
Spurious wakeups may sound strange,
but on some multiprocessor systems,
making condition wakeup completely
predictable might substantially slow
all condition variable operations. The
race conditions that cause spurious
wakeups should be considered rare.”