/// <summary>
/// 指定异步任务状态，并从指定的状态开始执行,必须由主线程来调用
/// </summary>
/// <param name="state">指定异步任务的状态</param>
/// <param name="asyncTask">异步任务对象</param>
public void ExecuteAsyncTask(AsyncState state, IAsyncTask asyncTask)
{
switch (state)
{
case AsyncState.BeforeAsync:
{
//异步开始前执行，由主线程调用
AsyncState newState = asyncTask.BeforeAsyncTask();
if (newState == AsyncState.BeforeAsync)
{
throw new ApplicationException(string.Format("asyncTask:{0} [BeforeAsyncTask] infinite loop.", asyncTask.GetType().FullName));
}
this.ExecuteAsyncTask(newState, asyncTask);
break;
}
case AsyncState.DoAsync:
{
//需要异步执行，委托线程池来执行该任务
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncExecute), asyncTask);
break;
}
case AsyncState.AfterAsync:
{
AsyncState newState = asyncTask.AfterAsyncTask();
if (newState == AsyncState.AfterAsync)
{
throw new ApplicationException(string.Format("asyncTask:{0} [AfterAsyncTask] infinite loop.", asyncTask.GetType().FullName));
}
this.ExecuteAsyncTask(newState, asyncTask);
break;
}
default:
{
break;
}
}
}
/// <summary>
/// Thread function, keeps running.
/// </summary>
protected void Run()
{
while (_started)
{
IAsyncTask evnt = null;
try
{
lock (this)
{
if ((_eventsHi.Count < 1) && (_eventsLow.Count < 1) && !_isShutdown)
{
Monitor.Wait(this);
}
if ((_eventsHi.Count < 1) && _isShutdown)
{
lock (_shutdownMutex)
{
Monitor.PulseAll(_shutdownMutex);
break;
}
}
if (_eventsHi.Count > 0)
{
evnt = (IAsyncTask)_eventsHi.Dequeue();
}
else if (_eventsLow.Count > 0)
{
evnt = (IAsyncTask)_eventsLow.Dequeue();
}
}
if (evnt == null && _eventsHi.Count < 1 && _isShutdown)
{
lock (_shutdownMutex)
{
Monitor.PulseAll(_shutdownMutex);
break;
}
}
if (evnt == null)
{
continue;
}
evnt.Process();
}
catch (ThreadAbortException e)
{
if (NCacheLog != null)
{
NCacheLog.Flush();
}
break;
}
catch (ThreadInterruptedException e)
{
if (NCacheLog != null)
{
NCacheLog.Flush();
}
break;
}
catch (NullReferenceException nr) { }
catch (Exception e)
{
string exceptionString = e.ToString();
if (exceptionString != "ChannelNotConnectedException" && exceptionString != "ChannelClosedException")
{
if (NCacheLog != null)
{
NCacheLog.Error("AsyncProcessor.Run()", "Task name: " + evnt.GetType().FullName + " Exception: " + exceptionString);
}
}
}
}
}
/// <summary>
/// 指定异步任务状态，并从指定的状态开始执行,必须由主线程来调用
/// </summary>
/// <param name="state">指定异步任务的状态</param>
/// <param name="asyncTask">异步任务对象</param>
public void ExecuteAsyncTask(AsyncState state, IAsyncTask asyncTask)
{
switch (state)
{
case AsyncState.BeforeAsync:
{
//异步开始前执行，由主线程调用
AsyncState newState = asyncTask.BeforeAsyncTask();
if (newState == AsyncState.BeforeAsync)
{
throw new ApplicationException(string.Format("asyncTask:{0} [BeforeAsyncTask] infinite loop.", asyncTask.GetType().FullName));
}
this.ExecuteAsyncTask(newState, asyncTask);
break;
}
case AsyncState.DoAsync:
{
//需要异步执行，委托线程池来执行该任务
ThreadPool.QueueUserWorkItem(new WaitCallback(AsyncExecute), asyncTask);
break;
}
case AsyncState.AfterAsync:
{
AsyncState newState = asyncTask.AfterAsyncTask();
if (newState == AsyncState.AfterAsync)
{
throw new ApplicationException(string.Format("asyncTask:{0} [AfterAsyncTask] infinite loop.", asyncTask.GetType().FullName));
}
this.ExecuteAsyncTask(newState, asyncTask);
break;
}
default:
{
break;
}
}
}
protected override void Beat()
{
IInternalMessage message = SystemMessageQueue.Instance.Poll();
if (message != null)
{
switch (message.GetMessageId())
{
case AsyncTaskMessage.ASYNC_MESSAGE_ID:
{
AsyncTaskMessage asyncTaskMessage = message as AsyncTaskMessage;
AsyncState state = asyncTaskMessage.State;
IAsyncTask asyncTask = asyncTaskMessage.AsyncTask;
if (state == AsyncState.DoAsync)
{
throw new ApplicationException(string.Format("asyncTask:{0} [DoAsyncTask] infinite loop.", asyncTask.GetType().FullName));
}
AsyncManager.Instance.ExecuteAsyncTask(state, asyncTask);
break;
}
default:
{
break;
}
}
}
}
