如何在C＃中实现健壮的线程监视？

Question

I have 2 tasks running parallelly and here is the task information. Task 1 - Launch and run application Task 2 - Monitor the application run duration. If it exceeds 30 mins, issue a stop command of task 1 application and restart both task.

Task 1 application bit heavy and memory leak prone during longer runs.

I am requesting, how can we implement robust threading solution for this situation.

    using QuickTest;
    using System;
    using System.Threading;
    using System.Threading.Tasks;

    namespace TaskParallelExample
     {
     internal class Program
      {
       private static void Main(string[] args)
        {
        Parallel.Invoke(RunApplication, MonitorApplication);
    }

    private static void RunApplication()
    {
        Application uftInstance = new Application();
        uftInstance.Launch();
        QuickTest.Test uftTestInstance = uftInstance.Test;
        uftInstance.Open(@"C:\Tasks\Test1");
        uftInstance.Test.Run(); // It will may run more then 30 mins or less then also. It it exceeds 30 mins which is calculated from Monitor Application.
    }

    private static void MonitorApplication()
    {
        Application uftInstance = new Application();
        try
        {
            DateTime uftTestRunMonitor = DateTime.Now;
            int runningTime = (DateTime.Now - uftTestRunMonitor).Minutes;
            while (runningTime <= 30)
            {
                Thread.Sleep(5000);
                runningTime = (DateTime.Now - uftTestRunMonitor).Minutes;
                if (!uftInstance.Test.IsRunning)
                {
                    break;
                }
            }
        }
        catch (Exception exception)
        {
            //To-do
        }
        finally
        {
            if (uftInstance.Test.IsRunning)
            {
                //Assume it is still running and it is more then 30 mins
                uftInstance.Test.Stop();
                uftInstance.Test.Close();
                uftInstance.Quit();
            }
        }
    }
}

}

Thanks, Ram

Answer 1

Could you use a CancellationTokenSource with timeout set to 30 mins?

var stopAfter30Mins = new CancellationTokenSource(TimeSpan.FromMinutes(30));

Then you would pass that to your worker method:

var task = Task.Run(() => worker(stopAfter30Mins.Token), stopAfter30Mins.Token);

...

static void worker(CancellationToken cancellation)
{
    while (true)  // Or until work completed.
    {
        cancellation.ThrowIfCancellationRequested();
        Thread.Sleep(1000); // Simulate work.
    }
}

Note that if the worker task cannot periodically check the cancellation status, there is NO robust way to handle task timeout.

Answer 2

System.Threading.Tasks.Task do the job

   CancellationTokenSource cts = new CancellationTokenSource();
            CancellationToken token = cts.Token;
            Task myTask = Task.Factory.StartNew(() =>
           {
               for (int i = 0; i < 2000; i++)
               {
                   token.ThrowIfCancellationRequested();

                   // Body of for loop.
               }
           }, token);

            //Do sometohing else 
            //if cancel needed
            cts.Cancel();