CODEWITHSUNDEEP
javamultithreadingtimeoutrunnable
Pectus Excavatum
Pectus Excavatum

Reputation: 3773

java - how to kill a Process if it exceeds an alloted time

I am wondering what the best way is to detect/kill a process if it exceeds a predefined time. I know an old way was to use the watchdog/timeoutobserver class from the ant package. But this is deprecated now, so I am wondering how it should be done now?

Here is the code I have which uses watchdog:

import org.apache.tools.ant.util.Watchdog;
import org.apache.tools.ant.util.TimeoutObserver;


public class executer implements TimeoutObserver {

    private int timeOut = 0;
    Process process = null;
    private boolean killedByTimeout =false;


    public executer(int to) {
        timeOut = t;
    }

    public String executeCommand() throws Exception {
        Watchdog watchDog = null;
        String templine = null;
        StringBuffer outputTrace = new StringBuffer();
        StringBuffer errorTrace = new StringBuffer();



        Runtime runtime = Runtime.getRuntime();



        try {
            //instantiate a new watch dog to kill the process
            //if exceeds beyond the time
            watchDog = new Watchdog(getTimeout());
            watchDog.addTimeoutObserver(this);
            watchDog.start();

            process = runtime.exec(command);

            //... Code to do the execution .....

            InputStream inputStream = process.getInputStream();
            InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
            bufferedReader = new BufferedReader(inputStreamReader);
            while (((templine = bufferedReader.readLine()) != null) && (!processWasKilledByTimeout)) {
                outputTrace.append(templine);
                outputTrace.append("\n");
            }


            this.setStandardOut(outputTrace);


            int returnCode = process.waitFor();
            //Set the return code
            this.setReturnCode(returnCode);

            if (processWasKilledByTimeout) {
                //As process was killed by timeout just throw an exception
                throw new InterruptedException("Process was killed before the waitFor was reached.");
            }


        } finally {
            // stop the watchdog as no longer needed.
            if (aWatchDog != null) {
                aWatchDog.stop();
            }
            try {
                // close buffered readers etc
            } catch Exception() {
            }
            //Destroy process
            //    Process.destroy() sends a SIGTERM to the process. The default action
            //    when SIGTERM is received is to terminate, but any process is free to
            //    ignore the signal or catch it and respond differently.
            //
            //    Also, the process started by Java might have created additional
            //    processes that don't receive the signal at all.
            if(process != null) {

                process.destroy();
            }
        }



        public void timeoutOccured(Watchdog arg0) {
            killedByTimeout = true;

            if (process != null){
                process.destroy();
            }
            arg0.stop();
        }

    }
}

Any help would be greatly appreciated as I am a bit lost. I am trying to take this up to Java 7, but I am not uptodate with the best way to kill it if it hangs beyond the alloted time.

Thanks,

Upvotes: 1

Views: 1964

Answers (4)

Adrian Shum
Adrian Shum

Reputation: 40036

If you just concern about WatchDog itself is deprecated, it is nothing more difficult for you to make use of TimerTask, and do the process.destroy() after a period of time.

Upvotes: 0

Evgeniy Dorofeev
Evgeniy Dorofeev

Reputation: 135992

try

    final Process p = ... 
    Thread t = new Thread() {
        public void run() {
            try {
                Thread.sleep(1000);
                p.destroy();
            } catch (InterruptedException e) {
            }
        };
    };
    p.waitFor();
    t.interrupt();

Upvotes: 1

John B
John B

Reputation: 32949

I have written a set of ExecutorServices that will cancel processes after they have been given a certain period of time to execute. This code has been checked into GitHub.

The class to use to create the ExecutorService is CancelingExecutors. There are two main classes:

Upvotes: 0

AlexR
AlexR

Reputation: 115328

Theoretically Thread has method stop() that totally kills the thread. This method is deprecated since java 1.1 because it may cause resources leak. So, you are really not recommended to use it.

The "right" solution is to implement your thread so that they can gracefully exit when receiving a special "signal". You can use "interruption" mechanism: your watchdog should call "interrupt()" of thread that exceeds the time limit. But thread should call isInterrupted() itself and exit if it is interrupted. The good news is that method like sleep() and wait() already support this, so if your thread is waiting and you interrupt it from outside it InterruptedException will be thrown.

Upvotes: 0

Related Questions