C#执行带超时功能的方法

在日常的代码中,经常会遇到执行一段代码,无法控制执行的时间,

例如匹配一段非常复杂的正则,假设匹配时间超过30s可能即使匹配出来结果,我们也会放弃,因为他所消耗的资源太大了,因此就需要一个方法的超时处理功能

以下这个方法包含两个核心的方法OutTimeSomeParemReturn与Wait

下面我模拟一个执行过程,假设现在需要执行一个方法Method,方法执行的超时时间是OutTime,取消对象为cancelEvent,下面我来解释下这两个方法

Wait是用来等待超时的方法

        private static void Wait(Thread t, TimeSpan OutTime, WaitHandle are, WaitHandle cancelEvent)
        {
            WaitHandle[] ares;
            if (cancelEvent == null)
                ares = new WaitHandle[] { are };
            else
                ares = new WaitHandle[] { are, cancelEvent };
            int index = WaitHandle.WaitAny(ares, OutTime);
            if ((index != 0) && t.IsAlive)//如果不是执行完成的信号,并且,线程还在执行,那么,结束这个线程
            {
                t.Abort();
                t = null;
            }
        }

参数t为执行Method的线程,OutTime超时时间,are当Method方法执行完时的信号对象,cancelEvent当没有完成Method并需要取消执行时的取消信号

使用的是WaitHandle对象所带的WaitAny方法,

等待are与cancelEvent两个对象的信号,当其中一个对象调用Set方法时说明方法执行完,或是取消了,

如果当执行时间超过OutTime值时,也会结束等待,此时是执行Method超时了,需要强行停止Method方法的执行,即调用执行Method方法的线程t的About方法,把线程停止

 

OutTimeSomeParemReturn是用来调用所需要设置超时的执行方法,与调用Wait方法等待超时

        public static object OutTimeSomeParemReturn(SomeParamsReturnDelegate Method, TimeSpan OutTime, object Param, WaitHandle cancelEvent)
        {
            object obj = null;
            AutoResetEvent are = new AutoResetEvent(false);
            Thread t = new Thread(delegate() { obj = Method(Param); are.Set(); });
            t.Start();
            Wait(t, OutTime, are, cancelEvent);
            return obj;
        }

参数Method为需要执行的方法,OutTime超时时间,Param为Method方法执行所需要的参数,cancelEvent为取消信号

我使用了一个匿名的方法来执行Method方法,并传入参数Param,当执行结束后,调用are的Set方法,通知等待方法,并且把方法Method所反回的值赋给obj,

然后调用等待方法,阻塞,直到Method方法执行完,或是取消,或是超时三者其一时,反回obj对象

 

其他几个方法为OutTimeSomeParemReturn方法的变形,或是重载,下面是全部代码

using System;
using System.Threading;

namespace OutTimeManager
{
    /// <summary>
    /// 超时类,可设置执行方法超时时间
    /// 目前没有添加取消方法,如有需要,可添加取消功能
    /// </summary>
    public class OutTimeClass
    {
        #region delegate
        /// <summary>
        /// 无参数,无反回值方法
        /// </summary>
        public delegate void NotParamDelegate();
        /// <summary>
        /// 有参数,无反回值方法
        /// </summary>
        /// <param name="Params"></param>
        public delegate void SomeParamsDelegate(object Params);
        /// <summary>
        /// 无参数,带返回值方法
        /// </summary>
        /// <returns></returns>
        public delegate object NotParamReturnDelegate();
        /// <summary>
        /// 有参数,有反回值方法
        /// </summary>
        /// <param name="Params"></param>
        /// <returns></returns>
        public delegate object SomeParamsReturnDelegate(object Params);
        #endregion

        #region 超时方法
        /// <summary>
        /// 无参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTimeMilliseconds">超时时间(毫秒)</param>
        public static void OutTimeNotParam(NotParamDelegate Method, int OutTimeMilliseconds)
        {
            OutTimeNotParam(Method, TimeSpan.FromMilliseconds(OutTimeMilliseconds));
        }

        /// <summary>
        /// 无参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        public static void OutTimeNotParam(NotParamDelegate Method, TimeSpan OutTime)
        {
            OutTimeNotParam(Method, OutTime, null);
        }

        /// <summary>
        /// 无参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="cancelEvent">取消信号</param>
        public static void OutTimeNotParam(NotParamDelegate Method, TimeSpan OutTime, WaitHandle cancelEvent)
        {
            AutoResetEvent are = new AutoResetEvent(false);
            Thread t = new Thread(delegate() { Method(); are.Set(); });
            t.Start();
            Wait(t, OutTime, are, cancelEvent);
        }

        /// <summary>
        /// 有参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTimeMilliseconds">超时时间(毫秒)</param>
        /// <param name="Param">参数</param>
        public static void OutTimeSomeParem(SomeParamsDelegate Method, int OutTimeMilliseconds, object Param)
        {
            OutTimeSomeParem(Method, TimeSpan.FromMilliseconds(OutTimeMilliseconds), Param);
        }

        /// <summary>
        /// 有参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="Param">参数</param>
        public static void OutTimeSomeParem(SomeParamsDelegate Method, TimeSpan OutTime, object Param)
        {
            OutTimeSomeParem(Method, OutTime, Param, null);
        }

        /// <summary>
        /// 有参数,无反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="cancelEvent">取消信号</param>
        /// <param name="Params">参数</param>
        public static void OutTimeSomeParem(SomeParamsDelegate Method, TimeSpan OutTime, object Param, WaitHandle cancelEvent)
        {
            AutoResetEvent are= new AutoResetEvent(false);
            Thread t = new Thread(delegate() { Method(Param); are.Set(); });
            t.Start();
            Wait(t, OutTime, are, cancelEvent);
        }

        /// <summary>
        /// 没参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTimeMilliseconds">超时时间(毫秒)</param>
        /// <returns>反回object类型对象</returns>
        public static object OutTimeNotParamReturn(NotParamReturnDelegate Method, int OutTimeMilliseconds)
        {
            return OutTimeNotParamReturn(Method, TimeSpan.FromMilliseconds(OutTimeMilliseconds));
        }

        /// <summary>
        /// 没参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <returns>反回object类型对象</returns>
        public static object OutTimeNotParamReturn(NotParamReturnDelegate Method, TimeSpan OutTime)
        {
            return OutTimeNotParamReturn(Method, OutTime, null);
        }

        /// <summary>
        /// 没参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="cancelEvent">取消信号</param>
        /// <returns>反回object类型对象</returns>
        public static object OutTimeNotParamReturn(NotParamReturnDelegate Method, TimeSpan OutTime, WaitHandle cancelEvent)
        {
            object obj = null;
            AutoResetEvent are = new AutoResetEvent(false);
            Thread t = new Thread(delegate() {obj= Method(); are.Set(); });
            t.Start();
            Wait(t, OutTime, are, cancelEvent);
            return obj;
        }

        /// <summary>
        /// 有参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="Params">执行参数</param>
        /// <returns>反回一个object类型方法</returns>
        public static object OutTimeSomeParemReturn(SomeParamsReturnDelegate Method, int OutTimeMilliseconds, object Param)
        {
            return OutTimeSomeParemReturn(Method, TimeSpan.FromMilliseconds(OutTimeMilliseconds), Param);
        }

        /// <summary>
        /// 有参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="Params">执行参数</param>
        /// <returns>反回一个object类型方法</returns>
        public static object OutTimeSomeParemReturn(SomeParamsReturnDelegate Method, TimeSpan OutTime, object Param)
        {
            return OutTimeSomeParemReturn(Method, OutTime, Param, null);
        }

        /// <summary>
        /// 有参数,有反回值超时方法
        /// </summary>
        /// <param name="Method">执行方法</param>
        /// <param name="OutTime">超时时间</param>
        /// <param name="Params">执行参数</param>
        /// <param name="cancelEvent">取消信号</param>
        /// <returns>反回一个object类型方法</returns>
        public static object OutTimeSomeParemReturn(SomeParamsReturnDelegate Method, TimeSpan OutTime, object Param, WaitHandle cancelEvent)
        {
            object obj = null;
            AutoResetEvent are = new AutoResetEvent(false);
            Thread t = new Thread(delegate() { obj = Method(Param); are.Set(); });
            t.Start();
            Wait(t, OutTime, are, cancelEvent);
            return obj;
        }

        /// <summary>
        /// 等待方法执行完成,或超时
        /// </summary>
        /// <param name="t"></param>
        /// <param name="OutTime"></param>
        /// <param name="ares"></param>
        private static void Wait(Thread t, TimeSpan OutTime, WaitHandle are, WaitHandle cancelEvent)
        {
            WaitHandle[] ares;
            if (cancelEvent == null)
                ares = new WaitHandle[] { are };
            else
                ares = new WaitHandle[] { are, cancelEvent };
            int index = WaitHandle.WaitAny(ares, OutTime);
            if ((index != 0) && t.IsAlive)//如果不是执行完成的信号,并且,线程还在执行,那么,结束这个线程
            {
                t.Abort();
                t = null;
            }
        }
        #endregion
    }
}

另复上一个正则的超时方法,思路与上述相同,只是我把正则匹配的功能加上了.

using System;
using System.Text.RegularExpressions;
using System.Threading;

namespace AD818_JM
{
    public class OutTimeRegex
    {
        /// <summary>
        /// 正则解析
        /// </summary>
        /// <param name="regex">正则对象</param>
        /// <param name="input">需要解析的字符串</param>
        /// <param name="OutTimeMilliseconds">超时时间</param>
        /// <returns></returns>
        public static MatchCollection Matchs(Regex regex, string input, int OutTimeMilliseconds)
        {
            MatchCollection mc = null;
            AutoResetEvent are = new AutoResetEvent(false);
            Thread t = new Thread(delegate() { 
                mc = regex.Matches(input);
                //注意,在这里一定要把所有的匹配项遍历一次,不然的话当在此方法外遍历的话.也可能会出现等待情况
                foreach (Match m in mc) { }
                are.Set(); });
            t.Start();
            Wait(t, TimeSpan.FromMilliseconds(OutTimeMilliseconds), are, null);
            return mc;
        }

        /// <summary>
        /// 等待方法执行完成,或超时
        /// </summary>
        /// <param name="t"></param>
        /// <param name="OutTime"></param>
        /// <param name="ares"></param>
        private static void Wait(Thread t, TimeSpan OutTime, WaitHandle are, WaitHandle cancelEvent)
        {
            WaitHandle[] ares;
            if (cancelEvent == null)
                ares = new WaitHandle[] { are };
            else
                ares = new WaitHandle[] { are, cancelEvent };
            int index = WaitHandle.WaitAny(ares, OutTime);
            if ((index != 0) && t.IsAlive)//如果不是执行完成的信号,并且,线程还在执行,那么,结束这个线程
            {
                t.Abort();
                t = null;
            }
        }

        /// <summary>
        /// 正则解析
        /// </summary>
        /// <param name="regex">正则对象</param>
        /// <param name="input">需要解析的字符串</param>
        /// <param name="OutTimeMilliseconds">超时时间</param>
        /// <returns></returns>
        public static Match Match(Regex regex, string input, int OutTimeMilliseconds)
        {
            Match m = null;
            AutoResetEvent are = new AutoResetEvent(false);
            Thread t = new Thread(delegate() { m = regex.Match(input); are.Set(); });
            t.Start();
            Wait(t, TimeSpan.FromMilliseconds(OutTimeMilliseconds), are, null);
            return m;
        }
    }
}

 

这是我第一次在园子里发博客,希望园友们多多给意见或建议,