.Net Cancellable Task - APM异步超时机制扩展

概述

.NET基于委托的APM(Asynchronous Programming Model)模式通过BeginInvoke, EndInvoke, AsyncCallback,IAsyncResult的组合使用，让程序员可以方便的进行异步调用、异步回调和同步等待等操作。但.NET平台还没有为线程的中止(abort)提供安全可靠的机制，也许正是基于这个原因APM并没有包含异步调用的超时机制，而是把这个可能引起争议的工作交给使用者自己来把握。

作为APM模型的补充，本文通过CancellableTask类提供了一个异步调用超时机制。CancellableTask类的设计有两个主要的考虑：

1.保持APM风格，使用者依然可以使用熟悉的BeginInvoke, EndInvoke, IAsyncResult, AsyncCallback等；

2.提供基于Thread.Abort的默认超时处理，同时支持用户自定义cancel回调。

使用

CancellableTask的构造函数包含workCallbak和cancelCallback（可选）两参数，分别对应work回调和cancel回调。CancellableTask的BeginInvoke保持了APM的风格，可以看作是增加了timeout参数（单位：ms）的扩展版；而EndInvoke，AsyncCallback以及IAsyncResult的使用都和APM保持一致。Work委托产生的异常会在EndInvoke时抛出，同时若线程被超时中止，EndInvoke则会抛出ThreadAbortException异常。

下面是一段CancellableTask的使用示例：

 

class  Program
{
     static   void  Main( string [] args)
    {
         // 默认超时直接abort线程
        {
            Console.WriteLine( " [case 1] " );

            CancellableTask cancellableTask  =   new  CancellableTask(Work);

            State arg  =   new  State { Loop  =   20 , Stop  =   false  };
            IAsyncResult asyncResult  =  cancellableTask.BeginInvoke(
                arg, 
                (ar  =>  Console.WriteLine( " Async Callback " )), 
                 null , 
                 10   *   1000 );
            asyncResult.AsyncWaitHandle.WaitOne();
             try
            {
                 object  r  =  cancellableTask.EndInvoke(asyncResult);
                Console.WriteLine( " return  "   +  r);
            }
             catch  (ThreadAbortException)
            {
                Console.WriteLine( " Thread Aborted " );
            }
             catch  (Exception exp)
            {
                Console.WriteLine(exp.ToString());
            }
        }

         // 自定义Cancel回调
        {
            Console.WriteLine(Environment.NewLine  +   " [case 2] " );

            CancellableTask cancellableTask  =   new  CancellableTask(Work, Cancel);

            State arg  =   new  State { Loop  =   20 , Stop  =   false  };
            IAsyncResult asyncResult  =  cancellableTask.BeginInvoke(
                arg,
                (ar  =>
                    {
                         try
                        {
                             object  r  =  cancellableTask.EndInvoke(ar);
                            Console.WriteLine( " return  "   +  r);
                        }
                         catch  (ThreadAbortException)
                        {
                            Console.WriteLine( " Thread Aborted " );
                        }
                         catch  (Exception exp)
                        {
                            Console.WriteLine(exp.ToString());
                        }
                    }
                ),
                arg,
                 10   *   1000 );
        }
        Console.ReadLine();
    }

     static   object  Work( object  arg)
    {
        State state  =  arg  as  State;
         int  i;
         for  (i  =   0 ; i  <  state.Loop; i ++ )
        {
             if  (state.Stop)  break ;

            Console.WriteLine(i);
            Thread.Sleep( 1000 );
        }

         return  i;
    }

     static   void  Cancel( object  state)
    {
        State st  =  state  as  State;
        st.Stop  =   true ;
    }
}

internal   class  State
{
     public   int  Loop {  get ;  set ; }
     public   bool  Stop {  get ;  set ; }
}

实现

CancellableTask通过wrapper对workCallback进行包装。Wrapper内部首先创建等待事件e，并通过ThreadPool.RegisterWaitForSingleObject注册事件和WaitOrTimeout回调，然后调用workCallback。若workCallback提前返回，调用e.Set()，ThreadPool会调用WaitOrTimeout回调，isTimeout参数为false，不进行处理；否则，当workCallback超时未返回，ThreadPool会调用WaitOrTimeout回调，isTimeout参数为true。WaitOrTimeout回调在isTimeout情况下，首先判断是否有自定义cancel回调，如果有则采用自定义回调；否则，默认情况下调用Thread.Abort终止work线程。下面是CancellableTask的实现细节：

 

public   class  CancellableTask
{
     public   delegate   object  WorkCallback( object  arg);
     public   delegate   void  CancelCallback( object  state);

     protected   class  TimeoutState
    {
         internal  Thread thread;
         internal   object  state;

         public  TimeoutState(Thread thread,  object  state)
        {
             this .thread  =  thread;
             this .state  =  state;
        }
    }

     protected  WorkCallback workCallback;
     protected  CancelCallback cancelCallback;
     protected  WorkCallback wrapper;

     public  CancellableTask(WorkCallback workCallback)
    {
         this .workCallback  =  workCallback;
    }

     public  CancellableTask(WorkCallback workCallback, CancelCallback cancelCallback)
    {
         this .workCallback  =  workCallback;
         this .cancelCallback  =  cancelCallback;
    }

     public  IAsyncResult BeginInvoke( object  arg, AsyncCallback asyncCallback,  object  state,  int  timeout)
    {
        wrapper  =   delegate ( object  argv)
        {
            AutoResetEvent e  =   new  AutoResetEvent( false );

             try
            {
                TimeoutState waitOrTimeoutState  =   new  TimeoutState(Thread.CurrentThread, state);

                ThreadPool.RegisterWaitForSingleObject(e, WaitOrTimeout, waitOrTimeoutState, timeout,  true );

                 return  workCallback(argv);
            }
             finally
            {
                e.Set();
            }
        };

        IAsyncResult asyncResult  =  wrapper.BeginInvoke(arg, asyncCallback, state);

         return  asyncResult;
    }

     public   object  EndInvoke(IAsyncResult result)
    {
         return  wrapper.EndInvoke(result);
    }

     protected   void  WaitOrTimeout( object  state,  bool  isTimeout)
    {
         try
        {
             if  (isTimeout)
            {
                TimeoutState waitOrTimeoutState  =  state  as  TimeoutState;

                 if  ( null   !=  cancelCallback)
                {
                    cancelCallback(waitOrTimeoutState.state);
                }
                 else
                {
                    waitOrTimeoutState.thread.Abort();
                }
            }
        }
         catch  { }
    }
}

总结

本文为.NET APM模型提供了异步超时机制扩展，一方面保持了APM编程风格，另一方面支持用户自定义cancel回调。需要注意的是，默认的cancel方式Thread.Abort的安全性问题，使用时应注意资源释放等。

作者

http://www.cnblogs.com/weidagang2046/，欢迎就线程问题交流探讨。