You java gurus probably hate it when a posting starts like this, but
here goes anyway. Sorry, in advance!

Disclaimer: I'm not a java guru. I know how to spell it and I've
written some basic OO stuff. I now have a real problem that I'm trying
to solve but have no idea how best to implement it.

Here's the situation. I have a small java routine (in Oracle) that
executes an operating system command. Here's that code:

import java.io.*;
public class Host {
 public static void executeCommand(String command) {
   try {
     String[] finalCommand;
     if (isWindows()) {
       finalCommand = new String[4];
       // Use the appropriate path for your windows version.
       finalCommand[0] = "C:\\windows\\system32\\cmd.exe";  //
Windows XP/2003
       //finalCommand[0] = "C:\\winnt\\system32\\cmd.exe";  //
Windows NT/2000
       finalCommand[1] = "/y";
       finalCommand[2] = "/c";
       finalCommand[3] = command;
     }
     else {
       finalCommand = new String[3];
       finalCommand[0] = "/bin/sh";
       finalCommand[1] = "-c";
       finalCommand[2] = command;
     }

     final Process pr = Runtime.getRuntime().exec(finalCommand);
     pr.waitFor();

     new Thread(new Runnable(){
       public void run() {
         BufferedReader br_in = null;
         try {
           br_in = new BufferedReader(new
InputStreamReader(pr.getInputStream()));
           String buff = null;
           while ((buff = br_in.readLine()) != null) {
             System.out.println("Process out :" + buff);
             try {Thread.sleep(100); } catch(Exception e) {}
           }
           br_in.close();
         }
         catch (IOException ioe) {
           System.out.println("Exception caught printing process
output.");
           ioe.printStackTrace();
         }
         finally {
           try {
             br_in.close();
           } catch (Exception ex) {}
         }
       }
     }).start();

     new Thread(new Runnable(){
       public void run() {
         BufferedReader br_err = null;
         try {
           br_err = new BufferedReader(new
InputStreamReader(pr.getErrorStream()));
           String buff = null;
           while ((buff = br_err.readLine()) != null) {
             System.out.println("Process err :" + buff);
             try {Thread.sleep(100); } catch(Exception e) {}
           }
           br_err.close();
         }
         catch (IOException ioe) {
           System.out.println("Exception caught printing process
error.");
           ioe.printStackTrace();
         }
         finally {
           try {
             br_err.close();
           } catch (Exception ex) {}
         }
       }
     }).start();
   }
   catch (Exception ex) {
     System.out.println(ex.getLocalizedMessage());
   }
 }

 public static boolean isWindows() {
   if
(System.getProperty("os.name").toLowerCase().indexOf("windows") != -1)
     return true;
   else
     return false;
 }

};

What I want to do is put a timer in this code that will only allow the
command to attempt to run for a set amount of time, and when that time
elapses the program will decide that the command isn't going to work
and it quits with an error message.

The way I understand the documentation, as the code is written right
now (with the pr.waitFor(); line) it will wait for the process (in
this case an OS command) to complete before the code will continue.
That seems to bear out in my testing so far.

I've seen also in the javadocs where you can call Thread.join(50000);
or something similar, to join the running thread and if it doesn't
complete in the specified time that it will kill the thread. Is this
the right approach to solving this problem? Is the problem even clear?
Any suggestions about how to do this and where to put the suggested
code snippets will be greatly appreciated. Thank you.

Sincerely,

Earl