单例模式

3.单例模式（Singleton）

在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在；
好处：
1、某些类创建比较频繁，对于一些大型对象，这是一笔很大的开销。
2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统紊乱。
首先，写一个简单的单例类：

public class Singleton{    /*持有私有静态实例，防止被引用，此处赋值null，目的是实现延迟加载*/    private static Singleton instance = null;    /*私有构造方法，防止被实例化*/    private Singleton(){    }    /*静态工程方法，创建实例*/    public static Singleton getInstance(){        if(instance == null)            instance = new Singleton();        return instance;    }    /*如果该对象被用于序列化，可以保证对象在序列化前后保持一致*/    public Object readResolve(){        return instance;    }}   

这个类可以满足基本需求，但是，像这样没有线程安全保护的类，如果我们把它放入多线程环境，肯定就会出现问题，如何解决？首先会想到对getInstance方法加synchronized关键字，如下：

public static synchronized Singleton getInstance() {      if (instance == null)          instance = new Singleton();      return instance;  }  

但是，这样synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用getInstance()，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，所以我们改成下面这样：

public static synchronized Singleton getInstance() {      if (instance == null) {        synchronized (instance){            if(instance == null)                instance = new Singleton();    }    }        return instance;  }  

这样似乎解决了问题，将synchronized关键字加在了内部，就是说调用的时候不需要加锁，只用instance为null，并且创建对象的时候才需要加锁，性能有一定提升；但是看下面这种情况：
在Java指令中，创建对象和赋值操作是分开的，就是说instance = new Singleton();是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说JVM可能会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例，这样可能就出错了我们以A,B两个线程为例：
a>A,B线程同时进入了一个if判断
b>A首先进入synchronized块，由于instance == null，所以他执行instance = new Singleton();
c>由于JVM优化机制，JVM先画出了一些分配给Singleton实例的内存，并赋值给instance（此时JVM并没有初始化这个实例），然后A离开synchronized块
d>B进入synchronized块，由于instance ！= null，所以直接离开
e>此时B打算使用Singleton实例，却发现他并没有被初始化，error
写多线程环境下的程序很复杂，我们要进一步对程序做优化：

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

实际上，单例模式使用内部类来维护单例的实现，JVM内部的机制能够保护当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕，这样就不用担心上面的问题。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能的问题。
- 我们总结一个比较好的单例模式：

public class Singleton{    /* 私有构造方法，防止被实例化 */     private Singleton(){    }    /*此处使用一个内部类来维护单例*/    private static class SingletonFactory(){        private static Singleton instance = new Singleton();    }    /*获取实例*/    public static Singleton getInstance(){        return SingletonFactory.instance;    }    /*如果该对象被用于序列化，可以保证对象在序列化前后保持一致*/    public Object readResolve(){        return instance;    }}

也有人这样实现：因为只需要在创建类的时候进行同步，所以只需要将创建和getInstance()分开，单独为创建加synchronized。

public class SingletonTest {      private static SingletonTest instance = null;      private SingletonTest() {      }      private static synchronized void syncInit() {          if (instance == null) {              instance = new SingletonTest();          }      }      public static SingletonTest getInstance() {          if (instance == null) {              syncInit();          }          return instance;      }  }  

• 补充：采用”影子实例”的办法为单例对象属性同步更新

public class SingletonTest {      private static SingletonTest instance = null;      private Vector properties = null;      public Vector getProperties() {          return properties;      }      private SingletonTest() {      }      private static synchronized void syncInit() {          if (instance == null) {              instance = new SingletonTest();          }      }      public static SingletonTest getInstance() {          if (instance == null) {              syncInit();          }          return instance;      }      public void updateProperties() {          SingletonTest shadow = new SingletonTest();          properties = shadow.getProperties();      }  }  

• 最后单例类实际上只是解决一种问题（对象不能多于一个）的方式，常用而且实现并不简单，需要反复在应用中去尝试使用。