ACE vs Boost: Singleton的实现及点评

以前曾经讨论过Singleton的实现，这次在对照ACE和Boost代码的时候，又重新审视了一下二者对Singleton不同的实现。其间的差别也体现了不同的编程哲学：

ACE的实现更加偏重多线程中的安全和效率问题；Boost的实现则偏重于使用语言自身的特性满足Singleton模式的基本需求。

 

o ACE的实现

Douglas C. Schmidt在Double-Checked Locking: An Optimization Pattern for Efficiently Initializing and Accessing Thread-safe Objects一文中对double-check lock（一般译为双检锁）进行了详细的阐述。

ACE的Singleton使用Adapter模式实现对其他类的适配，使之具有全局唯一的实例。由于C++标准并非明确指定全局静态对象的初始化顺序，ACE使用double-check lock保证线程安全，并使之不受全局静态对象初始化顺序的影响，同时也避免了全局静态实现方式的初始化后不使用的开销。

 

如果你能够准确的区分以下三种实现的弊端和隐患，对double-check lock也就有了足够的了解。

// -------------------------------------------
class Singleton
{
public:
    static Singleton *instance (void)
    {
        // Constructor of guard acquires
        // lock_ automatically.
        Guard<Mutex> guard (lock_);
        // Only one thread in the
        // critical section at a time.
        if (instance_ == 0)
            instance_ = new Singleton;
        return instance_;
        // Destructor of guard releases
        // lock_ automatically.
    }
private:
    static Mutex lock_;
    static Singleton *instance_;
};

// ---------------------------------------------
static Singleton *instance (void)
{
    if (instance_ == 0) {
        Guard<Mutex> guard (lock_);
        // Only come here if instance_
        // hasn’t been initialized yet.
        instance_ = new Singleton;
    }
    return instance_;
}

// ---------------------------------------------
class Singleton
{
public:
    static Singleton *instance (void)
    {
        // First check
        if (instance_ == 0)
        {
            // Ensure serialization (guard
            // constructor acquires lock_).
            Guard<Mutex> guard (lock_);
            // Double check.
            if (instance_ == 0)
                instance_ = new Singleton;
        }
        return instance_;
        // guard destructor releases lock_.
    }
private:
    static Mutex lock_;
    static Singleton *instance_;
};

更多详情，见Schmidt的原文[as a resource in my space]和ACE_Singleton实现。

o Boost的实现

Boost的Singleton也是线程安全的，而且没有使用锁机制。当然，Boost的Singleton有以下限制（遵从这些限制，可以提高效率）：

o The classes below support usage of singletons, including use in program startup/shutdown code, AS LONG AS there is only one thread running before main() begins, and only one thread running after main() exits.

o This class is also limited in that it can only provide singleton usage for classes with default constructors.

// T must be: no-throw default constructible and no-throw destructible
template <typename T>
struct singleton_default
{
private:
    struct object_creator
    {
        // This constructor does nothing more than ensure that instance()
        //  is called before main() begins, thus creating the static
        //  T object before multithreading race issues can come up.
        object_creator() { singleton_default<T>::instance(); }
        inline void do_nothing() const { }
    };
    static object_creator create_object;

    singleton_default();

public:
    typedef T object_type;

    // If, at any point (in user code), singleton_default<T>::instance()
    //  is called, then the following function is instantiated.
    static object_type & instance()
    {
        // This is the object that we return a reference to.
        // It is guaranteed to be created before main() begins because of
        //  the next line.
      static object_type obj;

      // The following line does nothing else than force the instantiation
      //  of singleton_default<T>::create_object, whose constructor is
      //  called before main() begins.
      create_object.do_nothing();

      return obj;
    }
};
template <typename T>
typename singleton_default<T>::object_creator  // type of create_object is typenamed.
singleton_default<T>::create_object;     // c++ spec: initialization of static field of the singleton_default.

对于多数Singleton使用，Boost提供的版本完全能够满足需求。为了效率，我们有必要对其使用作出一定的限制。

 

 

而在多线程编程中，则有必要使用double-check lock降低频繁加锁带来的开销。

Additional---boost 的完整代码:

// Copyright (C) 2000 Stephen Cleary ([e-mail])//// This file can be redistributed and/or modified under the terms found//  in "copyright.html"// This software and its documentation is provided "as is" without express or//  implied warranty, and with no claim as to its suitability for any purpose.//// See http://www.boost.org for updates, documentation, and revision history.#ifndef BOOST_POOL_SINGLETON_HPP#define BOOST_POOL_SINGLETON_HPP// The following code might be put into some Boost.Config header in a later revision#ifdef __BORLANDC__# pragma option push -w-inl#endif//// The following helper classes are placeholders for a generic "singleton"//  class.  The classes below support usage of singletons, including use in//  program startup/shutdown code, AS LONG AS there is only one thread//  running before main() begins, and only one thread running after main()//  exits.//// This class is also limited in that it can only provide singleton usage for//  classes with default constructors.//// The design of this class is somewhat twisted, but can be followed by the//  calling inheritance.  Let us assume that there is some user code that//  calls "singleton_default<T>::instance()".  The following (convoluted)//  sequence ensures that the same function will be called before main()://    instance() contains a call to create_object.do_nothing()//    Thus, object_creator is implicitly instantiated, and create_object//      must exist.//    Since create_object is a static member, its constructor must be//      called before main().//    The constructor contains a call to instance(), thus ensuring that//      instance() will be called before main().//    The first time instance() is called (i.e., before main()) is the//      latest point in program execution where the object of type T//      can be created.//    Thus, any call to instance() will auto-magically result in a call to//      instance() before main(), unless already present.//  Furthermore, since the instance() function contains the object, instead//  of the singleton_default class containing a static instance of the//  object, that object is guaranteed to be constructed (at the latest) in//  the first call to instance().  This permits calls to instance() from//  static code, even if that code is called before the file-scope objects//  in this file have been initialized.namespace boost {namespace details {namespace pool {// T must be: no-throw default constructible and no-throw destructibletemplate <typename T>struct singleton_default{  private:    struct object_creator    {      // This constructor does nothing more than ensure that instance()      //  is called before main() begins, thus creating the static      //  T object before multithreading race issues can come up.      object_creator() { singleton_default::instance(); }      inline void do_nothing() const { }    };    static object_creator create_object;    singleton_default();  public:    typedef T object_type;    // If, at any point (in user code), singleton_default<T>::instance()    //  is called, then the following function is instantiated.    static object_type & instance()    {      // This is the object that we return a reference to.      // It is guaranteed to be created before main() begins because of      //  the next line.      static object_type obj;      // The following line does nothing else than force the instantiation      //  of singleton_default<T>::create_object, whose constructor is      //  called before main() begins.      create_object.do_nothing();      return obj;    }};template <typename T>typename singleton_default<T>::object_creatorsingleton_default<T>::create_object;} // namespace pool} // namespace details} // namespace boost// The following code might be put into some Boost.Config header in a later revision#ifdef __BORLANDC__# pragma option pop#endif#endif

 

@点评

Boost的singleton twisted code! disadvantage: lazy initialization or lazy load absence.