共计 4112 个字符，预计需要花费 11 分钟才能阅读完成。
前言
前段时间在用 Python 实现业务的时候发现一个坑，精确的来说是对于 Python 门外汉容易踩的坑；
大略代码如下：
class Mom(object):
name = ''
sons = []
if __name__ == '__main__':
m1 = Mom()
m1.name = 'm1'
m1.sons.append(['s1', 's2'])
print '{} sons={}'.format(m1.name, m1.sons)
m2 = Mom()
m2.name = 'm2'
m2.sons.append(['s3', 's4'])
print '{} sons={}'.format(m2.name, m2.sons) 首先定义了一个 Mom 的类，它蕴含了一个字符串类型的 name 与列表类型的 sons 属性；
在应用时首先创立了该类的一个实例 m1 并往 sons 中写入一个列表数据；紧接着又创立了一个实例 m2，也往 sons 中写入了另一个列表数据。
如果是一个 Javaer 很少写 Python 看到这样的代码首先想到的输入应该是：
m1 sons=[['s1', 's2']]
m2 sons=[['s3', 's4']]但其实最终的输入后果是：
m1 sons=[['s1', 's2']]
m2 sons=[['s1', 's2'], ['s3', 's4']]如果想要达到期望值须要略微批改一下：
class Mom(object):
name = ''
def __init__(self):
self.sons = [] 只须要批改类的定义就能够了，我置信即便没有 Python 相干教训比照这两个代码应该也能猜到起因：
在 Python 中如果须要将变量作为实例变量（也就是每个咱们冀望的输入）时，须要将变量定义到构造函数中，通过 self 拜访。
如果只放在类中，和 Java 中的 static 动态变量成果相似；这些数据由类共享，也就能解释为什么会呈现第一种状况，因为其中的 sons 是由 Mom 类共享，所以每次都会累加。
Python 单例
既然 Python 能够通过类变量达到变量在同一个类中共享的成果，那是否能够实现单例模式呢？
能够利用 Python 的 metaclass 的个性，动静的管制类的创立。
class Singleton(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
return cls._instances[cls] 首先创立一个 Singleton 的基类，而后咱们在咱们须要实现单例的类中将其作为 metaclass
class MySQLDriver:
__metaclass__ = Singleton
def __init__(self):
print 'MySQLDriver init.....' 这样 Singleton 就能够管制 MySQLDriver 这个类的创立了；其实在 Singleton 中的 __call__ 能够很容易了解这个单例创立的过程：
- 定义一个公有的类属性
_instances的字典（也就是Java中的map）能够做到在整个类中共享，无论创立多少个实例。 - 当咱们自定义类应用了
__metaclass__ = Singleton后，便能够管制自定义类的创立了；如果曾经创立了实例，那就间接从_instances取出对象返回，不然就创立一个实例并写回到_instances，有点Spring容器的感觉。
if __name__ == '__main__':
m1 = MySQLDriver()
m2 = MySQLDriver()
m3 = MySQLDriver()
m4 = MySQLDriver()
print m1
print m2
print m3
print m4
MySQLDriver init.....
<__main__.MySQLDriver object at 0x10d848790>
<__main__.MySQLDriver object at 0x10d848790>
<__main__.MySQLDriver object at 0x10d848790>
<__main__.MySQLDriver object at 0x10d848790>最初咱们通过试验后果能够看到单例创立胜利。
Go 单例
因为最近团队中有局部业务开始在用 go，所以也想看看在 go 中如何实现单例。
type MySQLDriver struct {username string} 在这样一个简略的构造体（能够简略了解为 Java 中的 class）中是没法相似于 Python 和 Java 一样能够申明类共享变量的；go 语言中不存在 static 的概念。
但咱们能够在包中申明一个全局变量来达到同样的成果：
import "fmt"
type MySQLDriver struct {username string}
var mySQLDriver *MySQLDriver
func GetDriver() *MySQLDriver {
if mySQLDriver == nil {mySQLDriver = &MySQLDriver{}
}
return mySQLDriver
}这样在应用时：
func main() {driver := GetDriver()
driver.username = "cj"
fmt.Println(driver.username)
driver2 := GetDriver()
fmt.Println(driver2.username)
} 就不须要间接结构 MySQLDriver，而是通过 GetDriver() 函数来获取，通过 debug 也能看到 driver 和 driver1 援用的是同一个内存地址。
这样的实现惯例状况是没有什么问题的，机智的敌人肯定能想到和 Java 一样，一旦并发拜访就没那么简略了。
在 go 中，如果有多个 goroutine 同时拜访 GetDriver()，那大概率会创立多个 MySQLDriver 实例。
这里说的没那么简略其实是绝对于 Java 来说的，go 语言中提供了简略的 api 便可实现临界资源的拜访。
var lock sync.Mutex
func GetDriver() *MySQLDriver {lock.Lock()
defer lock.Unlock()
if mySQLDriver == nil {fmt.Println("create instance......")
mySQLDriver = &MySQLDriver{}}
return mySQLDriver
}
func main() {
for i := 0; i < 100; i++ {go GetDriver()
}
time.Sleep(2000 * time.Millisecond)
}稍加革新上文的代码，退出了
lock.Lock()
defer lock.Unlock() 代码就能简略的管制临界资源的拜访，即使咱们开启了 100 个协程并发执行，mySQLDriver 实例也只会被初始化一次。
- 这里的
defer相似于Java中的finally，在办法调用前加上go关键字即可开启一个协程。
虽说能满足并发要求了，但其实这样的实现也不够优雅；认真想想这里
mySQLDriver = &MySQLDriver{}创立实例只会调用一次，但后续的每次调用都须要加锁从而带来了不必要的开销。
这样的场景每个语言都是雷同的，拿 Java 来说是不是常常看到这样的单例实现：
public class Singleton {private Singleton() {}
private volatile static Singleton instance = null;
public static Singleton getInstance() {if (instance == null) {synchronized (Singleton.class){if (instance == null) {instance = new Singleton();
}
}
}
return instance;
}
}这是一个典型的双重查看的单例，这里做了两次查看便能够防止后续其余线程再次拜访锁。
同样的对于 go 来说也相似：
func GetDriver() *MySQLDriver {
if mySQLDriver == nil {lock.Lock()
defer lock.Unlock()
if mySQLDriver == nil {fmt.Println("create instance......")
mySQLDriver = &MySQLDriver{}}
}
return mySQLDriver
} 和 Java 一样，在原有根底上额定做一次判断也能达到同样的成果。
但有没有感觉这样的代码十分繁琐，这一点 go 提供的 api 就十分省事了：
var once sync.Once
func GetDriver() *MySQLDriver {once.Do(func() {
if mySQLDriver == nil {fmt.Println("create instance......")
mySQLDriver = &MySQLDriver{}}
})
return mySQLDriver
} 实质上咱们只须要不论在什么状况下 MySQLDriver 实例只初始化一次就能达到单例的目标，所以利用 once.Do() 就能让代码只执行一次。
查看源码会发现 once.Do() 也是通过锁来实现，只是在加锁之前利用底层的原子操作做了一次校验，从而防止每次都要加锁，性能会更好。
总结
置信大家日常开发中很少会碰到须要本人实现一个单例；首先大部分状况下咱们都不须要单例，即便是须要，框架通常也都有集成。
相似于 go 这样框架较少，须要咱们本人实现时其实也不须要过多思考并发的问题；摸摸本人肚子左上方的地位想想，本人写的这个对象真的同时有几百上千的并发来创立嘛？
不过通过这个比照会发现 go 的语法的确要比 Java 简洁太多，同时轻量级的协程以及简略易用的并发工具反对看起来都要比 Java 优雅许多；后续有机会再接着深刻。
参考链接：
Creating a singleton in Python
How to implement Singleton Pattern in Go
