异步操作

　　对于游戏开发而言，经常使用到异步相关操作，因此在使用moduleframework之前应该提供一个异步操作的类。 以后相关的异步操作均继承这个类

　　AsyncOperation:

　　先贴出代码：

　　#ifndef __ASYNC_OPERATION_H__

　　#define __ASYNC_OPERATION_H__

　　#include

　　class AsyncOperation

　　{

　　public:

　　typedef boost::function(void) TypeOnExecute;

　　typedef boost::function(void) TypeOnComplete;

　　typedef boost::function(void) TypeOnAborted;

　　// 委托执行函数

　　explicit AsyncOperation(TypeOnExecute onExecute)

　　:_onExecute(onExecute)

　　{

　　if(!_onExecute) throw "onExecute is NULL";

　　}

　　virtual AsyncOperation(){}

　　void Execute(TypeOnComplete onComplete, TypeOnAborted onAorted = NULL)

　　{

　　if (!_onComplete) throw "onComplete is NULL"

　　_onComplete = onComplete;

　　_onAborted = onAorted;

　　_onExecute(this);

　　}

　　virtual void Abort()

　　{

　　}

　　void Complete()

　　{

　　_onComplete(this);

　　}

　　private:

　　TypeOnExecute _onExecute;

　　TypeOnComplete _onComplete;

　　TypeOnAborted _onAborted;

　　};

　　#endif

　　真正的执行函数是Execute 另外提供了一个完成 和终止的接口。

　　这个类应该比较简单。

　　在此类的基础上构建一个异步队列。 AsyncQueue继承该类

　　#ifndef __ASYNC_QUEUE_H__

　　#define __ASYNC_QUEUE_H__

　　#include

　　#include "AsyncOpertaion.hpp"

　　#include

　　#include

　　using namespace std;

　　class AsyncQueue : public AsyncQueue

　　{

　　public:

　　// 构造函数默认调用ExecuteNextChild来启动整个异步进程

　　AsyncQueue(): AsyncOperation(boost::bind(&AsyncQueue::ExecuteNextChild, this, _1))

　　, _abortFlag(false)

　　{

　　}

　　~AsyncQueue()

　　{

　　TypeOptQueue::iterator it = _queue.begin();

　　for (; it != _queue.end(); ++it)

　　{

　　delete *it;

　　}

　　}

　　// 加入队列

　　void Push(AsyncOperation* operation)

　　{

　　_queue.push_back(operation);

　　}

　　// 终止执行

　　void Abort()

　　{

　　if(_queue.empty()) return;

　　_abortFlag = true;

　　AsyncOperation* front = _queue.front();

　　front->Abort(); // 终止队列首位的执行

　　}

　　private:

　　void ExecuteNextChild(AsyncOperation* operation)

　　{

　　if(_queue.empty())

　　{

　　LOG(ERROR) << "Async Queue is Empty!";

　　return;

　　}

　　// 迭代执行_queue中的操作

　　AsyncOperation* front = _queue.front();

　　front->Execute(boost::bind(&AsyncQueue::OnChildComplete, this, _1));

　　}

　　void OnChildComplete(AsyncOperation* operation)

　　{

　　// 移除已执行的异步操作

　　_queue.pop_front();

　　delete operation;

　　if (_queue.empty())

　　{

　　// 通知队列执行完成

　　Complete();

　　return;

　　}

　　if (_abortFlag && _onAborted)

　　{

　　_onAborted(this);

　　}else

　　{

　　// 迭代执行

　　ExecuteNextChild(0);

　　}

　　}

　　private:

　　typedef deque TypeOptQueue; // 使用队列来包装

　　TypeOptQueue _queue;

　　bool _abortFlag;

　　};

　　#endif

　　这里一个巧妙指出在于 如果迭代执行整个异步队列， 注意看 构造函数和OnExecuteNextChild 这两点 。