Time-consuming code should check Thread.interrupted() regularly. If true, then respond just as if you had caught an InterruptedException.

Do NOT cause an interrupt to be ignored, or no one will be able to stop your Thread.

You will only get an InterruptedException if someone has deliberately called Thread.interrupt(). They want your Thread to clean up and return from the Thread.run() method.

If your utility method is not in a position to clean up, then it should rethrow the InterruptedException. Do not convert and rethrow a different kind of Exception.

If this is too difficult, then at least call Thread.currentThread().interrupt() so that later code can handle the interrupt correctly.

 
public void foo() {
  try {Thread.sleep(1000);}
  catch (InterruptedException e) {
    Thread.currentThread().interrupt();
  }
}

There is no other safe way to stop a Thread because Thread.stop() is deprecated.

Running and interrupting threads after a time limit

  /** Run many Threads and interrupt if not finished after a time limit.
      @param thread Start these threads and interrupt if necessary.
      @param millisWait Milliseconds to wait for threads to complete.
      If zero, wait forever.
      @param millisPause Wait this many milliseconds between starting
      each thread, to avoid clobbering resources.
      @return Array of booleans for each thread.
      Element is true if thread was interrupted because of timeout or
      because this thread was interrupted.
  */
  public static boolean[] run(Thread[] thread, long millisWait,
                              long millisPause) {
    long end = System.currentTimeMillis() + millisWait;
    if (millisWait == 0) {
      end = Long.MAX_VALUE;
    }
    boolean interruptedMe = false;
    for (int i=0; i<thread.length; ++i) {
      if (thread[i] != null)
        thread[i].start();
      if (millisPause >0) {
        try {
          Thread.sleep(millisPause);
        } catch (InterruptedException e) {
          interruptedMe = true;
        }
      }
    }
    boolean allFinished = false;
    while (!interruptedMe &&
           System.currentTimeMillis() < end &&
           !allFinished) {
      allFinished = true;
      for (int i=0; allFinished && i<thread.length; ++i) {
        if (thread[i] != null && thread[i].isAlive())
          allFinished = false;
      }
      if (!allFinished) {
          try {
            Thread.sleep(200);
          } catch (InterruptedException e) {
            interruptedMe = true;
          }
      }
    }
    boolean[] interrupted = new boolean[thread.length];
    for (int i=0; i<thread.length; ++i) {
      if (thread[i] != null && thread[i].isAlive()) {
        thread[i].interrupt();
        interrupted[i] = true;
      } else {
        interrupted[i] = false;
      }
    }
    if (interruptedMe) {
      Thread.currentThread().interrupt();
    }
    return interrupted;
  }

Getting a list of running Threads

  public static String[] getThreadNames() {
    ThreadGroup group = Thread.currentThread().getThreadGroup();
    ThreadGroup parent = null;
    while ( (parent = group.getParent()) != null ) {
      group = parent;
    }
    Thread[] threads = new Thread[group.activeCount()];
    group.enumerate(threads);
    java.util.HashSet set = new java.util.HashSet();
    for (int i=0; i < threads.length; ++i) {
      if (threads[i] != null && threads[i].isAlive()) {
        try {
          set.add(threads[i].getThreadGroup().getName()+","
                  +threads[i].getName()+","
                  +threads[i].getPriority());
        } catch (Throwable e) {e.printStackTrace();}
      }
    }
    String[] result = (String[]) set.toArray(new String[0]);
    java.util.Arrays.sort(result);
    return result;
  }

Quick profiling