Concurrency Unit Test Waynes Attempt

From ExtremeProgrammingChallengeFourteenTheBug

---

This test exposes the error with the message "producer1 blocked". It's verbose and it's slow (takes seconds to execute), and I hate that it's not deterministic. It can also report false errors if the process doesn't get any CPU time for 200 msec.

  public void testTwoProducersTwoConsumers() throws Exception {
final int numberOfItems = 10000;
final Watchdog watchdog = new Watchdog();
final BoundedBuffer buffer = new BoundedBuffer(1);
Thread producer1 = new Producer(buffer, watchdog, numberOfItems);
Thread producer2 = new Producer(buffer, watchdog, numberOfItems);
Thread consumer1 = new Consumer(buffer, watchdog, numberOfItems);
Thread consumer2 = new Consumer(buffer, watchdog, numberOfItems);
producer1.start();
producer2.start();
consumer1.start();
consumer2.start();
watchdog.waitUntilInactive();
assert("producer1 blocked", !producer1.isAlive());
assert("producer2 blocked", !producer2.isAlive());
assert("consumer1 blocked", !consumer1.isAlive());
assert("consumer2 blocked", !consumer2.isAlive());
  }

Watchdog is how I detect that nothing is happening. It allows the test to work on faster or slower CPUs:

private static class Watchdog {
  private long msecOfLastReset;
  public Watchdog() {
reset();
  }
  public synchronized void reset() {
msecOfLastReset = System.currentTimeMillis();
  }
  public void waitUntilInactive() throws InterruptedException {
while (msecSinceReset() < 200)
Thread.sleep(200);
  }
  private synchronized long msecSinceReset() {
return System.currentTimeMillis() - msecOfLastReset;
  }
};

The producers and consumers are about what you'd expect (I expect):

private abstract static class Actor extends Thread {
  protected BoundedBuffer buffer;
  private Watchdog watchdog;
  private int numberOfItems;
  public Actor(BoundedBuffer buffer, Watchdog watchdog, int numberOfItems) {
this.buffer = buffer;
this.watchdog = watchdog;
this.numberOfItems = numberOfItems;
  }
  public void run() {
try {
for (int i = 0; i < numberOfItems; i++) {
act();
watchdog.reset();
}
}
catch (InterruptedException e) {
}
  }
  protected abstract void act() throws InterruptedException;
};

private static class Producer extends Actor {
  public Producer(BoundedBuffer buffer, Watchdog watchdog, int numberOfItems) {
super(buffer, watchdog, numberOfItems);
  }
  protected void act() throws InterruptedException {
buffer.put(new Object());
  }
};

private static class Consumer extends Actor {
  public Consumer(BoundedBuffer buffer, Watchdog watchdog, int numberOfItems) {
super(buffer, watchdog, numberOfItems);
  }
  protected void act() throws InterruptedException {
buffer.take();
  }
};

I added a new constructor to BoundedBuffer that takes the buffer size, as I wasn't able to reproduce the deadlock with the default buffer size of 4.

Also, my test for one producer and two consumers showed a deadlock, as did my test for two producers and one consumer. One producer and one consumer worked fine. When I changed the notify() to notifyAll(), all the tests passed. -- WayneConrad