losophy

单例模式

发表于 更新于

游戏中用到单例模式的例子很多，几乎适用于系统资源管理类中，如聊天，道具，日志等等。

单例模式（Singleton），保证了全局有且只有一个实例对象，保证自动地初始化该对象，使得程序在任何时候任何地方都可以访问、获取该对象。

通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是让类自身保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。

基本类图

15102221-3340ff6dde434ed0b8f2a0a3340cfa88

实现

这里把构造函数定义为private或protected，可以防止外界利用new创建此类实例。而且GetInstance是一个静态的函数，主要负责创建自己的唯一实例。而且GetInstance是一个静态的函数，主要负责创建自己的唯一实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
//获取某个类的单例
#define GetClassInstance( classname ) static_cast<classname*>( CMySingleton<classname>::GetInstance() )

//单例模板
template <typename T>
class CMySingleton
{
private:
    CMySingleton();

public:
    ~CMySingleton();

public:
    /**
     * 获取全局唯一实例对象。如果还没有创建，创建她。
     */
    static T* GetInstance()
    {        
        if (m_pInstance == NULL)
        {
            m_pInstance= new T();
        }
        return m_pInstance;
    }

    /**
     * 消除全局唯一实例对象。
     */
    static void Destroy()
    {
        if (m_pInstance != NULL)
        {
            delete m_pInstance;
            m_pInstance = NULL;
        }
    } 

private:
    static T* m_pInstance;
};

但有时候，在多线程的程序中，多个线程同时访问Singleton，调用GetInstance()方法，会有可能造成创建多个实例。这时候就要给程序加锁。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
//获取某个类的单例
#define GetClassInstance( classname ) static_cast<classname*>( CMySingleton<classname>::GetInstance() )

//单例模板
template <typename T>
class CMySingleton
{
private:
    CMySingleton()
    {
        pthread_mutex_init(&m_mutex, NULL);
    }

public:
    ~CMySingleton()
    {
        pthread_mutex_destory(&m_mutex);
    }

public:
    /**
     * 获取全局唯一实例对象。如果还没有创建，创建她。
     */
    static T* GetInstance()
    {        
        if (m_pInstance == NULL)
        {
            pthread_mutex_lock(&m_mutex);
            if (m_pInstance == NULL)
            {
                m_pInstance= new T();
            }
            pthread_mutex_unlock(&m_mutex);
        }
        return m_pInstance;
    }

    /**
     * 消除全局唯一实例对象。
     */
    static void Destroy()
    {
        pthread_mutex_lock(&m_mutex);//此处无需双重检测，因为delete null并不会导致bug.
        if (m_pInstance != NULL)
        {
            delete m_pInstance;
            m_pInstance = NULL;
        }
    } 

private:
    static T* m_pInstance;
    pthread_mutex_t m_mutex;
};

这里有个疑惑，为什么在lock后，还需要做一次instance实例是否存在的判断？
当instance为null并且同时有两个纯种调用GetInstance()方法时，它们将都可以通过第一重判断。然后由于lock机制，这两个线程则只有一个进入，另一个在外排队等候，必须要其中的一个进入并出来后，另一个才能进入。而此时如果没有了第二重的判断，则第一个线程创建了实例，而第二个线程还是可以继续再创建新的实例，这就没有达到单例的目的了。

总结

单例模式有以下的特点：

1 单例类只可有一个实例
2 单例类必须自己创建自己这惟一的实例
3 单例类必须给所有其他对象提供这一实例
4 在大并发程序里，可能有多个线程同时访问单例，所以一定要记得加锁

多线程时：
单例模式主要有2中形式，一种是饿汉式，一种是懒汉式。
饿汉式：程序一加载单例模式就已经创建了，也就很饥饿嘛。因为是静态属性进行单例初始化，所以优点是线程是安全的，缺点是无论用户是否使用单例对象都会创建单例对象。

1
2
//静态属性类外初始化
Singleton_Hungry* Singleton_Hungry::singleton = new Singleton_Hungry;

懒汉式：当用户使用单例对象时，才去创建单例对象，所以很懒惰嘛。优点是用户不使用就不会创建对象，缺点是 当遇到多线程是，是线程不安全的，但是我们可以使用加强版的也就是线程安全的懒汉式。（上面用到的是这个）。

A otro perro con ese hueso.

相关文章