Java设计模式之单例模式（Singleton）

Java设计模式

单例模式

Java开发中的23种设计模式详解(转)
在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。主要是有下面的几个好处：
1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

简单的单例类如下：

package Singleton;

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;
    }
}

大家思考一下，如果放到多线程的情况下，我们可以发现instance字各个线程不同步，对导致调用出错。
我们指导加synchronized关键词，可以对对象、方法、类进行加锁。假如我们对getInstance()方法进行加锁。

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

synchronized关键词锁住的是这个对象，因为每次调用getInstance(),都要对对象上锁，但是我们只有在第一次创建对象的时候需要加锁，对象instance一旦创建成功，每次调用getInstance()的时候直接返回已创建的instance对象。

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

当调用的时候是不需要加锁的，只有在instance为null,并创建对象的时候才需要加锁，性能有一定的提升。考虑一个问题：在JVM中，instance = new Singleton()这条语句执行步骤：1，先new一个Singleton()对象，2，在将对象的引用赋值给instance。也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。如下所示：
1、A、B线程同时进入了第一个if判断。
2、A先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
3、由于JVM内部的优化机制，JVM先化出了一些分配给Singleton实例的空白内存，并赋值给了instance成员（注意此时JVM并没有开始初始化这个实例），然后A离开了synchronized块。
4、此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。

上面的使用方法还是会有些问题，那么我们能不能找到一个相对比较好的方法呢
如果我们使用内部类来维护单例的实现，JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕。同时该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低性能问题。

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

通过单例模式的学习告诉我们：
1、单例模式理解起来简单，但是具体实现起来还是有一定的难度。
2、synchronized关键词锁定的是对象，在用的时候，一定要在恰当的时候使用。（注意使用锁的对象和过程，可能有的时候并不是整个对象和整个过程都需要锁）。

---

如果采用类的静态方法实现单例模式的效果，也是可行的，但是与内部类实现有什么差别呢
1、静态类不能够实现接口。
2、单例可以被延迟初始化，静态类一般是在第一次加载就初始化。延迟初始化，是因为有一些类比较庞大，延迟加载有助于提升性能。
3、单例类可以被继承，他的方法可以被覆写。但是静态类内部方法都是static，无法被覆写。
4、单例类比较灵活，毕竟从实现上只是一个普通的Java类，只要满足单例的基本需求，你就可以在里面随心所欲的实现一些其他的功能，但是静态类不行。