设计模式（四）

单例模式

有些情况下需要保证一个类在系统中只有一个实例，才能保证它的正确性。

//第一个版本，我们将类构造函数设置为私有
class Singleton
{
private:
    Singleton();
    Singleton(const Singleton&);
public:
    static Singleton* GetInstance();
    static Singleton* Instance;
}；

Singleton* Singleton::GetInstance()
{
    if(Instance == NULL){
        return Instance = new Singleton();
    }

    return Instance;
}
/*
当实例为空时，则返回一个新创建的对象；当第二次调用时，返回唯一变量
但是进入多线程环境时，若两个线程同时调用GetInstance()，则有可能两个线程同时创建一个实例
因此为了实现多线程安全版本，需要对类进行改进
1. 可以声明一把锁，对GetInstance()进行加锁
    但在高并发环境下所带来的性能损耗是很大的
2. 可以使用双重检查加锁，在第一次判断Instance是否为空时，对Instance进行加锁
    Instance = new Singleton() 在CPU层应先分配内存，再调用构造器，最后将内存地址交给Instance
    但在实际运行时上面的代码会先调用构造器，再分配内存，最后将内存地址交给Instance
    可能会出现A线程执行new时，B线程进入第一层if，发现Instance不为空，最后B线程返回一个分配了内存但没有
    调用构造器的对象，导致程序崩溃
3. 可以使用静态局部变量，在类第一次加载时，会自动调用构造器，保证单例的唯一性
    
*/

// 1.
Singleton* Singleton::GetInstance()
{
    Lock lock;
    if(Instance == NULL){
        return Instance = new Singleton();
    }

    return Instance;
}

// 2.
Singleton* Singleton::GetInstance()
{
    if(Instance == NULL){
        Lock lock;
        if(Instance == NULL){
            Instance = new Singleton();
        }
    }

    return Instance;
}

// 3.
class
{
private:
    static Singleton* Instance = new Singleton();

    static Singleton* GetInstance()
    {
        return Instance;
    }
};

享元模式

享元模式通过运用共享技术有效地支持大量细粒度的对象。

如果对象已经创建，则返回，否则创建一个新的对象并加入对象池中。

/*
字体处理类
*/
class Font
{
private:
    string Key;

public:
    Font(const string& key)
    {
        //...
    }
};

class FontFactory
{
private:
    map<string, Font*> FontPool;

public:
    Font* GetFont(const string& key)
    {
        //去寻找对象池中是否已经创建过，如果没有则创建一个新的，否则直接返回找到结果
        if(FontPool.find(key) == FontPool.end()){
            FontPool[key] = new Font(key);
        }

        return FontPool[key];
    }
};

• 本文作者： KongXinQing
• 本文链接： https://13114987559.github.io/2023/10/13/note/设计模式4/
• 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！