Using the notifyAll and wait Methods - Java Tutorial 5.0 英文版

Start of Tutorial > Start of Trail > Start of Lesson

Search Feedback Form

Using the notifyAll and wait Methods

Let's investigate how the code in CubbyHole's put and get methods helps the Producer and the Consumer coordinate their activities. The CubbyHole stores its value in a private member variable called contents. CubbyHole has another private member variable, available, a boolean. The available variable is true when the value has been put but not yet gotten and is false when the value has been gotten but not yet put. Here's one possible implementation for the put and get methods.

public synchronized int get() {    //Won't work!
	if (available == true) {
		available = false;
		return contents;
	}
}

public synchronized void put(int value) {    //Won't work!
	if (available == false) {
		available = true;
		contents = value;
	}
}

As implemented, these two methods won't work. Look at the get method. What happens if the Producer hasn't put anything in the CubbyHole and available isn't true? The get method does nothing. Similarly, if the Producer called put before the Consumer got the value, put doesn't do anything.

You really want the Consumer to wait until the Producer puts something in the CubbyHole and the Producer notifies the Consumer when it's done so. Similarly, the Producer should wait until the Consumer takes a value (and notifies the Producer of its activities) before replacing it with a new value. The two threads must coordinate more fully and can use Object's wait and notifyAll methods to do so.

The following new get and put implementations wait on and notify each other of their activities.

public synchronized int get() {
    while (available == false) {
        try {
            //Wait for Producer to put value.
            wait();
        } catch (InterruptedException e) { }
    }
    available = false;
    //Notify Producer that value has been retrieved.
    notifyAll();
    return contents;
}

public synchronized void put(int value) {
    while (available == true) {
        try {
            //Wait for Consumer to get value.
            wait();
        } catch (InterruptedException e) { }
    }
    contents = value;
    available = true;
    //Notify Consumer that value has been set.
    notifyAll();
}

The code in the get method loops until the Producer has produced a new value. Each time through the loop, get calls the wait method. The wait method relinquishes the lock on the CubbyHole held by the Consumer (thereby allowing the Producer to get the lock and update the CubbyHole) and then waits for notification from the Producer. When the Producer puts something in the CubbyHole, it notifies Consumer by calling notifyAll. The Consumer then comes out of the wait state and the get method returns the value in the CubbyHole.

The put method works in a similar fashion. It waits for the Consumer thread to consume the current value before allowing the Producer to produce a new one.

The notifyAll method wakes up all threads waiting on the object in question (in this case, the CubbyHole). The awakened threads compete for the lock. One thread gets it, and the others go back to waiting. The Object class also defines the notify method, which arbitrarily wakes up one of the threads waiting on this object.

The following are the three versions of the wait method contained in the Object class:

• wait(): waits indefinitely for notification. (This method was used in the producer-consumer example.)

• wait(long timeout): waits for notification or until the timeout period has elapsed; timeout is measured in milliseconds.

• wait(long timeout, int nanos): waits for notification or until timeout milliseconds plus nanos nanoseconds have elapsed.

---

Note:  Besides using these timed wait methods to synchronize threads, you also can use them in place of sleep. Both wait and sleep delay for the requested amount of time. You can easily wake up wait with a notify, but a sleeping thread cannot be awakened prematurely. This doesn't matter too much for threads that don't sleep for long, but it could be important for threads that sleep for minutes at a time.

---

Start of Tutorial > Start of Trail > Start of Lesson

Search Feedback Form

Copyright 1995-2005 Sun Microsystems, Inc. All rights reserved.