C#中，函数运行超时的功能的实现

主要使用BeginInvoke方法和ManualResetEvent类来实现。

BeginInvoke使得函数在线程池上异步运行，运行完成后，调用回调函数。

ManualResetEvent用于同步阻塞。

设计思想如下：

当函数在线程池中的某一线程上异步的运行的时候，ManualResetEvent阻塞当前线程，等待若干时间。

在等候期间，如果异步函数运行完毕，会对ManualResetEvent设置一个信号，使得阻塞的线程得以继续运行下去。

如果等候超时了，则阻塞的线程也会取消阻塞，继续运行下去，但是不再理会回调的函数。（即使回调函数仍然被调用），事实上，BeginInvoke创建的线程都是后台线程,这种线程一但所有的前台线程都退出后(其中主线程就是一个前台线程),不管后台线程是否执行完毕,都会结束线程,并退出。因此如果阻塞的主线程完全运行完毕退出，那么异步运行的线程也会退出，无论是否运行完毕。

语句isGetSignal = manu.WaitOne(timeout);就是阻塞当前线程一段时间。

该语句阻塞期间，不会对isGetSignal赋值，直到阻塞取消后，才会返回一个值给isGetSignal。

当阻塞是因为收到信号而取消的，得到的值是true。

当阻塞是因为超时而取消的，得到的值是false。

整个流程如下：

把这些代码逻辑封装成一个类。

这个类就接受一个委托和一个超时时间作为构造函数。

把这个委托和 ManualResetEvent .Set();语句写在一个方法体内，CombineActionAndManuset，因此CombineActionAndManuset的调用就是实现了方法运行完毕后，设置取消阻塞信号。

封装后的代码：

public class FuncTimeout
   {
       /// <summary>
       /// 信号量
       /// </summary>
       public ManualResetEvent manu = new ManualResetEvent(false);
       /// <summary>
       /// 是否接受到信号
       /// </summary>

       public bool isGetSignal;
       /// <summary>
       /// 设置超时时间
       /// </summary>
       public int timeout;
       /// <summary>
       /// 要调用的方法的一个委托
       /// </summary>
       public Action<int> FunctionNeedRun;

       /// <summary>
       /// 构造函数，传入超时的时间以及运行的方法
       /// </summary>
       /// <param name="_action"></param>
       /// <param name="_timeout"></param>
       public FuncTimeout(Action<int> _action, int _timeout)
       {
           FunctionNeedRun = _action;
           timeout = _timeout;
       }

       /// <summary>
       /// 回调函数
       /// </summary>
       /// <param name="ar"></param>
       public void MyAsyncCallback(IAsyncResult ar)
       {
           //isGetSignal为false,表示异步方法其实已经超出设置的时间，此时不再需要执行回调方法。
           if (isGetSignal == false)
           {
               Console.WriteLine("放弃执行回调函数");
               Thread.CurrentThread.Abort();
           }
           else
           {
               Console.WriteLine("调用回调函数");
           }
       }

       /// <summary>
       /// 调用函数
       /// </summary>
       /// <param name="param1"></param>
       public void doAction(int param1)
       {
           Action<int> WhatTodo = CombineActionAndManuset;
           //通过BeginInvoke方法，在线程池上异步的执行方法。
           var r=WhatTodo.BeginInvoke(param1, MyAsyncCallback, null);
           //设置阻塞,如果上述的BeginInvoke方法在timeout之前运行完毕，则manu会收到信号。此时isGetSignal为true。
           //如果timeout时间内，还未收到信号，即异步方法还未运行完毕，则isGetSignal为false。
           isGetSignal = manu.WaitOne(timeout);

           if (isGetSignal == true)
           {
               Console.WriteLine("函数运行完毕，收到设置信号,异步执行未超时");
           }
           else
           {
               Console.WriteLine("没有收到设置信号,异步执行超时");
           }
       }

       /// <summary>
       /// 把要传进来的方法，和 manu.Set()的方法合并到一个方法体。
       /// action方法运行完毕后，设置信号量，以取消阻塞。
       /// </summary>
       /// <param name="num"></param>
       public void CombineActionAndManuset(int num)
       {
           FunctionNeedRun(num);
           manu.Set();
       }
   }

测试代码：

 

class Program
    {
        static void Main(string[] args)
        {
            FuncTimeout ft = new FuncTimeout(dosth, 3000);
            ft.doAction(6);
        }

       static void dosth(int num)
        {
            for (int i = 0; i < num; i++)
            {
                Thread.Sleep(500);
                Console.Write(i);
            }
        }
    }

 

当超时时间设置为5s的时候，方法未超时

当超时时间设置为1s的时候，方法超时