Chapter 14 ■ ConCurrenCy

public void run() { try {

// wait for the timer count down to reach 0 timer.await();

} catch (InterruptedException ie) {

System.err.println("interrupted -- can't start running the race");

}

System.out.println(this.getName() + " started running");

}

}

This program prints the following:

Carl ready and waiting for the count down to start Joe ready and waiting for the count down to start Jack ready and waiting for the count down to start Starting the countdown

5

4

3

2

1 Start

Joe started running Carl started running Jack started running

Let’s consider how the program works. The class Runner simulates a runner in a running race waiting to start running. It waits for the race to start by calling the await() method on the CountDownLatch object passed through the constructor.

The RunningRaceStarter class creates a CountDownLatch object. This counter object is initialized with the count value 5, which means the countdown is from 5 to 0. In the main() method, you create Runner objects; these three threads wait on the counter object. For each second, you call the countDown() method, which decrements count by 1. Once the count reaches zero, all three waiting threads are released and they automatically continue execution.

Note: In this program, the sequence in which Joe, Carl, or Jack is printed cannot be predicted since it depends on thread scheduling. So, if you run this program, you may get these three names printed in some other order.

Exchanger

The Exchanger class is meant for exchanging data between two threads. What Exchanger does is something very simple: it waits until both the threads have called the exchange() method. When both threads have called the exchange() method, the Exchanger object actually exchanges the data shared by the threads with each other. This class is useful when two threads need to synchronize between them and continuously exchange data.

This class is a tiny class with only one method: exchange(). Note that this exchange() method has an overloaded form where it takes a time-out period as an argument.

Listing 14-3 shows an example simulating silly talk between the Java Duke mascot and the coffee shop. The two threads DukeThread and CoffeeShop threads run independently. However, for a chat to happen, they need to listen when the other is talking. An Exchange object provides a means for them to talk to each other.

440

Chapter 14 ■ Concurrency

Listing 14-3.  KnockKnock.java

import java.util.concurrent.Exchanger;

//The DukeThread class runs as an independent thread. It talks to the CoffeeShopThread that

//also runs independently. The chat is achieved by exchanging messages through a common

//Exchanger<String> object that synchronizes the chat between them.

//Note that the message printed are the "responses" received from CoffeeShopThread

class DukeThread extends Thread {

private Exchanger<String> sillyTalk;

public DukeThread(Exchanger<String> args) { sillyTalk = args;

}

public void run() {

String reply = null; try {

//start the conversation with CoffeeShopThread reply = sillyTalk.exchange("Knock knock!");

//Now, print the response received from CoffeeShopThread System.out.println("CoffeeShop: " + reply);

//exchange another set of messages reply = sillyTalk.exchange("Duke");

//Now, print the response received from CoffeeShopThread System.out.println("CoffeeShop: " + reply);

//an exchange could happen only when both send and receive happens

//since this is the last sentence to speak, we close the chat by

//ignoring the "dummy" reply

reply = sillyTalk.exchange("The one who was born in this coffee shop!");

//talk over, so ignore the reply!

}catch(InterruptedException ie) {

System.err.println("Got interrupted during my silly talk");

}

}

}

class CoffeeShopThread extends Thread { private Exchanger<String> sillyTalk;

public CoffeeShopThread(Exchanger<String> args) { sillyTalk = args;

}

public void run() {

String reply = null; try {

// exchange the first messages

reply = sillyTalk.exchange("Who's there?"); // print what Duke said System.out.println("Duke: " + reply);

441

Chapter 14 ■ Concurrency

// exchange second message

reply = sillyTalk.exchange("Duke who?"); // print what Duke said System.out.println("Duke: " + reply);

//there is no message to send, but to get a message from Duke thread,

//both ends should send a message; so send a "dummy" string

reply = sillyTalk.exchange(""); System.out.println("Duke: " + reply);

} catch(InterruptedException ie) {

System.err.println("Got interrupted during my silly talk");

}

}

}

//Coordinate the silly talk between Duke and CoffeeShop by instantitaing the Exchanger object

//and the CoffeeShop and Duke threads

class KnockKnock {

public static void main(String []args) {

Exchanger<String> sillyTalk = new Exchanger<String>(); new CoffeeShopThread(sillyTalk).start();

new DukeThread(sillyTalk).start();

}

}

The program prints the following:

Duke: Knock knock! CoffeeShop: Who's there? Duke: Duke

CoffeeShop: Duke who?

Duke: The one who was born in this coffee shop!

The comments inside the program explain how the program works. The main concept to understand with this example is that Exchanger helps coordinate (i.e., synchronize) exchanging messages between two threads. Both the threads wait for each other and use the exchange() method to exchange messages.

CyclicBarrier

There are many situations in concurrent programming where threads may need to wait at a predefined execution point until all other threads reach that point. CyclicBarrier helps provide such a synchronization point; see Table 14-3 for the important methods in this class.

442

Listing 14-4 is an example that makes use of CyclicBarrier class.

Listing 14-4.  CyclicBarrierTest.java

import java.util.concurrent.*;

//The run() method in this thread should be called only when four players are ready to start the game class MixedDoubleTennisGame extends Thread {

public void run() {

System.out.println("All four players ready, game starts \n Love all...");

}

}

//This thread simulates arrival of a player.

//Once a player arrives, he/she should wait for other players to arrive

class Player extends Thread { CyclicBarrier waitPoint;

public Player(CyclicBarrier barrier, String name) { this.setName(name);

waitPoint = barrier; this.start();

}

public void run() {

System.out.println("Player " + getName() + " is ready ");

443