Question on example from "Java concurrency in practice"

Question

"Java concurrency in practice" 14.9 listing ( [Orig here|http://www.javaconcurrencyinpractice.com/listings/ThreadGate.java] ):
+...The condition predicate used by await is more complicated than simply testing isOpen. This is needed because if N threads are waiting at the gate at the time it is opened, they should all be allowed to proceed. But, if the gate is opened and closed in rapid succession, all threads might not be released if await examines only isOpen: by the time all the threads receive the notification, reacquire the lock, and emerge from wait, the gate may have closed again. So ThreadGate uses a somewhat more complicated condition predicate: every time the gate is closed, a "generation" counter is incremented, and a thread may pass await if the gate is open now or if the gate has opened since this thread arrived at the gate...+
public class ThreadGate {
    private boolean isOpen;
    private int generation;
    public synchronized void close() {
        isOpen = false;
    public synchronized void open() {
        ++generation;
        isOpen = true;
        notifyAll();
    public synchronized void await() throws InterruptedException {
        int arrivalGeneration = generation;
        while (!isOpen && arrivalGeneration == generation) {
            wait();
Question:
Guys, could anyone explain me
1) the work of code in term of "thread T1 waits, thread T2 closes..." the part arrivalGeneration == generation is unclear?
2) Why both english and french editions say "every time the gate is closed, a generation counter is incremented"? How this is possible?
3) Give an example how "the gate may have closed again" ? How this is possible?
I posted this in other forums, but never had any explanations. Thanks.
Edited by: maxim_2004 on Jul 14, 2010 9:19 AM

Answer 1

Generation is a counter of how many times the gate has opened. We use it to determine if the gate has opened since a waiting thread arrived. The criteria for a waiting thread to proceed is not, "Is the gate open now?" but rather "Has the gate opened at least once since this thread started waiting?"
Say you have N waiting threads and one controller thread. When the controller thread calls open(), we want all N waiting threads to be able to proceed. But the controller thread may call close() at any time, and depending on when he calls close(), how many waiting threads there are (that is, how large N is) and how the scheduler on that JVM/OS is operating, the controller thread may call close() before all of the waiting threads have completed the await() method.
So a waiting thread may be stuck in the while loop call wait(), and by the time he has been notified, gets CPU cycles, acquires the lock, and goes back to test isOpen, the gate may have opened and closed. But we want him to be able to go, just because the gate did open. We don't care if he didn't get through before it closed again--he's supposed to be able to go anyway.
Therefore, we don't just wait if the gate is closed. We wait if the number of times it has opened is the same as when we arrived. In other words we wait only, if it hasn't opened since this waiting thread arrived.
Gate opens 1st time. (generation = 1)
Gate closes.
Gate opens 2nd time. (gen = 2)
T2 arrives. (arrivalGen = 2)
T2 calls wait()
Gate opens 3rd time. (gen = 3)
Gate closes.
T2 gets CPU time and lock. Executes while test. Gate is closed. BUT gen=3 and arrivalGen=2, so even though the gate is closed now, it has opened since T2 arrived, so T2 is allowed to proceed (arrivalGen != gen)
Edited by: jverd on Jul 14, 2010 10:05 AM
Edited by: jverd on Jul 14, 2010 10:08 AM