单例模式的两种实现形式,java单例模式和多例模式区别

2022-08-26 05:01:46 分类：python 阅读()

　　单例模式的两种实现形式,java单例模式和多例模式区别

　　00-1010

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

前段时间用Python实现业务的时候发现了一个坑。准确的说，是Python外行人容易踩的坑；

　　大致的代码如下：

　　类妈妈(对象):

　　name=

　　sons=[]if _ _ name _ _== _ _ main _ _ :

　　m1=Mom()

　　m1.name=m1

　　m1.sons.append([s1 ， S2 ])print“{ sons={ }”。格式(m1.name，m1.sons)

　　m2=Mom()

　　m2.name=m2

　　M2.sons.append ([S3 ， S4 ])print“{ sons={ }”。format (m2.name，m2.sons)复制代码首先定义一个Mom类，包含一个字符串类型名称和一个列表类型sons属性；

　　使用时，先创建该类的一个实例m1，将一个列表数据写入sons然后创建另一个实例m2，并将另一个列表数据写入sons。

　　如果是一个很少写Python的Javaer，看到这样的代码首先想到的输出应该是：

　　m1 sons=[ S1 ， s2]]

　　M2父子=[ S3 ， s4]]复制代码但实际上最后输出的结果是：

　　m1 sons=[ S1 ， s2]]

　　M2父子=[ S1 ， S2]，[S3 ， S4]]如果要达到预期值，复制代码需要稍微修改一下：

　　类妈妈(对象):

　　name=

　　def __init__(self):

　　Self.sons=[]复制代码只需要修改类的定义。相信即使没有Python相关经验，对比这两段代码也应该能猜出原因：

　　在Python中，如果需要使用变量作为实例变量(也就是我们期望的每一个输出)，就需要将变量定义到构造函数中，通过self来访问。

　　如果只是放在一个类中，就类似于Java中的静态变量。这些数据是班级共享的，可以解释为什么会出现第一种情况，因为儿子是妈妈班级共享的，所以每次都是累加的。

　　00-1010既然Python可以通过类变量实现变量在同一个类中共享的效果，那么是否可以实现单体模式呢？

　　您可以通过使用Python元类的特性来动态控制类的创建。

　　类Singleton(类型):

　　_instances={} def __call__(cls，*args，**kwargs):

　　如果cls不在cls。_实例：

　　CLS。_ Instances[CLS]=Super(Singleton，CLS)。_ _ Call _ _ (* args，* * kwargs)返回CLS。_ Instances [CLS]复制代码。首先，创建一个singleton的基类，然后我们在需要实现singleton的类中使用它作为元类。

　　>

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() 就能让代码只执行一次。

　　查看源码会发现 once.Do() 也是通过锁来实现，只是在加锁之前利用底层的原子操作做了一次校验，从而避免每次都要加锁，性能会更好。

　　

总结

相信大家日常开发中很少会碰到需要自己实现一个单例；首先大部分情况下我们都不需要单例，即使是需要，框架通常也都有集成。

　　类似于 go 这样框架较少，需要我们自己实现时其实也不需要过多考虑并发的问题；摸摸自己肚子左上方的位置想想，自己写的这个对象真的同时有几百上千的并发来创建嘛？

　　不过通过这个对比会发现 go 的语法确实要比 Java 简洁太多，同时轻量级的协程以及简单易用的并发工具支持看起来都要比 Java 优雅许多；后续有机会再接着深入。

　　

相关免费学习推荐：python视频教程

　　

以上就是单例模式中不同语言的不同实现的详细内容，更多请关注盛行IT软件开发工作室其它相关文章！

　　

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

标签： python

相关文章阅读

  • python命令函数 python函数教学
  • python简单函数编程 如何用python编写函数
  • python随机函数种子 python随机数种子怎么用
  • python画兔子代码，python语言绘制小兔子源代码怎么运行
  • range函数是从0开始吗,python中range(0)
  • python多线程坑,python多线程阻塞
  • python怎么画k线,python绘制k线及均线
  • python调用安卓so库,python .so文件
  • python赋值运算符-=的作用是,在Python中关系运算符中,表示“不等于”
  • python语言是一种脚本编程语言,python属于脚本语言还是编程语言
  • python想获取字符串str的长度,python str转char
  • python从键盘不断输入整数,python控制键盘输入数字
  • python输入姓名输出姓,python输入名字输出你好代码
  • python怎么实现黑客攻击,python网络攻防
  • python@property,python中的property函数
    • 留言与评论（共有 条评论）
       
    验证码：