单例模式的实现方法
单例模式（Singleton）是一种使用率非常高的设计模式，其主要目的在于保证某一类在运行期间仅被创建一个实例，并为该实例提供了一个全局访问方法。下面分别给出 java 和 python 的实现方式：
java 的 6 种实现方法：
1 懒汉式，线程不安全
public class SingletonModle1 {
private static SingletonModle1 instance;
private SingletonModle1() {
}
public static SingletonModle1 getInstance() {
if (null == instance) {
instance = new SingletonModle1();
}
return instance;
}
}
2 懒汉式，线程安全
public class SingletonModle2 {
private static SingletonModle2 instance;
private SingletonModle2() {
}
public static synchronized SingletonModle2 getInstance() {
if (null == instance) {
instance = new SingletonModle2();
}
return instance;
}
}
3 饿汉式，线程安全
public class SingletonModle3 {
private static SingletonModle3 instance = new SingletonModle3();
private SingletonModle3() {
}
public static synchronized SingletonModle3 getInstance() {
return instance;
}
}
4 双重校验锁
public class SingletonModle4 {
private static volatile SingletonModle4 instance;
private SingletonModle4() {
}
public static SingletonModle4 getInstance() {
if (null == instance) {
synchronized (SingletonModle4.class) {
if (null == instance) {
instance = new SingletonModle4();
}
}
}
return instance;
}
}
5 静态内部类
public class SingletonModle5 {
private static class SingletonModleHolder {
private static final SingletonModle5 instance = new SingletonModle5();
}
private SingletonModle5() {
}
public static final SingletonModle5 getInstance() {
return SingletonModleHolder.instance;
}
}
6 枚举
public enum SingletonModleEnum {
INSTANCE;
int value;
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
}
java 单例验证类
public class SingletonVerify {
public static void main(String[] args) {
verify();
}
public static void verify () {
SingletonModle1 singletonModle11 = SingletonModle1.getInstance();
SingletonModle1 singletonModle12 = SingletonModle1.getInstance();
if (singletonModle11 == singletonModle12) {
System.out.println("SingletonModle1 verify pass");
}
SingletonModle2 singletonModle21 = SingletonModle2.getInstance();
SingletonModle2 singletonModle22 = SingletonModle2.getInstance();
if (singletonModle21 == singletonModle22) {
System.out.println("SingletonModle2 verify pass");
}
SingletonModle3 singletonModle31 = SingletonModle3.getInstance();
SingletonModle3 singletonModle32 = SingletonModle3.getInstance();
if (singletonModle31 == singletonModle32) {
System.out.println("SingletonModle3 verify pass");
}
SingletonModle4 singletonModle41 = SingletonModle4.getInstance();
SingletonModle4 singletonModle42 = SingletonModle4.getInstance();
if (singletonModle41 == singletonModle42) {
System.out.println("SingletonModle4 verify pass");
}
SingletonModle5 singletonModle51 = SingletonModle5.getInstance();
SingletonModle5 singletonModle52 = SingletonModle5.getInstance();
if (singletonModle51 == singletonModle52) {
System.out.println("SingletonModle5 verify pass");
}
SingletonModleEnum singletonModleEnum1 = SingletonModleEnum.INSTANCE;
SingletonModleEnum singletonModleEnum2 = SingletonModleEnum.INSTANCE;
if (singletonModleEnum1 == singletonModleEnum2) {
System.out.println("SingletonModleEnum verify pass");
}
}
}
运行结果如下：
SingletonModle1 verify pass
SingletonModle2 verify pass
SingletonModle3 verify pass
SingletonModle4 verify pass
SingletonModle5 verify pass
SingletonModleEnum verify pass
Process finished with exit code 0
python 的 5 种实现方法：
1 基于模块
class Singleton(object):
"""
Python 的模块就是天然的单例模式
"""
def foo(self):
pass
singleton = Singleton()
2 注解
def Singleton(cls):
_instance = {
}
def _singleton(*args, **kargs):
if cls not in _instance:
_instance[cls] = cls(*args, **kargs)
return _instance[cls]
return _singleton
@Singleton
class SingletonObject(object):
a = 1
def __init__(self, x=0):
self.x = x
3 基于类
import threading
class Singleton(object):
"""
基于类实现
"""
_instance_lock = threading.Lock()
def __init__(self):
pass
@classmethod
def instance(cls, *args, **kwargs):
if not hasattr(Singleton, "_instance"):
with Singleton._instance_lock:
if not hasattr(Singleton, "_instance"):
Singleton._instance = Singleton(*args, **kwargs)
return Singleton._instance
4 基于__new__方法
import threading
class Singleton(object):
"""
基于__new__方法实现
"""
_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
5 基于 metaclass
import threading
class SingletonType(type):
"""
基于 metaclass 方法实现
"""
_instance_lock = threading.Lock()
def __call__(cls, *args, **kwargs):
if not hasattr(cls, "_instance"):
with SingletonType._instance_lock:
if not hasattr(cls, "_instance"):
cls._instance = super(SingletonType, cls).__call__(*args, **kwargs)
return cls._instance
class SingletonObject(metaclass=SingletonType):
def __init__(self, name):
self.name = name
python 单例验证方法
from singleton1 import singleton
from singleton2 import SingletonObject
from singleton3 import Singleton as Singleton3
from singleton4 import Singleton as Singleton4
from singleton5 import SingletonObject as Singleton5
if __name__ == '__main__':
singleton1 = singleton
singleton2 = singleton
if (singleton1 is singleton2):
print('singleton1 verify pass')
singleton1 = SingletonObject(1)
singleton2 = SingletonObject(2)
if (singleton1 is singleton2):
print('singleton2 verify pass')
singleton1 = Singleton3().instance()
singleton2 = Singleton3().instance()
if (singleton1 is singleton2):
print('singleton3 verify pass')
singleton1 = Singleton4()
singleton2 = Singleton4()
if (singleton1 is singleton2):
print('singleton4 verify pass')
singleton1 = Singleton5('1')
singleton2 = Singleton5('2')
if (singleton1 is singleton2):
print('singleton5 verify pass')
运行结果:
singleton1 verify pass
singleton2 verify pass
singleton3 verify pass
singleton4 verify pass
singleton5 verify pass
Process finished with exit code 0