点击下载
本文文档

当前位置：首页 - 科技 - 知识百科 - 正文

单例模式中不同语言的不同实现

来源：懂视网责编：小采时间：2020-11-02 18:02:18

单例模式中不同语言的不同实现

单例模式中不同语言的不同实现:今天python视频教程栏目介绍单例模式中不同语言的不同实现。前言前段时间在用 Python 实现业务的时候发现一个坑，准确的来说是对于 Python 门外汉容易踩的坑；大概代码如下：class Mom(object): name = '' sons = []if __na

推荐度：

点击下载本文 文档为doc格式

导读单例模式中不同语言的不同实现:今天python视频教程栏目介绍单例模式中不同语言的不同实现。前言前段时间在用 Python 实现业务的时候发现一个坑，准确的来说是对于 Python 门外汉容易踩的坑；大概代码如下：class Mom(object): name = '' sons = []if __na

今天python视频教程栏目介绍单例模式中不同语言的不同实现。

前言

前段时间在用 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 *MySQLDriverfunc 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.Mutexfunc 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.Oncefunc GetDriver() *MySQLDriver {
 once.Do(func() { if mySQLDriver == nil {
 fmt.Println("create instance......")
 mySQLDriver = &MySQLDriver{}
 }
 }) return mySQLDriver
}复制代码

本质上我们只需要不管在什么情况下 MySQLDriver 实例只初始化一次就能达到单例的目的，所以利用 once.Do() 就能让代码只执行一次。