HorseRace example from Thinking in Java

[Vladimir Mokrozub]

Hello,

I have a question about a HorseRace example from Bruce Eckel's Thinking in Java.

class Horse implements Runnable {
	private static int counter = 0;
	private final int id = counter++;
	private int strides = 0;
	private static Random rand = new Random(47);
	private static CyclicBarrier barrier;

	public Horse(CyclicBarrier b) {
		barrier = b;
	}

	public synchronized int getStrides() {
		return strides;
	}

	public void run() {
		try {
			while (!Thread.interrupted()) {
				synchronized (this) {
					strides += rand.nextInt(3); // Produces 0, 1 or 2
				}
				barrier.await();
			}
		} catch (InterruptedException e) {
			// A legitimate way to exit
		} catch (BrokenBarrierException e) {
			// This one we want to know about
			throw new RuntimeException(e);
		}
	}

	public String toString() {
		return "Horse " + id + " ";
	}

	public String tracks() {
		StringBuilder s = new StringBuilder();
		for (int i = 0; i < getStrides(); i++)
			s.append("*");
		s.append(id);
		return s.toString();

	}
}

public class HorseRace {
	static final int FINISH_LINE = 75;
	private List<Horse> horses = new ArrayList<Horse>();
	private ExecutorService exec = Executors.newCachedThreadPool();
	private CyclicBarrier barrier;

	public HorseRace(int nHorses, final int pause) {
		barrier = new CyclicBarrier(nHorses, new Runnable() {
			public void run() {
				StringBuilder s = new StringBuilder();
				for (int i = 0; i < FINISH_LINE; i++)
					s.append("="); // The fence on the racetrack
				println(s);
				for (Horse horse : horses)
					println(horse.tracks());
				for (Horse horse : horses)
					if (horse.getStrides() >= FINISH_LINE) {
						println(horse + "won!");
						exec.shutdownNow();
						return;
					}
				try {
					TimeUnit.MILLISECONDS.sleep(pause);
				} catch (InterruptedException e) {
					println("barrier-action sleep interrupted");
				}
			}
		});
		for (int i = 0; i < nHorses; i++) {
			Horse horse = new Horse(barrier);
			horses.add(horse);
			exec.execute(horse);
		}
	}

	public static void main(String[] args) {
		int nHorses = 7;
		int pause = 200;
		if (args.length > 0) { // Optional argument
			int n = new Integer(args[0]);
			nHorses = n > 0 ? n : nHorses;
		}
		if (args.length > 1) { // Optional argument
			int p = new Integer(args[1]);
			pause = p > -1 ? p : pause;
		}
		new HorseRace(nHorses, pause);
	}
}

The question is: why do we need to synchronize strides field in the Horse class? The only two threads that have access to it are Horse itself and Runnable in CyclicBarrier. And the documentation for CyclicBarrier says:

A CyclicBarrier supports an optional Runnable command that is run once per barrier point, after the last thread in the party arrives, but before any threads are released. This barrier action is useful for updating shared-state before any of the parties continue.

As far as I understand, this means that when the last active Horse thread calls await and goes to sleep, CyclicBarrier runs its Runnable before any Horse threads are awakened so there will be no collision when accessing strides. Am I right?

[Ranganathan Kaliyur Mannar]

Hi,
Welcome to the Ranch!

Your understanding is not right. You have quoted the CyclicBarrier API - it says "an optional Runnable command that is run once per barrier point" - what is your 'barrier point' here?

[Vladimir Mokrozub]

Well, the barrier point is reached when each Horse makes one stride, following which they all goes into a blocking state and CyclicBarrier performs its action and then releases threads.
BTW, I've changed the code to make some observations:

Horse class:

public void run() {
		try {
			while (!Thread.interrupted()) {
				// added
				print("Thread " + id + ", ");
				//
				strides += rand.nextInt(3); // Produces 0, 1 or 2
				barrier.await();
			}
		} catch (InterruptedException e) {
			// A legitimate way to exit
		} catch (BrokenBarrierException e) {
			// This one we want to know about
			throw new RuntimeException(e);
		}
	}

CyclicBarrier:

barrier = new CyclicBarrier(nHorses, new Runnable() {
			public void run() {
				for (Horse horse : horses)
					if (horse.getStrides() >= FINISH_LINE) {
						println(horse + "won!");
						exec.shutdownNow();
						return;
					}
				try {
					TimeUnit.MILLISECONDS.sleep(pause);
				} catch (InterruptedException e) {
					println("barrier-action sleep interrupted");
				}
				// added
				println("Action");
				//
			}
		});

Here is the output:

Thread 0, Thread 1, Thread 2, Thread 3, Thread 4, Thread 5, Thread 6, Action
Thread 6, Thread 2, Thread 4, Thread 5, Thread 1, Thread 0, Thread 3, Action
Thread 3, Thread 2, Thread 4, Thread 5, Thread 1, Thread 0, Thread 6, Action
Thread 6, Thread 3, Thread 2, Thread 4, Thread 5, Thread 1, Thread 0, Action
Thread 0, Thread 3, Thread 2, Thread 6, Thread 4, Thread 5, Thread 1, Action
Thread 1, Thread 0, Thread 3, Thread 2, Thread 4, Thread 5, Thread 6, Action
Thread 6, Thread 1, Thread 0, Thread 3, Thread 2, Thread 4, Thread 5, Action
...

Doesn't this prove that all threads are waiting at the barrier point until the CyclicBarrier completely executes it's action?

[Ranganathan Kaliyur Mannar]

Hi,
I re-read your initial post. I think you are right. I was wrong in my earlier post. I initially thought a single object is shared by all the threads (which is not the case here).
And your understanding of CyclicBarrier is correct. I am not sure why the author has synchronized access to strides here...

[Vladimir Mokrozub]

OK, thanks!