单例模式(java/python/c++)

序

最近接触到新项目，后端基于java开发。对于有c++/python开发经验，无java经验的小梅同学，开始了漫漫学习之旅，第一篇学习记录，从最简单的单例模式开始吧。

众所周知，单例模式的最明显的几个特点：

1. 一个进程存在唯一一个实例

2. 不能被用户创建

3. 有一个获取实例的接口

单例模式常用在日志，全局变量等整个进程只需要唯一实例的应用中。

开启java之旅

Step1:new->Package 命名为singleton

Step2:在singleton包下，new->Java Class，命名为Singleton。Singleton.java实现如下：

package singleton;
public class Singleton
{    
    // 定义一个私有静态的句柄    
    private static Singleton instance = null;    
    // 构造函数私有化:保证1，2
    private Singleton(){}    
    // 公有静态获取句柄函数：保证3  
    public static Singleton getInstance()    
    {       
        if(instance == null)        
        {            
            instance = new Singleton();        
        }        
        return instance;    
    }
    // 其他普通函数
    public void  testCommFunc()    
    {        
    System.out.println("Common Function Of Singleton Class");    
    }
};

Step3:在singleton包下，new->Java Class，命名为SingletonDemo。SingletonDemo.java实现如下：

package singleton;public class SingletonDemo 
{    
    public static void main(String[] args) 
    {        
        Singleton s = Singleton.getInstance();        
        s.testCommFunc();    
    }
}

Step4: 运行SingletonDemo.java，控制台输出：

Common Function Of Singleton Class

回顾

• Python中单例

最简单的方式：在file1.py定义中定义一个变量var，其他文件导入这个变量，此变量即是全局的。如果此变量为类实例变量，那么此实例即是唯一的。

单例class方式：

# 单例实现
class Singleton(type):
    def __call__(cls, *args, **kwargs):
        if not hasattr(cls, "_instance"):
            # with Singleton.lock: #如果是多线程的话，此处需要加锁
            if not hasattr(cls, "_instance"):
                cls._instance = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instance

# ClassA（比如日志类）继承单例         
class MyLog(metaclass=Singleton):
    def __init__(self):
    super(ClassA, self).__init__()
    self.x = None
    self.y = dict()

a1 = MyLog()
a1.x = 10
a2 = MyLog()
a2.y = [1, 1, 2]

# a1和a2的输出地址应相同
print("addr a1 {}   a2 {}".format(a1, a2))

# a1和a2的x,y值应相同，分别为10， [1, 1, 2]
print("x: a1 {}, a2 {}".format(a1.x, a2.x))
print("y: a1 {}, a2 {}".format(a1.y, a2.y))

• c++中的单例

template<class T>
class TSingleton
{
    public:
    static T* getInstance();

    protected:
    TSingleton(const TSingleton&) {}
    TSingleton&operator=(const TSingleton&) {}
    TSingleton() {}
    virtual ~TSingleton() {}
    static std::shared_ptr<T>&instance()
    {
        // 采用std标准库中的轻量级智能指针实现单件对象管理
        static std::shared_ptr<T> pInstance;

        return pInstance;
    }
};
template<class T>
T*TSingleton<T>::getInstance()
{
    std::shared_ptr<T> &rInstance = instance();
    // Double-checked
    if (NULL == rInstance.get())
    {
        if (NULL == rInstance.get())
        {
            // 不使用instance().reset(new T),防止在编译器优化的情况下
            // 出现先将智能指针赋值，再进行构造
            std::shared_ptr<T> _au(new T);
            rInstance = _au;
        }
    }

    return rInstance.get();
}

代码来源于：https://github.com/Tencent/GameAISDK/tree/master/src/ImgProc/Comm/Utils/TSingleton.h 如有侵权，请告之，将立即删除。

日志类：

class CMyLog : public TSingleton<CMyLog>
{
    ....
}