多线程单例模式

             单例模式相信一般的开发人员都很熟悉了。但是在多线程环境下的单例模式你确定你清楚吗？

        首先在研究多线程单例模式之前我们必须先清楚几个基本都的知识点。1.pthread_key_t；这里提一下什么是线程存储：在多线程程序中，所有线程共享程序中的变量。现在有一全局变量，所有线程都可以使用它，改变它的值。而如果每个线程希望能单独拥有它，那么就需要使用线程存储了。表面上看起来这是一个全局变量，所有线程都可以使用它，而它的值在每一个线程中又是单独存储的。这就是线程存储的意义。如何使用线程存储？

1. 创建一个类型为 pthread_key_t 类型的变量。

2. 调用 pthread_key_create() 来创建该变量。该函数有两个参数，第一个参数就是上面声明的 pthread_key_t 变量，第二个参数是一个清理函数，用来在线程释放该线程存储的时候被调用。该函数指针可以设成 NULL ，这样系统将调用默认的清理函数。

3. 当线程中需要存储特殊值的时候，可以调用 pthread_setspcific() 。该函数有两个参数，第一个为前面声明的 pthread_key_t 变量，第二个为 void* 变量，这样你可以存储任何类型的值。

4. 如果需要取出所存储的值，调用 pthread_getspecific() 。该函数的参数为前面提到的 pthread_key_t 变量，该函数返回 void * 类型的值。

下面是前面提到的函数的原型：
int pthread_setspecific(pthread_key_t key, const void *value);
void *pthread_getspecific(pthread_key_t key);
int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));

    其次我们在来弄清楚下一个关键点：__thread关键字，__thread是GCC内置的线程局部存储设施，存取效率可以和全局变量相比。__thread变量每一个线程有一份独立实体，各个线程的值互不干扰。可以用来修饰那些带有全局性且值可能变，但是又不值得用全局

变量保护的变量。

下面是线程单例的具体实现代码：

template <typename T>
class Singleton:public CNoncopyable//继承自不可拷贝的类，使它变得不可拷贝复制，也不执行赋值操作
{
private:
    Singleton()
    {
    }
    ~Singleton()
    {
    }
    static void destructor(void* obj)
    {
      assert(obj == value_);
      typedef char T_must_be_complete_type[sizeof(T) == 0 ? -1 : 1];
      delete value_;
      value_ = 0;
    }

    class Deleter
    {
    public:
        Deleter()
        {
            pthread_key_create(&pKey,&Singleton::destructor);
        }
        ~Deleter()
        {
            pthread_key_delete(pKey);
        }
        void set(T *pNew)
        {
            void *p = pthread_getspecific(pKey);
            T *pValue = static_cast<T *>(p);
            if(!pValue)
            {
                pthread_setspecific(pKey,pNew);
            }
        }
    private:
        pthread_key_t pKey;
    };
public:
    static T &instance(void)
    {
        if(!value_)
        {
            value_ = new T();
            deleter_.set(value_);
        }
        return *value_;
    }
    static T *pointer(void)
    {
        return value_;
    }

private:
    static Deleter deleter_;
    static __thread T *value_;

};
template <typename T> __thread T *Singleton<T>::value_=NULL;
template<typename T>
typename Singleton<T>::Deleter Singleton<T>::deleter_;

    让我们从头来看，如果你想单例化一个类你调用Singleton<Test>::instance()，我们看到当调用instance()时它先new出一个实例然后调用deleter_.set()，那接着我们来看看set()做了什么事，pthread_setspecific(pKey,pNew);哦，原来就是做了线程存储，而deleter_在构造的时候执行了pthread_key_create(&pKey,&Singleton::destructor);申明了线程存储在析构时执行的销毁动作，析构掉Test。原来就是这么简单。