Activity 8.6 - Running the greedy consumers

Topic

This activity uses the methods wait() and notifyAll() which all classes inherit from Object.

Materials

In addition to the Solution document, the project for this activity contains three classes:

• SweetJar;
• Consumer;
• Main.

Task

Class SweetJar models a container for sweets and has:

• A data field int numberOfSweets that keeps track of the number of sweets currently in the jar;
• A public method eatSweet which allows another object (i.e. a consumer) to eat a sweet from the jar.

Class Consumer extends Thread and models a greedy sweet lover who will just keep eating sweets as long as any are left in the jar.

Class Main creates a jar with 20 sweets in, then creates two consumer threads and sets them executing. These consumer threads will compete with one another, each attempting to grab as many as possible of the 20 sweets.

In its current form, the program allows the running thread to go on gobbling up sweets one after another, and possibly consume them all before the other thread can even get a look in.

The objective is to amend the class SweetJar so that the two threads must take turns to eat just one sweet at a time, thus ensuring a fair distribution.

Instructions

Run the program.

Notice that because the two threads are uncoordinated at the moment the thread that first gets to run will swallow up most of the 20 sweets (perhaps all of them) before the other thread can get a look in. Our output began like this:

Consumer 1 eats sweet 20 - yummy!
Consumer 1 eats sweet 19 - yummy!
Consumer 1 eats sweet 18 - yummy!
Consumer 1 eats sweet 17 - yummy!
Consumer 1 eats sweet 16 - yummy!
Consumer 1 eats sweet 15 - yummy!
Consumer 1 eats sweet 14 - yummy!
Consumer 1 eats sweet 13 - yummy!
Consumer 1 eats sweet 12 - yummy!
Consumer 1 eats sweet 11 - yummy!
Consumer 1 eats sweet 10 - yummy!
Consumer 1 eats sweet 9 - yummy!

As you see, the first consumer has already eaten more than half the contents of the jar!

To prevent this greedy behaviour you will need to change the class SweetJar as follows:

• A new variable int turn is required to keep track of the id of the thread which is entitled to go next.
• The method eatSweet must be declared synchronized; this is so we can call wait and notifyAll.
• Extra code must be added to the body of the method eatSweet:
  • If a thread attempts to eat a sweet out of turn then wait must be called and the thread will block;
  • When a thread is the one entitled to go next then it can execute the method and eat a sweet. Before the method returns it must change turn to indicate that the opposing thread is now entitled to eat the next sweet, and call notifyAll to make other threads runnable, if they are currently blocked.
  The four locations in SweetJar where new code is necessary are indicated by comments.
• Because wait can throw an exception, it must be enclosed in a try block, with a corresponding catch.
• Make the necessary alterations to SweetJar and test your code. You should now see the sweets being shared fairly:

  Consumer 1 eats sweet 20 - yummy!
  Consumer 2 eats sweet 19 - yummy!
  Consumer 1 eats sweet 18 - yummy!
  Consumer 2 eats sweet 17 - yummy!
  etc.

• Having tested your code, take a good look at the last line of the output from your program. Does it say that 'sweet 0 was eaten'? If so, try to work out how this is possible and figure out what amendments you would need to make to your code to avoid such behaviour. You may want to add various println statements to your code, to trace which thread is executing, and how many sweets there are at that point.