23种设计模式之（一）单例模式（python_c++实现)

23种设计模式之（一）单例模式（Singleton）

本文主要介绍23种设计模式之单例模式，附详细python/c++示例代码。
- 概念
- 应用场景
- 注意事项
- 代码示例
- 总结
- 代码链接

---

单例模式（Singleton）

概念

单例模式是一种对象创建型模式，使用单例模式，可以保证为一个类只生成唯一的实例对象。也就是说，在整个程序空间中，该类只存在一个实例对象。
GoF对单例模式的定义是：保证一个类、只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。

应用场景

一个无状态的类使用单例模式节省内存资源。为了性能的考虑，需要节省对象的创建时间，全局变量，共享资源，如全局连接池，客户端全局配置项，客户端账号信息等。

注意事项

C++多线程下懒汉式使用线程锁

代码示例

C++代码示例

#include "stdafx.h"
#include <Windows.h>
#include <iostream>

/************************************************************************/
/* 设计模式专题
/*
/* 单例模式
/*
/* Author  : zzl
/*
/* 编程环境: window10 vs2010
/*
/* Date    : 20180912
/************************************************************************/
class  Singelton
{
private:
    Singelton()
    {
        m_SingeltoInstance = NULL;
        printf("构造函数Singelton ... do\n");
    }

public:
    static Singelton *getInstance()
    {
        return m_SingeltoInstance;
    }
    static void Singelton::FreeInstance()
    {
        if (m_SingeltoInstance != NULL)
        {
            delete m_SingeltoInstance;
            m_SingeltoInstance = NULL;

        }
    }


private:
    static Singelton *m_SingeltoInstance;

};
Singelton *Singelton::m_SingeltoInstance = new Singelton; //不管你创建不创建实例，均把实例new出来

//懒汉式考虑多线程
//临界区
CRITICAL_SECTION g_cs;//全局关键代码段对象

class SingletonB
{

private:
    SingletonB()
    {
        printf("Singleton begin\n");    
    }
    SingletonB(const SingletonB &);
    SingletonB& operator = (const SingletonB &);
public:
    static SingletonB *getInstance()
    {
        if(m_SingeltoInstance == NULL)  //double check 
        {   
            EnterCriticalSection(&g_cs);   //只有当pInstance等于null时，才开始使用加锁机制 二次检查
            if(m_SingeltoInstance == NULL)
            {
                m_SingeltoInstance = new SingletonB(); 
            }
            LeaveCriticalSection(&g_cs);
        }
        return m_SingeltoInstance;
    }
    static void SingletonB::FreeInstance()
    {
        if (m_SingeltoInstance != NULL)
        {
            delete m_SingeltoInstance;
            m_SingeltoInstance = NULL;

        }
    }
    static SingletonB *m_SingeltoInstance;

};

SingletonB *SingletonB::m_SingeltoInstance =NULL; 

void main1()
{


    Singelton *pSingelto1 = Singelton::getInstance(); //只有在使用的时候，才去创建对象。
    Singelton *pSingelto2 = Singelton::getInstance();
    if (pSingelto1 != pSingelto2)
    {
        printf("不是同一个对象\n");
    }
    else
    {
        printf("是同一个对象\n");
    }
    Singelton::FreeInstance();

    InitializeCriticalSection(&g_cs);
    SingletonB *pSingelto3 = SingletonB::getInstance(); //只有在使用的时候，才去创建对象。
    SingletonB *pSingelto4 = SingletonB::getInstance();
    if (pSingelto3 != pSingelto4)
    {
        printf("不是同一个对象\n");
    }
    else
    {
        printf("是同一个对象\n");
    }

    SingletonB::FreeInstance();
    DeleteCriticalSection(&g_cs);//删除关键代码段对象

}

python代码示例

# -*- coding: utf-8 -*-
###################################################################
# 设计模式专题
# 
# 单例模式
# 
# Author  : zzl
# 
# 编程环境: window10 python2.7
# 
# Date    : 20180912
##################################################################
import threading
class Singleton(object):
    _instance_lock = threading.Lock()

    def __init__(self):
        pass

    def __new__(cls, *args, **kwargs):
        if not hasattr(Singleton, "_instance"):
            with Singleton._instance_lock:
                if not hasattr(Singleton, "_instance"):
                    Singleton._instance = object.__new__(cls)
        return Singleton._instance


if __name__ == "__main__":

    singleton__instance1 = Singleton()
    singleton__instance2 = Singleton()
    print(singleton__instance1, singleton__instance2)


    def task(args):
        singleton__instance = Singleton()
        print(singleton__instance)


    for i in range(10):
        t = threading.Thread(target=task, args=[i, ])
        t.start()

源码链接

设计模式（一）单例模式示例代码(python–c++)