ACE中的设计模式

1.         Singleton模式简介

Singleton是GOF圣经中最简单的一个模式了，主要用于创建在系统中具有唯一实例又需要到处使用的类，实现起来非常简单。

#include <iostream>
using namespace std;
class my_singleton

{

public:

    static my_singleton *instance();

    void show_my_life();

protected:

    my_singleton();

private:

    static my_singleton *m_instance;

};

my_singleton *my_singleton::m_instance = NULL
my_singleton *my_singleton::instance()

{
    if (m_instance == NULL)
    {
        m_instance = new my_singleton;
    }
    return m_instance;
}


void my_singleton::show_my_life()
{
cout << "i'm living at " << (void*)this << endl;
}

my_singleton::my_singleton(){}

my_singleton::~my_singleton()
{
    if (m_instance != NULL)
    {
        delete m_instance;
        m_instance = NULL;
    }
}

int main()
{
    my_singleton::instance()->show_my_life();
    return 0;

};

2.         ACE中如何使用Singleton

如上例中，singleton代码非常简单，也很成熟，但是如果在一个系统中有很多地方都需要使用singleton模式，则需要写相当多的类似重复代码，枯燥且低效，如果碰巧使用了ACE，那么使用ACE封装的singleton，则可以更加简单：

class normal_test
{

    friend class ACE_Singleton<normal_test, ACE_Null_Mutex>;

public:
    void show_my_life();

private:
    normal_test();

};

normal_test::normal_test(){}
typedef ACE_Singleton<normal_test, ACE_Null_Mutex> NORMAL_TEST;

void normal_test::show_my_life()

{
    cout << "i'm living at " << (void*)this << endl;
}


int ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{

    my_singleton::instance()->show_my_life();
    NORMAL_TEST::instance()->show_my_life();

   

return 0;

};

如上所示，获得了以下优点：

1.    代码减少了一半还多，变得更加简洁、清晰，

2.    使用了double-check技术，免费的获得了线程安全。

3.    没有使用继承、虚函数，性能、效率不会受影响。

3.         ACE的singleton是如何实现的？

以下代码节选自ACE的源代码，为清晰起见，去除了一些无关的宏开关

a)         以下是ACE_Singleton的定义：

template <class TYPE, class ACE_LOCK>

class ACE_Singleton : public ACE_Cleanup

{

public:

  /// Global access point to the Singleton.

  static TYPE *instance (void);


  /// Cleanup method, used by <ace_cleanup_destroyer> to destroy the

  /// ACE_Singleton.

  virtual void cleanup (void *param = 0);

  /// Dump the state of the object.

  static void dump (void);

protected:

  /// Default constructor.

  ACE_Singleton (void);


  /// Contained instance.

  TYPE instance_;


  /// Pointer to the Singleton (ACE_Cleanup) instance.

  static ACE_Singleton<TYPE, ACE_LOCK> *singleton_;

  /// Get pointer to the Singleton instance.

  static ACE_Singleton<TYPE, ACE_LOCK> *&instance_i (void);

};

b)      看一下instance的实现：

template <class TYPE, class ACE_LOCK> TYPE *

ACE_Singleton<TYPE, ACE_LOCK>::instance (void)

{

  ACE_TRACE ("ACE_Singleton<TYPE, ACE_LOCK>::instance");

  ACE_Singleton<TYPE, ACE_LOCK> *&singleton =

    ACE_Singleton<TYPE, ACE_LOCK>::instance_i ();

  // Perform the Double-Check pattern...

  if (singleton == 0)

    {
          static ACE_LOCK *lock = 0;

          if (ACE_Object_Manager::get_singleton_lock (lock) != 0)

            // Failed to acquire the lock!

            return 0;

          ACE_GUARD_RETURN

(ACE_LOCK, ace_mon, *lock, 0);

          if (singleton == 0)

            {

              ACE_NEW_RETURN (singleton, (ACE_Singleton<TYPE, ACE_LOCK>), 0);


              // Register for destruction with ACE_Object_Manager.

              ACE_Object_Manager::at_exit (singleton);

            }

    }

  return &singleton->instance_;

}

说明：double-check技术主要是解决线程安全问题，避免在初始化时多线程重入，导致instance被实例化两次。

c)      再看一下instance_i的实现：

template <class TYPE, class ACE_LOCK> ACE_Singleton<TYPE, ACE_LOCK> *&

ACE_Singleton<TYPE, ACE_LOCK>::instance_i (void)

{

  static ACE_Singleton<TYPE, ACE_LOCK> *singleton_ = 0;

  return singleton_;

}


4.         题外话：

ACE_Singleton较好的封装了Singleton模式，对于现代应用系统，一般而言会有相当多的地方需要使用Singleton模式，如线程池、内存池、数据连接池等，通过ACE_Singleton类，可以达到简化代码的目的，同时解决GOF圣经中未提的线程安全的问题。后续我会继续就ACE中的使用的设计模式提出来与大家进行探讨、学习。