23种设计模式[1]：单例模式-白红宇

23种设计模式[1]：单例模式

阅读量：4650 次

发布时间：2019-06-09

本文共 6481 字，大约阅读时间需要 21 分钟。

前言： 听说懂设计模式的Developer工资会高很多？最近面试也被问到熟悉设计模式有哪些？于是便有此文。

语言背景：PHP、Java

定义：确保一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

类型：创建类模式

类图：

类图知识点：

1.类图分为三部分，依次是类名、属性、方法

2.以<<开头和以>>结尾的为注释信息

3.修饰符+代表public，-代表private，#代表protected，什么都没有代表包可见。

4.带下划线的属性或方法代表是静态的。

5.对类图中对象的关系不熟悉的朋友可以参考文章：。

单例模式应该是23种设计模式中最简单的一种模式了。

它有以下几个要素(特点)：

私有的构造方法(只能有一个实例)。

指向自己实例的私有静态引用(必须自行创建这个实例)。

以自己实例为返回值的静态的公有的方法(必须给其他对象提供这一实例)。

单例模式根据实例化对象时机的不同分为两种：

一种是饿汉式单例，一种是懒汉式单例。

饿汉式单例在单例类被加载时候，就实例化一个对象交给自己的引用；

而懒汉式在调用取得实例方法的时候才会实例化对象。

PHP版本代码如下：

懒汉模式：

饿汉模式：

在讲为什么要使用单例模式之前，我们先回顾一下以往使用DB的方式。

在以往的PHP4旧版本项目开发中，没使用单例模式前的情况如下：

这种面向过程开发的代码，DB句柄变量完全暴露在外，有被修改的可能。

那么我们这样写：

db.php

index.php

OK,这回没有显式的在上下文中看到DB相关的变量了吧？但还是有被修改的可能。如我们的程序员小A ，他没有查看db.php上下文的情况下：

上面的程序例子，我们了解到面向过程开发哪怕你用函数进行了包装，还是无法杜绝被修改的可能。

自 PHP 5 起完全重写了对象模型以得到更佳性能和更多特性。这是自 PHP 4 以来的最大变化。PHP 5 具有完整的对象模型。

于是从PHP5开始完整的支持OOP概念编程了。我们用面向对象的方式再写一版本。代码如下：


     query('SELECT * FROM user WHERE id=' . $id);                $user = [];        //......        return $user;    }}$users = [];$user_obj = new User();for($i=0;$i<100;$++){    $users[] = $user_obj->getOne();}var_dump($users);

这样写代码没问题没毛病，DB句柄也是局部变量，外部无法访问。

但是问题来了，上面代码进行了100次PDO连数据库，数据库在本地情况下，性能还好说。但一旦跨机房了呢？

应用程序端需要进行100次的建立DB链接，这带来了不必要的通信开销。而且在并发情况下，会有很多客户端保持对DB的链接，但数据库的链接资源是有限的。这种编程方式是不可取的。

所以我们要使用单例模式，把DB链接保存在最少。这样就在程序上下文中能减少不必要的建立DB链接请求。

为什么要使用单例模式？

一个主要应用场合就是应用程序与数据库打交道的场景，在一个应用中会存在大量的数据库操作，针对数据库句柄连接数据库的行为，使用单例模式可以避免大量的new操作。因为每一次new操作都会消耗系统和内存的资源。

于是我们有了下面的单例模式：

Db.php：这是一个单例模式

User.php


     query('SELECT * FROM user WHERE id=' . $id);        $user = [];        //......        return $user;    }}$users = [];$user_obj = new User();for($i=0;$i<100;$++){    $users[] = $user_obj->getOne();}var_dump($users);

现在的代码，就不会进行建立100次DB链接请求了，整个程序上下文就只进行了一个耗时的DB链接。而这就是单例模式的优势。

单例模式的优点：

在内存(程序上下文)中只有一个对象，节省内存空间。

避免频繁的创建销毁对象，可以提高性能。

避免对共享资源的多重占用。

可以全局访问。

适用场景：由于单例模式的以上优点，所以是编程中用的比较多的一种设计模式。

需要频繁实例化然后销毁的对象。

创建对象时耗时过多或者耗资源过多，但又经常用到的对象。

有状态的工具类对象。

频繁访问数据库或文件或其他资源的对象。

以及其他没用过的所有要求只有一个对象的场景。

单例模式注意事项：

只能使用单例类提供的方法得到单例对象，不要使用反射，否则将会实例化一个新对象。（php还需要确认）

不要做断开单例类对象与类中静态引用的危险操作。

多线程使用单例使用共享资源时，注意线程安全问题。(php中没有该顾虑，Java中会有)

总结:

得到一个规律就是，设计模式是解决OOP编程概念衍生出来的一种概念，不是为了解决面向过程的。

换句百度百科说的： (英语 design pattern)是对中反复出现的问题的解决方案。

所以设计模式必然有各种设计原则，延伸阅读。

=============================================完结撒花=============================================

扩展阅读：

写到这就完了吗？不,我们还没有考虑多线程情况下的问题呢！

上面绿字说明，在多线程情况下，单例模式是会有问题的。于是乎为了解决多线程情况下的单例使用共享资源的问题。

Java中有7中模式的单例写法，并不是茴的多种写法那么回事，而是每一种写法都有各自的优势。No B B, Show me code ! 以下是Java代码：

第一种(懒汉，线程不安全)：

public class Singleton {      //静态变量保存全局实例    private static Singleton instance;      //私有构造函数，防止外界实例化对象    private Singleton (){}      //静态方法，单例统一访问入口    public static Singleton getInstance() {          if (instance == null) {              instance = new Singleton();          }          return instance;      }  }

这种模式实现了懒加载，但在多线程情况下，红色部分代码多次执行，这就没有达到采用单例模式的优点：在内存中只有一个对象，节省内存空间。避免频繁的创建对象。

那如何避免多次执行呢？对，Java中提供了synchronized关键字，它就是一把锁，可以修饰在方法上，代码块上。代码如下：

第二种(懒汉，线程安全)：

public class Singleton {          private static Singleton instance;          private Singleton (){}          //获得当前类的类锁    public static synchronized Singleton getInstance() {          if (instance == null) {              instance = new Singleton();          }          return instance;      }  }

这种写法能够在多线程中很好的工作，而且看起来它也具备很好的懒加载效果，但是遗憾的是，效率很低，99%情况下不需要同步。

既然使用到了synchronized关键字来加锁，从而实现线程安全。那么我们知道synchronized是可以给代码块加锁的，我们调整一下上面的代码：

第三种(懒汉，变种，双重校验锁，线程安全)：

public class Singleton {          //注意这里使用volatile关键字的内存屏障，来达到禁止指令重排序优化,使得线程间变量修改可见。    private volatile static Singleton singleton;          private Singleton (){}          public static Singleton getSingleton() {          if (singleton == null) {            //获得当前对象的类锁            synchronized (Singleton.class) {                  if (singleton == null) {                      singleton = new Singleton();                  }            }          }         return singleton;      }}

这个是第二种方式的升级版，俗称双重检查锁定。注意红色部分关键字volatile，延伸阅读( 、 )。

在JDK1.5之后，双重检查锁定才能够正常达到单例效果。关于synchronized锁的区别，请看：

第四种(饿汉，线程安全)：

public class Singleton {          //静态变量保存全局实例,该静态实例在该类的初始化阶段被实例化，    private static Singleton instance = new Singleton();          private Singleton (){}          public static Singleton getInstance() {          return instance;      }  }

这种方式基于Java的 classloder 机制避免了多线程的同步问题，不过，instance在类装载时就实例化了()。

虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到懒加载的效果。

第五种(饿汉，变种，线程安全)：

public class Singleton {          private Singleton instance = null;          static {          instance = new Singleton();      }          private Singleton (){}          public static Singleton getInstance() {          return this.instance;      }}

表面上看起来代码组织形式有差别，其实跟第三种方式差不多，都是在类初始化即实例化instance()。

第六种(懒汉，静态内部类，线程安全)：

public class Singleton {       private Singleton (){}          public static final Singleton getInstance() {          return SingletonHolder.INSTANCE;      }        //内部静态类    //Java机制规定，内部类 LazyHolder只有在getInstance()方法第一次调用的时候才会被加载(实现了延迟加载效果)，    //而且其加载过程是线程安全的(实现线程安全)    private static class SingletonHolder {          private static final Singleton INSTANCE = new Singleton();      }}

这种方式同样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第四种和第五种方式不同的是（很细微的差别）：

第四种和第五种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到懒加载效果），而这种方式是Singleton类被装载了，instance不一定被初始化。

因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。

想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。

这个时候，这种方式相比第四和第五种方式就显得很合理。

第七种(枚举，线程安全)：

class Resource{}public enum Singleton {    INSTANCE;        private Resource instance;        Singleton() {        instance = new Resource();    }        //外部程序直接用 Singleton.INSTANCE.getInstance() 获取单例实例;    public Resource getInstance() {        return instance;    }}

获取资源的方式很简单，只要 Singleton.INSTANCE.getInstance() 即可获得所要实例。扩展阅读，。

枚举模式对比第三种饿汉模式，相同之处就是没有实现懒加载。不同之处就是一个提供的是静态方法，一个是公有方法。单例的实例引用一个是私有静态变量，一个是私有变量。

这种方式是Effective Java作者Josh Bloch 提倡的方式，书中说：单元素的枚举类型已经成为实现Singleton的最佳方法。