C++——单例模式的DCLP(双重锁)实现以及性能测评

单例模式的描述是: 确保一个类只有一个实例，并提供对该实例的全局访问。

从这段话，我们可以知道，单例模式的最重要特点就是:一个类最多只有一个对象。

对于一个普通类，我么可以生成任意对象，我们为了避免生成太多的类，需要将类的构造函数设为私有。

这样的话，我们为了获取实例，只能借助于类的内部函数，而且必须是static函数(非static函数中均包含一个隐式参数this，由于我们没办法实例化，所以只能通过static函数来获取实例):

class Singleton
{
public:
    static Singleton *getInstance()
    {
        return new Singleton;
    }
private:
    Singleton() { }
};

这样虽然可以生成对象了，但每次都去new，无法保证唯一性，所以我们将对象保存在一个static 指针中:

class Singleton
{
public:
    static Singleton *getInstance()
    {
        if(pInstance_ == NULL) //线程的切换
        {
            ::sleep(1);
            pInstance_ = new Singleton;
        }
            
        return pInstance_;
    }
private:
    Singleton() { }

    static Singleton *pInstance_;
};

Singleton *Singleton::pInstance_ = NULL;

这样我们每次获取对象时，都会检查该指针是否为空。

这样虽然在单线程中可以通过测试，但在多线程中，由于线程的切换，我们生成的对象将不唯一。

所以，我们需要通过加锁来解决这个问题:

class Singleton
{
public:
    static Singleton *getInstance()
    {
        mutex_.lock();
        if(pInstance_ == NULL) //线程的切换
            pInstance_ = new Singleton;
        mutex_.unlock();
        return pInstance_;
    }
private:
    Singleton() { }

    static Singleton *pInstance_;
    static MutexLock mutex_;
};

Singleton *Singleton::pInstance_ = NULL;
MutexLock Singleton::mutex_;

加锁后，虽然解决了这种问题，可是互斥锁会极大的降低系统的并发能力，因为每次调用都要加锁。

测试代码如下:

class TestThread : public Thread
{
public:
    void run()
    {
        const int kCount = 1000 * 1000;
        for(int ix = 0; ix != kCount; ++ix)
        {
            Singleton::getInstance();
        }
    }
};

int64_t getUTime()
{
    struct timeval tv;
    ::memset(&tv, 0, sizeof tv);
    if(gettimeofday(&tv, NULL) == -1)
    {
        perror("gettimeofday");
        exit(EXIT_FAILURE);
    }
    int64_t current = tv.tv_usec;
    current += tv.tv_sec * 1000 * 1000;
    return current;
}

int main(int argc, char const *argv[])
{
    //Singleton s; ERROR

    int64_t startTime = getUTime();

    const int KSize = 100;
    TestThread threads[KSize];
    for(int ix = 0; ix != KSize; ++ix)
    {
        threads[ix].start();
    }

    for(int ix = 0; ix != KSize; ++ix)
    {
        threads[ix].join();
    }

    int64_t endTime = getUTime();

    int64_t diffTime = endTime - startTime;
    cout << "cost : " << diffTime / 1000 << " ms" << endl;

    return 0;
}

测试结果如下:

cost : 7304 ms

我们可以采用双重锁模式来提高性能。

class Singleton
{
public:
    static Singleton *getInstance()
    {
        if(pInstance_ == NULL)
        {
            mutex_.lock();
            if(pInstance_ == NULL) //线程的切换
                pInstance_ = new Singleton;
            mutex_.unlock();
        }

        return pInstance_;
    }
private:
    Singleton() { }

    static Singleton *pInstance_;
    static MutexLock mutex_;
};

Singleton *Singleton::pInstance_ = NULL;
MutexLock Singleton::mutex_;

我们在getInstance中采用了双重检查模式，这样做的优点为:

内部采用互斥锁，代码无论如何是可靠的

new出第一个实例后，后面每个线程访问到最外面的if判断就直接返回了，没有加锁的开销

再次测试，结果为:

cost : 486 ms

这样，就简单的完成了对单例模式的一点性能改进。