ACE队列用法

#include "ace/Log_Msg.h"
#include "ace/OS.h"
#include "ace/Task.h"
#include "ace/Method_Request.h"
#include "ace/Future.h"
#include "ace/Activation_Queue.h"
#include <memory.h>
using namespace std;

#pragma comment(lib,"ace.lib")

class Servant
{
public:
    Servant()
    {
        status_result_ = 1;
    }
    int status_update(void) 
    {
        ACE_DEBUG((LM_DEBUG, ACE_TEXT("Obtaining a status_update in %t ") ACE_TEXT("thread of control\n")));
        ACE_OS::sleep(2);
        return next_result_id();
    }
private:
    int next_result_id(void)
    {
        return status_result_++;
    };
    int status_result_;
};

class StatusUpdate : public ACE_Method_Request
{
public:
    StatusUpdate(Servant & controller, ACE_Future<int>&returnval)
        : controller_(controller), returnVal_(returnval)
    {
        ACE_DEBUG((LM_DEBUG, "StatusUpdate::StatusUpdate.\n"));
    }
    virtual int call(void)
    {
        ACE_DEBUG((LM_DEBUG, "StatusUpdate::call.\n "));
        this->returnVal_.set(this->controller_.status_update());
        return 0;
    }
    
    private:
    Servant& controller_;
    ACE_Future<int> returnVal_;

};

class ExitMethod : public ACE_Method_Request
{
public:
    virtual int call(void)
    {
        return -1;
    }
};

class Scheduler : public ACE_Task_Base
{
public:
    Scheduler()
    {
        ACE_DEBUG((LM_DEBUG, "Scheduler::Scheduler.\n"));
        this->activate();
    }

    virtual int svc(void)
    {
        ACE_DEBUG((LM_DEBUG, "Scheduler::svc.\n"));
        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) 
    {
        ACE_DEBUG((LM_DEBUG, "Proxy::enqueue.\n"));
        return this->activation_queue_.enqueue(request);
    }
    private:
    ACE_Activation_Queue activation_queue_;
};
class Proxy
{
public:
    ACE_Future<int> status_update(void)
    {
        ACE_DEBUG((LM_DEBUG, "Proxy::status_update.\n"));
        ACE_Future<int> result;
        this->scheduler_.enqueue(new StatusUpdate(this->controller_, result));
        return result;
    }
    void exit(void)
    {
         ACE_DEBUG((LM_DEBUG, "Proxy::exit.\n"));
         this->scheduler_.enqueue(new ExitMethod);
    }
    private:
        Scheduler scheduler_;
        Servant controller_;
};

int ACE_TMAIN(int, ACE_TCHAR* [])
{
    Proxy controller;
    ACE_Future<int> results[10];
//客户通过Proxy接口发起累加方法请求
    for (int i = 0; i < 10; i++)
    results[i] = controller.status_update();
    ACE_OS::sleep(5);
//客户获取运行结果
    for (int j = 0; j < 10; j++)
    {
         int result = 0;
         results[j].get(result);
         ACE_DEBUG((LM_DEBUG, "[%D(%t)] result %d\n", result));
    }
    controller.exit(); //线程退出
    ACE_Thread_Manager::instance()->wait();
    system("pause");
    return 0;
}

输出结果如下：