主动对象模式

最新推荐文章于 2021-07-19 10:19:52 发布
最新推荐文章于 2021-07-19 10:19:52 发布
阅读量346 收藏
点赞数
文章标签： string object os class 任务 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mopname/article/details/6636212
版权

主动对象模式用于降低方法执行和方法调用之间的耦合。该模式描述了另外一种更为透明的任务间通信方法。

传统上，所有的对象都是被动的代码段，对象中的代码是在对它发出方法调用的线程中执行的，当方法被调用时，调用线程将阻塞，直至调用结束。而主动对象却不一样。这些对象具有自己的命令执行线程，主动对象的方法将在自己的执行线程中执行，不会阻塞调用方法。

例如，设想对象"A"已在你的程序的main()函数中被实例化。当你的程序启动时，OS创建一个线程，以从main()函数开始执行。如果你调用对象A的任何方法，该线程将"流过"那个方法，并执行其中的代码。一旦执行完成，该线程返回调用该方法的点并继续它的执行。但是，如果"A"是主动对象，事情就不是这样了。在这种情况下，主线程不会被主动对象借用。相反，当"A"的方法被调用时，方法的执行发生在主动对象持有的线程中。另一种思考方法：如果调用的是被动对象的方法（常规对象），调用会阻塞（同步的）；而另一方面，如果调用的是主动对象的方法，调用不会阻塞（异步的）。

由于主动对象的方法调用不会阻塞，这样就提高了系统响应速度，在网络编程中是大有用武之地的。

在这里我们将一个"Logger"（日志记录器）对象对象为例来介绍如何将一个传统对象改造为主动对象，从而提高系统响应速度。

Logger的功能是将一些系统事件的记录在存储器上以备查询，由于Logger使用慢速的I/O系统来记录发送给它的消息，因此对Logger的操作将会导致系统长时间的等待。

其功能代码简化如下：

Cpp代码   收藏代码
  1. class Logger: public ACE_Task<ACE_MT_SYNCH>  
  2. {  
  3. public:  
  4.     void LogMsg(const string& msg)  
  5.     {  
  6.         cout<<endl<<msg<<endl;  
  7.         ACE_OS::sleep(2);  
  8.     }  
  9. };  
class Logger: public ACE_Task<ACE_MT_SYNCH>
{
public:
    void LogMsg(const string& msg)
    {
        cout<<endl<<msg<<endl;
        ACE_OS::sleep(2);
    }
};
 

为了实现实现记录日志操作的主动执行，我们需要用命令模式将其封装，从而使得记录日志的方法能在合适的时间和地方主动执行，封装方式如下：

Cpp代码   收藏代码
  1. class LogMsgCmd: public ACE_Method_Object  
  2. {  
  3. public:  
  4.     LogMsgCmd(Logger *plog,const string& msg)  
  5.     {  
  6.         this->log=plog;  
  7.         this->msg=msg;  
  8.     }  
  9.   
  10.     int call()  
  11.     {  
  12.         this->log->LogMsg(msg);  
  13.         return 0;  
  14.     }  
  15.   
  16. private:  
  17.     Logger *log;  
  18.     string msg;  
  19. };  
  20.   
  21. class Logger: public ACE_Task<ACE_MT_SYNCH>  
  22. {  
  23. public:  
  24.     void LogMsg(const string& msg)  
  25.     {  
  26.         cout<<endl<<msg<<endl;  
  27.         ACE_OS::sleep(2);  
  28.     }  
  29.   
  30.     LogMsgCmd *LogMsgActive(const string& msg)  
  31.     {  
  32.         new LogMsgCmd(this,msg);  
  33.     }  
  34. };  
class LogMsgCmd: public ACE_Method_Object
{
public:
    LogMsgCmd(Logger *plog,const string& msg)
    {
        this->log=plog;
        this->msg=msg;
    }

    int call()
    {
        this->log->LogMsg(msg);
        return 0;
    }

private:
    Logger *log;
    string msg;
};

class Logger: public ACE_Task<ACE_MT_SYNCH>
{
public:
    void LogMsg(const string& msg)
    {
        cout<<endl<<msg<<endl;
        ACE_OS::sleep(2);
    }

    LogMsgCmd *LogMsgActive(const string& msg)
    {
        new LogMsgCmd(this,msg);
    }
};
 

这里对代码功能做一下简单的说明：

ACE_Method_Object是ACE提供的命令模式借口，命令接口调用函数为int call()，在这里通过它可以把每个操作日志的调用封装为一个LogMsgCmd对象，这样，当原来需要调用LogMsg的方法的地方只要调用LogMsgActive即可生成一个LogMsgCmd对象，由于调用LogMsgActive方法，只是对命令进行了封装，并没有进行日志操作，所以该方法会立即返回。然后再新开一个线程，将LogMsgCmd对象作为参数传入，在该线程中执行LogMsgCmd对象的call方法，从而实现无阻塞调用。

然而，每次对一个LogMsg调用都开启一个新线程，无疑是对资源的一种浪费，实际上我们往往将生成的LogMsgCmd对象插入一个命令队列中，只新开一个命令执行线程依次执行命令队列中的所有命令。并且，为了实现对象的封装，命令队列和命令执行线程往往也封装到Logger对象中，代码如下所示：

Cpp代码   收藏代码
  1. #include "ace/OS.h"  
  2. #include "ace/Task.h"  
  3. #include "ace/Method_Object.h"  
  4. #include "ace/Activation_Queue.h"  
  5. #include "ace/Auto_Ptr.h"  
  6.   
  7. #include <string>  
  8. #include <iostream>  
  9. using namespace std;  
  10.   
  11. class Logger: public ACE_Task<ACE_MT_SYNCH>  
  12. {  
  13. public:  
  14.     Logger()  
  15.     {  
  16.         this->activate();  
  17.     }  
  18.   
  19.     int svc();  
  20.     void LogMsg(const string& msg);  
  21.     void LogMsgActive (const string& msg);  
  22.   
  23. private:  
  24.     ACE_Activation_Queue cmdQueue;    //命令队列  
  25. };  
  26.   
  27. class LogMsgCmd: public ACE_Method_Object  
  28. {  
  29. public:  
  30.     LogMsgCmd(Logger *plog,const string& msg)  
  31.     {  
  32.         this->log=plog;  
  33.         this->msg=msg;  
  34.     }  
  35.   
  36.     int call()  
  37.     {  
  38.         this->log->LogMsg(msg);  
  39.         return 0;  
  40.     }  
  41.   
  42. private:  
  43.     Logger *log;  
  44.     string msg;  
  45. };  
  46.   
  47. void Logger::LogMsg(const string& msg)  
  48. {  
  49.     cout<<endl<<msg<<endl;  
  50.     ACE_OS::sleep(2);  
  51. }  
  52.   
  53. //以主动的方式记录日志  
  54. void Logger::LogMsgActive(const string& msg)  
  55. {  
  56.     //生成命令对象，插入到命令队列中  
  57.     cmdQueue.enqueue(new LogMsgCmd(this,msg));  
  58. }  
  59.   
  60. int Logger::svc()  
  61. {  
  62.     while(true)  
  63.     {  
  64.         //遍历命令队列，执行命令  
  65.         auto_ptr<ACE_Method_Object> mo  
  66.             (this->cmdQueue.dequeue ());  
  67.   
  68.         if (mo->call () == -1)  
  69.             break;  
  70.     }  
  71.     return 0;  
  72. }  
  73.   
  74. int main (int argc, ACE_TCHAR *argv[])  
  75. {  
  76.     Logger log;  
  77.     log. LogMsgActive ("hello");  
  78.   
  79.     ACE_OS::sleep(1);  
  80.     log.LogMsgActive("abcd");  
  81.   
  82.     while(true)  
  83.         ACE_OS::sleep(1);  
  84.   
  85.     return 0;  
  86. }  
#include "ace/OS.h"
#include "ace/Task.h"
#include "ace/Method_Object.h"
#include "ace/Activation_Queue.h"
#include "ace/Auto_Ptr.h"

#include <string>
#include <iostream>
using namespace std;

class Logger: public ACE_Task<ACE_MT_SYNCH>
{
public:
    Logger()
    {
        this->activate();
    }

    int svc();
    void LogMsg(const string& msg);
    void LogMsgActive (const string& msg);

private:
    ACE_Activation_Queue cmdQueue;    //命令队列
};

class LogMsgCmd: public ACE_Method_Object
{
public:
    LogMsgCmd(Logger *plog,const string& msg)
    {
        this->log=plog;
        this->msg=msg;
    }

    int call()
    {
        this->log->LogMsg(msg);
        return 0;
    }

private:
    Logger *log;
    string msg;
};

void Logger::LogMsg(const string& msg)
{
    cout<<endl<<msg<<endl;
    ACE_OS::sleep(2);
}

//以主动的方式记录日志
void Logger::LogMsgActive(const string& msg)
{
    //生成命令对象，插入到命令队列中
    cmdQueue.enqueue(new LogMsgCmd(this,msg));
}

int Logger::svc()
{
    while(true)
    {
        //遍历命令队列，执行命令
        auto_ptr<ACE_Method_Object> mo
            (this->cmdQueue.dequeue ());

        if (mo->call () == -1)
            break;
    }
    return 0;
}

int main (int argc, ACE_TCHAR *argv[])
{
    Logger log;
    log. LogMsgActive ("hello");

    ACE_OS::sleep(1);
    log.LogMsgActive("abcd");

    while(true)
        ACE_OS::sleep(1);

    return 0;
}
 

在这里需要注意一下命令队列ACE_Activation_Queue对象，它是线程安全的，使用方法比较简单，这里我也不多介绍了。

主动对象的基本结构就是这样，然而，由于主动对象是异步调用的，又引出了如下两个新问题：

  1. 方法调用线程如何知道该方法已经执行完成？
  2. 如何或得方法的返回值？

这两个问题将在下回给与解决。

在上篇文章里，我们简单的介绍了一下ACE主动对象实现方式，同时提出了两个问题：

  1. 方法调用线程如何知道该方法已经执行完成？　
  2. 如何或得方法的返回值？

要解决这两个问题，首先得介绍一下ACE_Future对象，ACE_Future是表示一个会在将来被赋值的"期货"对象，可以通过ready()函数查询它是否已经被赋值。该对象创建的时候是未赋值的，后期可以通过set()函数来进行赋值，所赋的值可以通过get()函数来获取。

下面代码演示了它的基本用法：

Cpp代码   收藏代码
  1. #include "ace/Future.h"  
  2.   
  3. #include <string>  
  4. #include <iostream>  
  5. using namespace std;  
  6.   
  7. void get_info(ACE_Future<string> &fu)  
  8. {  
  9.     string state = fu.ready()?"ready":"not ready";  
  10.     cout<<endl<<state<<endl;  
  11.     if(fu.ready())  
  12.     {  
  13.         string value;  
  14.         fu.get(value);  
  15.         cout<<"value:\t"<<value<<endl;  
  16.     }  
  17. }  
  18.   
  19. int main(int argc, char *argv[])  
  20. {  
  21.     ACE_Future<string> fu;  
  22.     get_info(fu);  
  23.     fu.set("12345");  
  24.     get_info(fu);  
  25.   
  26.     return 0;  
  27. }  
#include "ace/Future.h"

#include <string>
#include <iostream>
using namespace std;

void get_info(ACE_Future<string> &fu)
{
    string state = fu.ready()?"ready":"not ready";
    cout<<endl<<state<<endl;
    if(fu.ready())
    {
        string value;
        fu.get(value);
        cout<<"value:\t"<<value<<endl;
    }
}

int main(int argc, char *argv[])
{
    ACE_Future<string> fu;
    get_info(fu);
    fu.set("12345");
    get_info(fu);

    return 0;
}
 

通过ACE_Future对象来解决上述两个问题的方法如下：

  • 首先创建ACE_Future对象用以保留返回值。
  • 调用主动命令时将ACE_Future对象作为参数传入，生成的命令对象中保存ACE_Future对象的指针。
  • 命令执行线程执行完命令后，将返回值通过set()函数设置到ACE_Future对象中。
  • 调用线程可以通过ACE_Future对象的ready()函数查询该命令是否执行完成，如果命令执行完成，则可通过get()函数来获取返回值。

使用的时候要注意一下ACE_Future对象的生命周期。

为了演示了如何获取主动命令的执行状态和结果，我将上篇文章中的代码改动了一下，日志类记录日志后，会将记录的内容作为返回值返回，该返回值会通过ACE_Future对象返回，代码如下：

Cpp代码   收藏代码
  1. #include "ace/OS.h"  
  2. #include "ace/Task.h"  
  3. #include "ace/Method_Object.h"  
  4. #include "ace/Activation_Queue.h"  
  5. #include "ace/Auto_Ptr.h"  
  6.   
  7. #include "ace/Future.h"  
  8.   
  9. #include <string>  
  10. #include <iostream>  
  11. using namespace std;  
  12.   
  13. class Logger: public ACE_Task<ACE_MT_SYNCH>  
  14. {  
  15. public:  
  16.     Logger()  
  17.     {  
  18.         this->activate();  
  19.     }  
  20.   
  21.     int svc();  
  22.     string LogMsg(const string& msg);  
  23.     void LogMsgActive (const string& msg,ACE_Future<string> *result);  
  24.   
  25. private:  
  26.     ACE_Activation_Queue cmdQueue; //命令队列  
  27. };  
  28.   
  29. class LogMsgCmd: public ACE_Method_Object  
  30. {  
  31. public:  
  32.     LogMsgCmd(Logger *plog,const string& msg,ACE_Future<string> *result)  
  33.     {  
  34.         this->log=plog;  
  35.         this->msg=msg;  
  36.         this->result=result;  
  37.     }  
  38.   
  39.     int call()  
  40.     {  
  41.         string reply = this->log->LogMsg(msg);  
  42.         result->set(reply);  
  43.         return 0;  
  44.     }  
  45.   
  46. private:  
  47.     ACE_Future<string> *result;  
  48.     Logger *log;  
  49.     string msg;  
  50. };  
  51.   
  52. string Logger::LogMsg(const string& msg)  
  53. {  
  54.     ACE_OS::sleep(2);  
  55.     cout<<endl<<msg<<endl;  
  56.     return msg;  
  57. }  
  58.   
  59. //以主动的方式记录日志  
  60. void Logger::LogMsgActive(const string& msg,ACE_Future<string> *result)  
  61. {  
  62.     //生成命令对象，插入到命令队列中  
  63.     cmdQueue.enqueue(new LogMsgCmd(this,msg,result));  
  64. }  
  65.   
  66. int Logger::svc()  
  67. {  
  68.     while(true)  
  69.     {  
  70.         //遍历命令队列，执行命令  
  71.         auto_ptr<ACE_Method_Object> mo  
  72.             (this->cmdQueue.dequeue ());  
  73.   
  74.         if (mo->call () == -1)  
  75.             break;  
  76.     }  
  77.     return 0;  
  78. }  
  79.   
  80. void get_info(ACE_Future<string> &fu)  
  81. {  
  82.     string state = fu.ready()?"ready":"not ready";  
  83.     cout<<endl<<state<<endl;  
  84.     if(fu.ready())  
  85.     {  
  86.         string value;  
  87.         fu.get(value);  
  88.         cout<<"value:\t"<<value<<endl;  
  89.     }  
  90. }  
  91.   
  92. int main (int argc, ACE_TCHAR *argv[])  
  93. {  
  94.     ACE_Future<string> result;  
  95.     Logger log;  
  96.     log.LogMsgActive ("hello",&result);  
  97.   
  98.     while(true)  
  99.     {  
  100.         get_info(result);  
  101.         if(result.ready())  
  102.             break;  
  103.         ACE_OS::sleep(1);  
  104.     }  
  105.   
  106.     cout<<endl<<"cmd end"<<endl;  
  107.   
  108.     while(true)  
  109.         ACE_OS::sleep(1);  
  110.   
  111.     return 0;  
  112. }  
#include "ace/OS.h"
#include "ace/Task.h"
#include "ace/Method_Object.h"
#include "ace/Activation_Queue.h"
#include "ace/Auto_Ptr.h"

#include "ace/Future.h"

#include <string>
#include <iostream>
using namespace std;

class Logger: public ACE_Task<ACE_MT_SYNCH>
{
public:
    Logger()
    {
        this->activate();
    }

    int svc();
    string LogMsg(const string& msg);
    void LogMsgActive (const string& msg,ACE_Future<string> *result);

private:
    ACE_Activation_Queue cmdQueue; //命令队列
};

class LogMsgCmd: public ACE_Method_Object
{
public:
    LogMsgCmd(Logger *plog,const string& msg,ACE_Future<string> *result)
    {
        this->log=plog;
        this->msg=msg;
        this->result=result;
    }

    int call()
    {
        string reply = this->log->LogMsg(msg);
        result->set(reply);
        return 0;
    }

private:
    ACE_Future<string> *result;
    Logger *log;
    string msg;
};

string Logger::LogMsg(const string& msg)
{
    ACE_OS::sleep(2);
    cout<<endl<<msg<<endl;
    return msg;
}

//以主动的方式记录日志
void Logger::LogMsgActive(const string& msg,ACE_Future<string> *result)
{
    //生成命令对象，插入到命令队列中
    cmdQueue.enqueue(new LogMsgCmd(this,msg,result));
}

int Logger::svc()
{
    while(true)
    {
        //遍历命令队列，执行命令
        auto_ptr<ACE_Method_Object> mo
            (this->cmdQueue.dequeue ());

        if (mo->call () == -1)
            break;
    }
    return 0;
}

void get_info(ACE_Future<string> &fu)
{
    string state = fu.ready()?"ready":"not ready";
    cout<<endl<<state<<endl;
    if(fu.ready())
    {
        string value;
        fu.get(value);
        cout<<"value:\t"<<value<<endl;
    }
}

int main (int argc, ACE_TCHAR *argv[])
{
    ACE_Future<string> result;
    Logger log;
    log.LogMsgActive ("hello",&result);

    while(true)
    {
        get_info(result);
        if(result.ready())
            break;
        ACE_OS::sleep(1);
    }

    cout<<endl<<"cmd end"<<endl;

    while(true)
        ACE_OS::sleep(1);

    return 0;
}
 

代码比较简单，这里就不多解释了。

这种查询模式比较简单有效，但存在一个问题：调用线程必须不断轮询ACE_Future对象以获取返回值，这样的效率比较低。可以通过观察者模式解决这个问题：在ACE_Future对象上注册一个观察者，当ACE_Future对象的值发生改变（异步命令执行完成）时主动通知该观察者，从而获取返回值。

ACE中的观察者模式可以通过ACE_Future_Observer来实现，使用方法如下：

Cpp代码   收藏代码
  1. #include "ace/Future.h"  
  2.   
  3. #include <string>  
  4. #include <iostream>  
  5. using namespace std;  
  6.   
  7. class MyObserver:public ACE_Future_Observer<string>  
  8. {  
  9.     virtual void update (const ACE_Future<string> &future)  
  10.     {  
  11.         string value;  
  12.         future.get(value);  
  13.         cout<<endl<<"change:\t"<<value<<endl;  
  14.     }  
  15. };  
  16.   
  17. int main(int argc, char *argv[])  
  18. {  
  19.     MyObserver obv;  
  20.     ACE_Future<string> fu;  
  21.   
  22.     fu.attach(&obv);  
  23.       
  24.     ACE_OS::sleep(3);  
  25.     fu.set("12345");  
  26.   
  27.     while(true)  
  28.         ACE_OS::sleep(3);  
  29.   
  30.     return 0;  
  31. }  
#include "ace/Future.h"

#include <string>
#include <iostream>
using namespace std;

class MyObserver:public ACE_Future_Observer<string>
{
    virtual void update (const ACE_Future<string> &future)
    {
        string value;
        future.get(value);
        cout<<endl<<"change:\t"<<value<<endl;
    }
};

int main(int argc, char *argv[])
{
    MyObserver obv;
    ACE_Future<string> fu;

    fu.attach(&obv);
    
    ACE_OS::sleep(3);
    fu.set("12345");

    while(true)
        ACE_OS::sleep(3);

    return 0;
}
 

通过观察者模式，可以更有效，及时的获取异步命令的返回值,但同时也增加了程序结构的复杂度并且难以调试，使用的时候应该根据需要选取合适的方式。



mopname
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Head First 设计模式
05-20
作者旨在避免直接给出答案，而是鼓励读者主动思考，通过问题与解答之间的互动，让读者逐步理解和掌握设计模式的核心思想。 书中涵盖了多种经典的设计模式，如工厂模式（Factory Method）、抽象工厂模式（Abstract ...
软件设计模式文档资源详细描述
03-26
在本文中，我们将深入探讨“观察者模式”（Observer Pattern），这是设计模式中的一种行为模式，用于处理对象间的一对多依赖关系。 观察者模式的主要意图是定义一种对象间的一对多依赖关系，当一个对象的状态发生...
Active Object Pattern（主动对象模式理解）
瞎几波写
07-19 616
之所以叫主动对象, 区别于被动对象, 只能被动被别人调用的对象, 而主动对象内部有线程可以自行调用自己的方法. Active Object首先使用了Proxy模式, 这个和RPC一样, 用户可以象访问local function一样使用 然后Active Object关键的一步是使用command模式分离invacation和execution, proxy并没有直接运行调用逻辑, 而是封装成command发送给invoker queue Active Object 设计模式的本质是解耦合方法的调用
主动对象模式(Active Object pattern)
weixin_30416497的博客
05-15 305
摘 要 　 本论文描述主动对象（Active Object）模式。该模式使方法执行与方法调用去耦合，以简化对驻留在它自己的线程控制中的对象的同步访问。主动对象模式允许一或多个交错访问数据的独立执行的线程被建模为单个对象。这一并发模式能良好地适用于广泛的生产者/消费者和读者/作者应用类。该模式通常用于需要多线程服务器的分布式系统中。此外，客户应用，比如窗口系统和网络浏览器，采用主动对象来简化并发...
设计模式- 主动对象（Active Object）
11-25 4457
原标题：Active Object －An Object Behavioral Pattern for Concurrent Programming源文地址：http://www.cs.wustl.edu/~schmidt/PDF/Act-Obj.pdf译者：cuichaox@gmail.com译者注：1.    对象分为主动对象和被动对象，主动对象内部包含一个线程，可以自动完成动作或改变状态，而
ACE主动对象模式
weixin_33958366的博客
05-04 83
主动对象模式用于降低方法执行和方法调用之间的耦合。该模式描述了另外一种更为透明的任务间通信方法。 传统上，所有的对象都是被动的代码段，对象中的代码是在对它发出方法调用的线程中执行的，当方法被调用时，调用线程将阻塞，直至调用结束。而主动对象却不一样。这些对象具有自己的命令执行线程，主动对象的方法将在自己的执行线程中执行，不会阻塞调用方法。 例如，设想对象"A"已在你的程序的main()函数中...
java观察者模式.doc
最新发布
09-19
观察者模式是软件设计模式中的一种行为模式，用于在对象之间建立一种一对多的依赖关系，使得每当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。在Java中，观察者模式通常通过`java.util....
设计模式课程作业.zip
03-28
用类图说明系统的静态设计视图，包含主动类的类图——专注于系统的静态进程视图。系统可有多个类图，单个类图仅表达了系统的一个方面。要在高层给出类的主要职责，在低层给出类的属性和操作。 　对象图：对象图展示...
面向对象编程依赖注入详解
09-01
依赖查找也是IoC的一种体现，但对象是主动去查找和获取依赖，而非被动接收。这通常涉及配置文件和框架提供的API，对象在需要依赖时通过指定的标识或路径获取依赖。 总结来说，依赖注入是提高软件可维护性和可扩展性...
ACE框架主动对象的实现及代码示例
09-18
主动对象是相对于被动对象而言的，通常传统的方法调用都是由单一线程顺序完成对象内部的方法调用。因为对象内部的方法是由主线程被动调用的所以称之为被动对象1)。主动对象的方法调用表面上和普通的方法调用没有很大的区别，可是在对象的内部其工作方式是不一样的。主线程并不会进入到方法内部执行其代码而是生成一个命令请求放入主动对象的内部队列，主线程会立即返回，而主动对象内部会由其内部线程去主动执行方法请求队列内的方法。方法执行完毕内部线程会把执行结果放入一个结果集数据结构等待主线程取回方法执行的结果。
主动对象（active object）<one>
didun5362的博客
11-06 703
1. 什么是主动对象？ 　参见《上篇：ACE技术论文集》第6章　和《ACE 程序员指南》第15章　归纳如下： 　　Active object（主动对象）模式是一种专门设计的模式，该模式使方法执行与方法调用去耦合，以简化对驻留在它自己的线程控制中的对象的同步访问。该模式以这样的需求为基础：两个主动对象应该能通过看起来像是常规方法调用的方法进行通信，但这些方法将在接受者的上下文、...
ACE-Task主动对象
zhoutong12589的专栏
10-27 501
ACE中有一个独特的对象叫做主动对象，在ACE的官方文档中描述为：ACE_Task是ACE中的任务或主动对象处理结构的基类，在ACE中使用此结构来实现主动对象模式，所有希望成为主动对象的对象都必须从此类派生。 主动对象可以理解为在类的内部实现了线程，我们需要做的就是为线程创建相应的环境，实现线程的操作，然后开启线程。 要创建主动对象必须继承ACE_Task类，并实现下列方法： 1、初始化和终
主动对象模式（Active Object）
huzhiqiangCSDN的博客
02-21 1586
七、主动对象模式（Active Object） 1、核心思想 一种异步编程思想，允许任务的提交（相当于对异步方法的调用）和任务的执行（相当于异步方法的真正执行）分离，实现了异步编程。 有利于提高并发性，从而提高系统的吞吐率 2、适用场景 适合分解一个比较耗时的任务（如I/O任务）已减少主线程的等待时间。 3、可复用代码 ActiveObjectProxy
主动对象（Active Object）：用于并发编程的对象行为模式
09-13 3998
最近在看 > 和 ACE 的源码，如果要深入理解 ACE，最好能结合 POSA2 >，但是此书中文版的翻译不佳，幸运的是，POSA2的大部分内容可以在 C++NP2 的翻译者马维达先生另一个翻译的技术文档 > 找到。本贴转自http://docs.huihoo.com/ace_tao/ACE-2002-12/Part-One/Chapter-6.htm主动对象（Active Object）：用于并
java主动对象模式_ACE主动对象模式(1)
weixin_42310231的博客
02-25 179
主动对象模式用于降低方法执行和方法调用之间的耦合。该模式描述了另外一种更为透明的任务间通信方法。传统上，所有的对象都是被动的代码段，对象中的代码是在对它发出方法调用的线程中执行的，当方法被调用时，调用线程将阻塞，直至调用结束。而主动对象却不一样。这些对象具有自己的命令执行线程，主动对象的方法将在自己的执行线程中执行，不会阻塞调用方法。例如，设想对象"A"已在你的程序的main()函数中被实例化。当...
设计模式（九）主动对象模式
胜利者的经验并不复杂,那就是寻找人生的关键点,并在关键时刻竭尽全力
02-12 2171
1. 用到了command与proxy模式，变成了一个更强大的模式。 2. 一般的command模式是当有请求到来的时候，在主线程中（也可以是其他线程，主线程这里只表示上下文）生成一个command，然后push到命令池（并不是所有的都有命令池的，这也是主动对象不同的地方，主动对象都有单独线程，不是在当前上下文中执行），在命令池线程中执行execute方法，或者在主线程中直接调用exec
qt ftp设置主动连接模式
08-27
在Qt中设置FTP连接模式可以通过 QNetworkConfiguration 类的 setPreferredNetworkConfiguration 方法来实现。在Qt中，可以设置FTP连接的两种模式，主动连接模式和被动连接模式。 主动连接模式是FTP服务器主动连接客户端，这种模式下，客户端在建立FTP数据连接之前会向服务器发送一个PORT命令，指定数据连接的IP地址和端口号。在Qt中，可以通过 QNetworkProxy 类的 setProxy 方法设置FTP连接的代理，然后将代理设置给QNetworkAccessManager类，使用setProxy方法来设置代理的IP地址和端口号。 以下是使用Qt设置FTP主动连接模式的示例代码： ```cpp #include <QNetworkAccessManager> #include <QNetworkConfiguration> #include <QNetworkProxy> int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); // 创建网络管理器 QNetworkAccessManager manager; // 设置FTP连接模式为主动连接 QNetworkConfiguration config = manager.configuration(); config.setActiveFtpConfiguration(QNetworkConfiguration::ActiveFtp); manager.setConfiguration(config); // 设置FTP连接代理 QNetworkProxy proxy; proxy.setType(QNetworkProxy::FtpCachingProxy); proxy.setHostName("127.0.0.1"); // 设置代理的IP地址 proxy.setPort(21); // 设置代理的端口号 manager.setProxy(proxy); // 其他FTP的操作 return a.exec(); } ``` 上述代码创建了一个包含FTP连接的Qt应用程序。首先创建了一个QNetworkAccessManager对象，然后使用setActiveFtpConfiguration方法将FTP连接模式设置为主动连接。接下来创建了一个QNetworkProxy对象，通过setType方法设置代理类型为FtpCachingProxy，并通过setHostName和setPort方法设置代理的IP地址和端口号。最后使用setProxy方法将代理设置给QNetworkAccessManager类。 使用上述代码，在Qt中可以设置FTP连接的主动连接模式，并指定代理的IP地址和端口号来进行FTP操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值