ExecutorService - program not stopping.

Question

Folks,
This program uses the ExecutorService to run some bodgy building elevator scenario test concurrently... My problem is that the program doesn't stop at the end of the run... I'm sure I could stick a System.exit(0), but that seems like "dirty" solution to me... I should be able to figure out why I've still got "heavy" thread(s) running.
I profiled it with visual-vm and I find NO untoward threads running... leaving me totally confusterpated.
Please if anyone could shed any light on the cause, or recommend some relevant reading, I would really appreciate it.
Thanx. Keith.
package forums;
import java.util.Random;
import java.util.List;
import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;
class Lift
  private static final double SECONDS_TO_SPEED_UP_AND_SLOW_DOWN = 6.0; // original 5
  private static final double SECONDS_TO_MOVE_ONE_FLOOR = 0.75; // original 2
  private final char name;      // the name of this lift (a,b,...)
  private int floor;            // which floor is the lift currently on [1..NUM_FLOORS]
  public Lift(char name, int floor) {
    this.name = name;
    moveTo(floor);
  public char getName() { return this.name; }
  public int getFloor() { return this.floor; }
  /** returns the amount of seconds this lift will take to goto the given floor. */
  public double timeTo(int floor) {
    return SECONDS_TO_SPEED_UP_AND_SLOW_DOWN
         + Math.abs(floor-this.floor) * SECONDS_TO_MOVE_ONE_FLOOR;
  /** moves this lift to the given floor (instantly) */
  public void moveTo(int floor) {
    if ( floor<1 || floor>Building.NUM_FLOORS ) {
      throw new IllegalArgumentException("floor "+floor+" is out of range [1.."+Building.NUM_FLOORS+"]");
    this.floor = floor;
/** The results of a TestRun */
class Result
  final double average;
  final double worstCase;
  Result(double average, double worstCase) {
    this.average = average;
    this.worstCase = worstCase;
/** Does a TestRun on the given number of Lift's and returns the result */
class TestRunner implements Callable<Result>
  private static final Random RANDOM = new Random();
  private static final int NUM_LIFT_MOVEMENTS = 10*1000;
  private final int numLifts;
  private final Lift[] lifts;
  public TestRunner(int numLifts) {
    this.numLifts = numLifts;
    this.lifts = newLifts(numLifts);
  public Result call() {
    int totalTime = 0;
    double maxTime = 0;
    for (int i=0; i<NUM_LIFT_MOVEMENTS; i++) {
      int destFloor = randomFloor();
      Lift fastestLift = null;
      double fastestTime = Integer.MAX_VALUE;
      for ( Lift lift : lifts ) {
        double time = lift.timeTo(destFloor);
        if ( time < fastestTime ) {
          fastestLift = lift;
          fastestTime = time;
      totalTime += fastestTime;
      maxTime = Math.max(fastestTime, maxTime);
      fastestLift.moveTo(destFloor);
    return new Result((double)totalTime/NUM_LIFT_MOVEMENTS, maxTime);
  private static Lift[] newLifts(int numLifts) {
    Lift[] lifts = new Lift[numLifts];
    char c = 'a';
    for (int i=0; i<numLifts; i++) {
      lifts[i] = new Lift(c++, randomFloor());
    return lifts;
  private static int randomFloor() {
    return RANDOM.nextInt(Building.NUM_FLOORS) + 1;
class Building {
  public static final int NUM_FLOORS = 160; // Burj Dubai
}... PTO ...

Answer 1

The problem was resolved by lifting the shutdownAndAwaitTermination method from the test harness of [this java.util.concurrent bugreport|http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6431315] (by none other than [Doug Lea|http://en.wikipedia.org/wiki/Doug_Lea] himself).
  public static void main (String [] args) {
    try {
      double[] averages = new double[MAX_NUM_LIFTS];
      double[] worstCases = new double[MAX_NUM_LIFTS];
      for (int t=0; t<=NUM_TIMES; t++) {
        runTest(averages, worstCases);
        System.out.format("\r%d   ", NUM_TIMES-t);
      System.out.format("\r");
      for (int n=0; n<MAX_NUM_LIFTS; n++) {
        System.out.format("for %2d lifts average was %6.2f seconds"
            , n+1, averages[n]/NUM_TIMES);
        System.out.format(" and the average worst case was %6.2f seconds%n"
            , worstCases[n]/NUM_TIMES);
      shutdownAndAwaitTermination(EXECUTOR);
      //System.exit(0);
    } catch (Exception e) {
      e.printStackTrace();
  private static void shutdownAndAwaitTermination(ExecutorService pool) {
    pool.shutdown(); // Disable new tasks from being submitted
    try {
      // Wait 10 seconds for existing tasks to terminate
      if (!pool.awaitTermination(10, TimeUnit.SECONDS)) {
        pool.shutdownNow(); // Cancel currently executing tasks
        // Wait a while for tasks to respond to being cancelled
        if (!pool.awaitTermination(10, TimeUnit.SECONDS)) {
          System.err.println("Pool did not terminate");
   } catch (InterruptedException ie) {
     // (Re-)Cancel if current thread also interrupted
     pool.shutdownNow();
     // Preserve interrupt status
     Thread.currentThread().interrupt();
}Cheers all... and thanx anyways. Keith.