深刻浅出单实例Singleton设计模式

时间  2020-01-18
标签 深刻 实例 singleton 设计 模式 繁體版
原文   原文链接 
深刻浅出单实例Singleton设计模式
陈皓

前序

单实例Singleton设计模式多是被讨论和使用的最普遍的一个设计模式了，这可能也是面试中问得最多的一个设计模式了。这个设计模式主要目的是想在整个系统中只能出现一个类的实例。这样作固然是有必然的，好比你的软件的全局配置信息，或者是一个Factory，或是一个主控类，等等。你但愿这个类在整个系统中只能出现一个实例。固然，做为一个技术负责人的你，你固然有权利经过使用非技术的手段来达到你的目的。好比：你在团队内部明文规定，“XX类只能有一个全局实例，若是某人使用两次以上，那么该人将被处于2000元的罚款！”（呵呵），你固然有权这么作。可是若是你的设计的是东西是一个类库，或是一个须要提供给用户使用的API，恐怕你的这项规定将会失效。由于，你无权要求别人会那么作。因此，这就是为何，咱们但愿经过使用技术的手段来达成这样一个目的的缘由。
本文会带着你深刻整个Singleton的世界，固然，我会放弃使用C++语言而改用Java语言，由于使用Java这个语言可能更容易让我说明一些事情。


Singleton的教学版本

这里，我将直接给出一个Singleton的简单实现，由于我相信你已经有这方面的一些基础了。咱们姑且把这具版本叫作1.0版
  1. // version 1.0   
  2. public class Singleton   
  3. {   
  4.     private static final Singleton singleton = null;   
  5.   
  6.     private Singleton()   
  7.     {   
  8.     }   
  9.     public static Singleton getInstance()   
  10.     {   
  11.         if (singleton== null)   
  12.         {   
  13.             singleton= new Singleton();   
  14.         }   
  15.         return singleton;   
  16.     }   
  17. }  
在上面的实例中，我想说明下面几个Singleton的特色：（下面这些东西多是尽人皆知的，没有什么新鲜的）
  1. 私有（private）的构造函数，代表这个类是不可能造成实例了。这主要是怕这个类会有多个实例。
  2. 即然这个类是不可能造成实例，那么，咱们须要一个静态的方式让其造成实例：getInstance()。注意这个方法是在new本身，由于其能够访问私有的构造函数，因此他是能够保证明例被建立出来的。
  3. 在getInstance()中，先作判断是否已造成实例，若是已造成则直接返回，不然建立实例。
  4. 所造成的实例保存在本身类中的私有成员中。
  5. 咱们取实例时，只须要使用Singleton.getInstance()就好了。
固然，若是你以为知道了上面这些事情后就学成了，那我给你当头棒喝一下了，事情远远没有那么简单。

Singleton的实际版本

上面的这个程序存在比较严重的问题，由于是全局性的实例，因此，在多线程状况下，全部的全局共享的东西都会变得很是的危险，这个也同样，在多线程状况下，若是多个线程同时调用getInstance()的话，那么，可能会有多个进程同时经过 (singleton== null)的条件检查，因而，多个实例就建立出来，而且极可能形成内存泄露问题。嗯，熟悉多线程的你必定会说——“咱们须要线程互斥或同步”，没错，咱们须要这个事情，因而咱们的Singleton升级成1.1版，以下所示：
  1. // version 1.1   
  2. public class Singleton   
  3. {   
  4.     private static final Singleton singleton = null;   
  5.   
  6.     private Singleton()   
  7.     {   
  8.     }   
  9.     public static Singleton getInstance()   
  10.     {   
  11.         if (singleton== null)   
  12.         {   
  13.             synchronized (Singleton.class) {   
  14.                 singleton= new Singleton();   
  15.             }   
  16.         }   
  17.         return singleton;   
  18.     }   
  19. }  
嗯，使用了Java的synchronized方法，看起来不错哦。应该没有问题了吧？！错！这仍是有问题！为何呢？前面已经说过，若是有多个线程同时经过(singleton== null)的条件检查（由于他们并行运行），虽然咱们的synchronized方法会帮助咱们同步全部的线程，让咱们并行线程变成串行的一个一个去new，那不仍是同样的吗？一样会出现不少实例。嗯，确实如此！看来，还得把那个判断(singleton== null)条件也同步起来。因而，咱们的Singleton再次升级成1.2版本，以下所示：
 
  1. // version 1.2   
  2. public class Singleton   
  3. {   
  4.     private static final Singleton singleton = null;   
  5.   
  6.     private Singleton()   
  7.     {   
  8.     }   
  9.     public static Singleton getInstance()   
  10.     {   
  11.         synchronized (Singleton.class)   
  12.         {   
  13.             if (singleton== null)   
  14.             {   
  15.                 singleton= new Singleton();   
  16.             }   
  17.         }   
  18.         return singleton;   
  19.     }   
  20. }  
不错不错，看似很不错了。在多线程下应该没有什么问题了，不是吗？的确是这样的，1.2版的Singleton在多线程下的确没有问题了，由于咱们同步了全部的线程。只不过嘛……，什么？！还不行？！是的，仍是有点小问题，咱们原本只是想让new这个操做并行就能够了，如今，只要是进入getInstance()的线程都得同步啊，注意，建立对象的动做只有一次，后面的动做全是读取那个成员变量，这些读取的动做不须要线程同步啊。这样的做法感受很是极端啊，为了一个初始化的建立动做，竟然让咱们达上了全部的读操做，严重影响后续的性能啊！
还得改！嗯，看来，在线程同步前还得加一个(singleton== null)的条件判断，若是对象已经建立了，那么就不须要线程的同步了。OK，下面是1.3版的Singleton。
  1. // version 1.3   
  2. public class Singleton   
  3. {   
  4.     private static final Singleton singleton = null;   
  5.   
  6.     private Singleton()   
  7.     {   
  8.     }   
  9.     public static Singleton getInstance()   
  10.     {   
  11.         if (singleton== null)   
  12.         {   
  13.             synchronized (Singleton.class)   
  14.             {   
  15.                 if (singleton== null)   
  16.                 {   
  17.                     singleton= new Singleton();   
  18.                 }   
  19.             }   
  20.         }   
  21.         return singleton;   
  22.     }   
  23. }  
感受代码开始变得有点罗嗦和复杂了，不过，这多是最不错的一个版本了，这个版本又叫“双重检查”Double-Check。下面是说明：
  1. 第一个条件是说，若是实例建立了，那就不须要同步了，直接返回就行了。
  2. 否则，咱们就开始同步线程。
  3. 第二个条件是说，若是被同步的线程中，有一个线程建立了对象，那么别的线程就不用再建立了。
至关不错啊，干得很是漂亮！请你们为咱们的1.3版起立鼓掌！
 

Singleton的其它问题

 
怎么？还有问题？！固然还有，请记住下面这条规则——“ 不管你的代码写得有多好，其只能在特定的范围内工做，超出这个范围就要出Bug了”，这是“陈式第必定理”，呵呵。你能想想还有什么状况会让这个咱们上面的代码出问题吗？
在C++下，我不是很好举例，可是在Java的环境下，嘿嘿，仍是让咱们来看看下面的一些反例和一些别的事情的讨论（ 固然，有些反例可能属于钻牛角尖，可能有点学院派，不过也不排除其实际可能性，就算是提个醒吧）：
其1、Class Loader。不知道你对Java的Class Loader熟悉吗？“类装载器”？！C++可没有这个东西啊。这是Java动态性的核心。顾名思义，类装载器是用来把类(class)装载进JVM的。JVM规范定义了两种类型的类装载器：启动内装载器(bootstrap)和用户自定义装载器(user-defined class loader)。 在一个JVM中可能存在多个ClassLoader，每一个ClassLoader拥有本身的NameSpace。一个ClassLoader只能拥有一个class对象类型的实例，可是不一样的ClassLoader可能拥有相同的class对象实例，这时可能产生致命的问题。如ClassLoaderA，装载了类A的类型实例A1，而ClassLoaderB，也装载了类A的对象实例A2。逻辑上讲A1=A2，可是因为A1和A2来自于不一样的ClassLoader，它们其实是彻底不一样的，若是A中定义了一个静态变量c，则c在不一样的ClassLoader中的值是不一样的。
因而，若是我们的Singleton 1.3版本若是面对着多个Class Loader会怎么样？呵呵，多个实例一样会被多个Class Loader建立出来，固然，这个有点牵强，不过他确实存在。难道咱们还要整出个1.4版吗？但是，咱们怎么可能在个人Singleton类中操做Class Loader啊？是的，你根本不可能。在这种状况下，你能作的只有是——“保证多个Class Loader不会装载同一个Singleton”。
其2、序例化。若是咱们的这个Singleton类是一个关于咱们程序配置信息的类。咱们须要它有序列化的功能，那么，当反序列化的时候，咱们将没法控制别人很少次反序列化。不过，咱们能够利用一下Serializable接口的readResolve()方法，好比：
  1. public class Singleton implements Serializable   
  2. {   
  3.     ......   
  4.     ......   
  5.     protected Object readResolve()   
  6.     {   
  7.         return getInstance();   
  8.     }   
  9. }  
其3、多个Java虚拟机。若是咱们的程序运行在多个Java的虚拟机中。什么？多个虚拟机？这是一种什么样的状况啊。嗯，这种状况是有点极端，不过仍是可能出现，好比EJB或RMI之流的东西。要在这种环境下避免多实例，看来只能经过良好的设计或非技术来解决了。
其四，volatile变量。关于volatile这个关键字所声明的变量能够被看做是一种 “程度较轻的同步synchronized”；与 synchronized 块相比，volatile 变量所需的编码较少，而且运行时开销也较少，可是它所能实现的功能也仅是synchronized的一部分。固然，如前面所述，咱们须要的Singleton只是在建立的时候线程同步，然后面的读取则不须要同步。因此，volatile变量并不能帮助咱们即能解决问题，又有好的性能。并且，这种变量只能在JDK 1.5+版后才能使用。
其5、关于继承。是的，继承于Singleton后的子类也有可能形成多实例的问题。不过，由于咱们早把Singleton的构造函数声明成了私有的，因此也就杜绝了继承这种事情。
其六，关于代码重用。也话咱们的系统中有不少个类须要用到这个模式，若是咱们在每个类都中有这样的代码，那么就显得有点傻了。那么，咱们是否可使用一种方法，把这具模式抽象出去？在C++下这是很容易的，由于有模板和友元，还支持栈上分配内存，因此比较容易一些（程序以下所示），Java下可能比较复杂一些，聪明的你知道怎么作吗？
  1. template<CLASS T> class Singleton   
  2. {   
  3.     public:   
  4.         static T& Instance()   
  5.         {   
  6.             static T theSingleInstance; //假设T有一个protected默认构造函数   
  7.             return theSingleInstance;   
  8.         }   
  9. };   
  10.   
  11. class OnlyOne : public Singleton<ONLYONE>   
  12. {   
  13.     friend class Singleton<ONLYONE>;   
  14.     int example_data;   
  15.   
  16.     public:   
  17.         int GetExampleData() const {return example_data;}   
  18.     protected:   
  19.         OnlyOne(): example_data(42) {}   // 默认构造函数   
  20.         OnlyOne(OnlyOne&) {}   
  21. };   
  22.   
  23. int main( )   
  24. {   
  25.     cout << OnlyOne::Instance().GetExampleData()<< endl;   
  26.     return 0;   
  27. }  
  ( 转载时请注明做者和出处。未经许可，请勿用于商业用途)
（全文完）
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程