Logic to kill a process within a time limit

Question

I want to ensure that my logic is correct here. I want to run a process for timeout seconds, if it runs for longer it should be immediately killed.

The completed flag should reliably indicate whether the process completed as intended, e.g was not killed, and did not crash or throw an exception.

Also, I am not positive if the check to process.HasExited is correct. If process.WaitForExit() returns false and Kill() succeeds, then will process.HasExited always be true? That would be my assumption but I wanted to confirm. Also, what if anything can be done if Kill() fails, besides just logging?

        using (process = new Process())
        {
            process.EnableRaisingEvents = true;
            process.OutputDataReceived += new DataReceivedEventHandler(OnOutputDataReceived);
            process.ErrorDataReceived += new DataReceivedEventHandler(OnErrorDataReceived); 
            process.Exited += new EventHandler(OnExited);

            process.StartInfo = startInfo;
            process.Start();

            process.BeginOutputReadLine();
            process.BeginErrorReadLine();

            if (!process.WaitForExit(timeout))
            {
                try
                {
                    process.Kill(); 
                }
                catch (Exception e)
                {
                    LogError(e, MethodBase.GetCurrentMethod());
                }
                finally
                {
                    this.completed = false;
                }
            }
            else
            {
                if (process.HasExited)
                {
                    this.code = process.ExitCode; 
                    this.completed = true;
                }
                else
                {
                    this.completed = false; 
                }
            }
        }

score 4 · Accepted Answer · edited May 23 '17 at 12:28

Yes, the HasExited will always be true in your case.

According to MSDN,

"A value of true for HasExited indicates that the associated process has terminated, either normally or abnormally.[...]A process can terminate independently of your code. If you started the process using this component, the system updates the value of HasExited automatically, even if the associated process exits independently."

However, if your process crashes and terminates before your timeout, then your code will set it as completed anyway. Maybe you should check the exit code, but it can have different meanings for each process:

if (process.ExitCode != 0)
{
    this.completed = false;
}

For crashes, there are some approaches here and here, but generally you can't detect crashes for all processes.

Also, in your case, according to msdn: When standard output has been redirected to asynchronous event handlers, it is possible that output processing will not have completed when HasExited returns true. To ensure that asynchronous event handling has been completed, call the WaitForExit() overload that takes no parameter before checking HasExited. — natenho, Sep 25 '13 at 13:35

score 2 · Answer 2 · edited Oct 01 '13 at 11:13

2

We use the following in a .net console app

private void InitTimer()
{
    double lInterval = Convert.ToDouble(AppSettings("MaxExecutionTime"));
    lInterval = lInterval * 60 * 1000;
    tm = new System.Timers.Timer(lInterval); // global timer object
    tm.Elapsed += OnTimedEvent;
    tm.Enabled = true;
}

public void ThreadProc(object stateinfo)
{
    // set error code here
    Environment.Exit(0);
}

private void OnTimedEvent(object source, ElapsedEventArgs e)
{
   Threading.ThreadPool.QueueUserWorkItem(new Threading.WaitCallback(ThreadProc));
}

edited Oct 01 '13 at 11:13

Mike de Klerk

11,906
8
54
76

answered Sep 30 '13 at 13:21

lcryder

486
2
8

I'm using this way too. – user743414 Oct 01 '13 at 07:58
1

Could to explain more about this @lcryder? I assume you implement this code in the application that is allowed to run for a specified amount of time. So controlling it internally. But Sean Thoman seems to be looking for a way to control it externally. – Mike de Klerk Oct 01 '13 at 11:05
Externally isn't a problem. Just start the process you want to monitor with "process = System.Diagnostics.Process.Start("notepad.exe");" and then start a timer and wait for the timer event. Done. – user743414 Oct 01 '13 at 12:37

score 1 · Answer 3 · answered Sep 27 '13 at 02:55

1

In C, you could set an OS alarm using the alarm function. When it expired, a SIGALRM would be sent to your process, which kills it if no handler is set.

answered Sep 27 '13 at 02:55

Demi

3,535
5
29
45

1

Nobody mentioned Windows here, maybe this should be a comment instead an answer. – Felipe Buccioni Oct 01 '13 at 13:35
True - I forgot that the OP is probably on Windows, and SIGALRM is POSIX. I don't know any C# though, so this was the best response I could think of. – Demi Oct 01 '13 at 15:29
@FelipeAlcacibar were you the one who downvoted me, and (if so) does your comment show why? – Demi Oct 01 '13 at 15:30
1

Before my comment it was a comment what I flag it before saying about SIGALRM does not are in windows, that is why my comment starts with that. And i am the one who upvoted you. – Felipe Buccioni Oct 01 '13 at 18:19
@FelipeAlcacibar sorry about that. Thanks. – Demi Oct 03 '13 at 16:41

score 1 · Answer 4 · edited May 23 '17 at 12:29

You can use this. It is a C# wrapper over the JobObjects functionallity. The idea behind is (low level outline that is embedded inside the library I mentioned):

Create a job object.
Configure the job object to have a time limit of x seconds.
Create a process and before resuming it assing it to the job object.
Resume the process.
The process will be killed by the operating system when the time passes. YOu usually get notified by a non zero return code, or a callback. The JobObject API itself allows callbacks, not sure about the C# wrapper.

Also using job objects you can restrict memory usage. On the page I mentioned you can find examples also.

UPDATE

After I wrote the above statements I have found this Kill child process when parent process is killed. They use the JobObjects for another task, but the usage of JobObjects should be the same as for your case.

Logic to kill a process within a time limit

4 Answers4