ACE 主动对象模式的按部就班的实现方法

ACE的主动对象模式的实现

对分布式系统设计来说，ACE提供的主动对象模式是让我们在系统框架构建的时候，回归到传统的单线程编程思维。你可能要问，既然有主动对象，那必然有被动对象，没有错，确实有被动对象，那到底什么是主动对象？什么又是被动对象呢？

被动对象：

假如我们要给一个客户端提供一个方法，计算两个数之和。我们一般定义一个对象，然后实现具体的加法运算操作，客户端在调用的时候，首先实例化我们这个对象，然后再执行这个方法。此时，这个对象的加法运算操作的执行和客户端的调用线程在一个线程中完成。这是标准的单线程执行顺序。我们把这种对象叫做被动对象，被动对象所提供的方法叫做被动对象的方法。

主动对象：

同理，假如我们要给一个客户端提供一个方法，计算两个数之和。同样我们如果实现了一个主动对象，同时给这个主动对象增加一个计算两个数之和的主动对象方法，那么当客户端调用这个主动对象所提供的方法的时候，这个对象的加法运算操作的执行和客户端的调用线程就不在一个线程中完成。而是在另外的一个线程中执行。我们把这种对象叫做主动对象，主动对象所提供的方法叫做主动对象的方法。

 

 

// ActiveObject.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "ace/OS_NS_unistd.h"
#include "ace/Activation_Queue.h"
#include "ace/Method_Request.h"
#include "ace/Task.h"
#include "ace/Future.h"
#include "ace/Auto_Ptr.h"

class CAdd;
class CAdd_MethordRequest;
class CScheduler;
class CAgent;

//第一步： 实现一个被动对象
class CAdd
{
public:
	CAdd(int a1, int a2)
	{
		m_a1 = a1;
		m_a2 = a2;
	}
	~CAdd(void)
	{
	}
public:
	int calculate_add()
	{
		return m_a1 + m_a2;
	}

	int geta1()
	{
		return m_a1;
	}

	int geta2()
	{
		return m_a2;
	}
private:
	int m_a1;
	int m_a2;
};

//第二步：从 ACE_Method_Request 继承一个对象，实现他的虚函数 void call()
class CAdd_MethordRequest : public ACE_Method_Request
{
public:
	CAdd_MethordRequest(CAdd add, ACE_Future<int>& retvalue)
	{
		m_padd = new CAdd(add.geta1(), add.geta2());
		returnVal_ = retvalue;
	}
	~CAdd_MethordRequest(void)
	{
		delete m_padd;
	}
public:
	virtual int call(void)
	{
		this->returnVal_.set(this->m_padd->calculate_add());
		return 0;
	}
private:
	CAdd *m_padd;
	ACE_Future<int> returnVal_;
};

//第三步，实现一个task, 其中定义一个ACE_Activation_Queue对象
class CScheduler : public ACE_Task_Base
{
public:
	CScheduler(void)
	{  
		this->activate();
	}

	~CScheduler(void)
	{
	}

public:
	virtual int svc (void)
	{
		while (1)
		{
			auto_ptr<ACE_Method_Request> request (this->activation_queue_.dequeue());
			if (request->call() == -1) break;
		}
		return 0;
	}
	int enqueue (ACE_Method_Request *request)
	{
		return this->activation_queue_.enqueue (request);
	}

private:
	ACE_Activation_Queue activation_queue_;
};

//第四步，实现一个主动对象
class Agent
{
public:
	Agent()
	{
	}
	~Agent(void)
	{
	}
public:
	//这个才是真正的主动对象的方法，这个方法才是客户端调用的真正的方法
	ACE_Future<int> calculate_add(int a1, int a2)
	{
		ACE_Future<int> result;
		CAdd add(a1, a2);
		this->scheduler_.enqueue(new CAdd_MethordRequest(add, result));
		return result;
	}
private:
	CScheduler scheduler_;
};


int main(int argc, char* argv[])
{
	ACE_Future<int> results[10];
	//定义主动对象
	Agent agent;
	for (int i = 0 ; i < 10; i++)
	{		
		//调用主动对象的方法
		results[i] = agent.calculate_add(i, i);
	}

	//模拟客户端去做其他事情了
	ACE_OS::sleep (5);  

	//这个事检测调用了主动对象方法的返回值，在时间情况中在其他线程中。
	for (int j = 0; j < 10; j++)
	{
		int result = 0;
		results[j].get(result);
		ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("calculate result: %d
"), result));
	}

	ACE_Thread_Manager::instance ()->wait ();

	return 0;
}