不一样语言对单例模式的不一样实现

前言

前段时间在用 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