史上最全单例模式写法详解

Singleton

这里，我将直接给出一个Singleton的简单实现，因为我相信你已经有这方面的一些基础了。我们姑且把这个版本叫做1.0版

// version 1.0 public   class   Singleton {      private   static   Singleton singleton =  null ;      private   Singleton() {  }      public   static   Singleton getInstance() {          if   (singleton==  null ) {             singleton=  new   Singleton();         }          return   singleton;     } }

在上面的实例中，我想说明下面几个Singleton的特点：（下面这些东西可能是尽人皆知的，没有什么新鲜的）

1. 私有（private）的构造函数，表明这个类是不可能形成实例了。这主要是怕这个类会有多个实例。
2. 即然这个类是不可能形成实例，那么，我们需要一个静态的方式让其形成实例：getInstance()。注意这个方法是在new自己，因为其可以访问私有的构造函数，所以他是可以保证实例被创建出来的。
3. 在getInstance()中，先做判断是否已形成实例，如果已形成则直接返回，否则创建实例。
4. 所形成的实例保存在自己类中的私有成员中。
5. 我们取实例时，只需要使用Singleton.getInstance()就行了。

当然，如果你觉得知道了上面这些事情后就学成了，那得给你当头棒喝一下了，事情远远没有那么简单。

上面的这个程序存在比较严重的问题，因为是全局性的实例，所以，在多线程情况下，所有的全局共享的东西都会变得非常的危险，这个也一样，在多线程情况下，如果多个线程同时调用getInstance()的话，那么，可能会有多个进程同时通过 (singleton== null)的条件检查，于是，多个实例就创建出来，并且很可能造成内存泄露问题。嗯，熟悉多线程的你一定会说——“我们需要线程互斥或同步”，没错，我们需要这个事情，于是我们的Singleton升级成1.1版，如下所示：

// version 1.1

public   class   Singleton

{

     private   static   Singleton singleton =  null ;

     private   Singleton() {  }

     public   static   Singleton getInstance() {

         if   (singleton==  null ) {

             synchronized   (Singleton. class ) {

                singleton=  new   Singleton();

            }

        }

         return   singleton;

    }

}

嗯，使用了Java的synchronized方法，看起来不错哦。应该没有问题了吧？！错！这还是有问题！为什么呢？前面已经说过，如果有多个线程同时通过(singleton== null)的条件检查（因为他们并行运行），虽然我们的synchronized方法会帮助我们同步所有的线程，让我们并行线程变成串行的一个一个去new，那不还是一样的吗？同样会出现很多实例。嗯，确实如此！看来，还得把那个判断(singleton== null)条件也同步起来。于是，我们的Singleton再次升级成1.2版本，如下所示：

// version 1.2

public   class   Singleton

{

     private   static   Singleton singleton =  null ;

     private   Singleton()  {  }

     public   static   Singleton getInstance()  {

         synchronized   (Singleton. class ) {

             if   (singleton==  null ) {

        singleton=  new   Singleton();

            }

         }

         return   singleton;

    }

}

不错不错，看似很不错了。在多线程下应该没有什么问题了，不是吗？的确是这样的，1.2版的Singleton在多线程下的确没有问题了，因为我们同步了所有的线程。只不过嘛……，什么？！还不行？！是的，还是有点小问题，我们本来只是想让new这个操作并行就可以了，现在，只要是进入getInstance()的线程都得同步啊，注意，创建对象的动作只有一次，后面的动作全是读取那个成员变量，这些读取的动作不需要线程同步啊。这样的作法感觉非常极端啊，为了一个初始化的创建动作，居然让我们达上了所有的读操作，严重影响后续的性能啊！

还得改！嗯，看来，在线程同步前还得加一个(singleton== null)的条件判断，如果对象已经创建了，那么就不需要线程的同步了。OK，下面是1.3版的Singleton。

以下这个是最普遍的版本，比较繁琐，可以通过反射来攻击代码，可以在在类中加一个计数器，创建第二个实例的时候抛出异常

// version 1.3

public   class   Singleton

{

     private   static  volatile  Singleton singleton =  null ;

     private   Singleton()  {    } //设置为私有，保证无法创建实例

     public   static   Singleton getInstance() {

         if   (singleton==  null )  { //第一次判断是否存在这个实例，存在就返回

             synchronized   (Singleton. class ) {

                 if   (singleton==  null )  { //线程同步的过程中，如果没有就创建

                    singleton=  new   Singleton();

                }

            }

        }

         return   singleton;

    }

}

这个反射攻击的代码 (唯一可以防止这种攻击的就是枚举类强化Singleton)

GatewayManager s1 = GatewayManager.getInstance();

Class c1 = Class.forName("com.iov.gatewayengine.framework.engine.GatewayManager");

Constructor[] cons = c1.getDeclaredConstructors();

Constructor cc1 = cons[0];

cc1.setAccessible(true);

GatewayManager s2 = (GatewayManager) cc1.newInstance(null);

System.out.println(s1 + "/" + s2);

System.out.println(s1 == s2);

以上都是繁琐的做法，属于不优雅的代码，但是通用型比较高

以下是EFFICTIVE JAVA 提供的三种方法，相比于上面的优雅且帅气

public class Singleton{

public static final Singleton INTANCE = new Singleton();

private Singleton(){}

..........

第一种：

}

私有构造器只被调用一次，用来实例化公有的静态FINAL域，这种方法无法抵御反射攻击，

第二种：

public class Singleton{

public static final Singleton INTANCE = new Singleton();

private Singleton(){}

public static Singleton getInstance(){

return INSTANCE；

}

..........

}

以上两种方法大致相同，第二种的API更为灵活，可以随时改变该类是否为singleton的想法

但是以上两种方法，在JAVA反序列化的时候则会创建一个新的实例，在我们的例子中，会导致"假冒的Singleton"，所以要在以上两种方法中加上，一个readResolve的方法

public Object readResolve(){

return INSTANCE;

}

最后一种终极大招，

public enum Singleton{

INSTANCE;

...........

}

枚举的方法 和公有域的方法类似，但是更加简洁，提供了无偿的序列化和反序列化的机制，绝对防止多种实例化，即时在面对反射攻击和复杂的序列化问题的时候

关于DLC单例为何要加一个 volatile  关键字，下篇见