设计模式之单例模式

什么是单例模式：单例模式是设计模式中最为普遍的一种设计模式，也是初学者就容易接触到的一种设计模式，它是一种对象的创建模式，用于产生  一个对象的具体实例，顾名思义，所谓单例，就是保证系统中该类仅有一个实例。

单例模式的好处：1.对于频繁使用的对象，可以省去new操作所花费的时间，这个对于一些重量级的对象来说，大大的节约了系统的开销。2.由于new操作的次数减少，所以系统内存的使用频率相应的也会降低，这将会减轻GC的压力。

单例模式的几种形式：

1.饿汉式

public class Singleton{
    //构造函数私有化
    private Singleton(){};
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
}
这个单例的性能非常好，getInstance()方法只是简单的返回instance，并没有任何锁操作，在并行程序中，会有良好的表现，但是同时该方法有一个明显的不足，就是该类的构造函数，也就是说，Singleton的实例在什么时候创建并不受控制，对于静态成员instance来说，它会在类第一次初始化的时候就会被创建，但是这个时候并不一定是getInstance（）方法第一次被调用的时候，假如代码如下：

public class Singleton{
    //包含了一个表示状态的静态成员
    public static int STATUS=1；
    private Singleton(){};
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
}
那么对于上面的代码来说，我们在任何地方引用这个STATUS都会导致instance实例被创建，因为任何对该类方法或者字段的引用，都会导致类的初始化，但是这并不是我们所希望的，简单来说，就是我们想要达到的目的是当我们调用getInstance方法的时候，才会创建这个对象实例。

2.懒汉式
    当我们需要控制instance的创建时间的时候，我们可以采用懒汉式
    public class LazySingleton{
        private LazySingleton(){};
        private static LazySingleton instance = null;
        public static synchronized LazySingleton getInstance(){
            if(instance == null)
                instance = new LazySingleton();
            return instance;
        }
    }
    懒汉式的核心思想是充分利用了延迟加载的侧虐，只有在真正需要的时候才会创建对象，但是这样在并发的情况下，用于加了锁，竞争激烈的场合对性能会造成一定的影响。

3.懒汉式的进化版（双重校验）
    public class Singleton{
         private static Singleton singleton;    
         private Singleton(){}     
         public static Singleton getInstance(){
             if(singleton == null){
                 synchronized(Singleton.class){
                     if(singleton == null)
                         singleton = new Singleton();   
                 }
             }
             return singleton;
         }
 }
     这种情况下，通过双重校验模式，减少了锁的判断次数，从而对性能起到了一定的提升作用。但是这种双重检测机制在JDK1.5之前是有问题的，问题还是出在，由所谓的无序写入造成的。一般来讲，当初始化一个对象的时候，会经历内存分配、初始化、返回对象在堆上的引用等一系列操作，这种方式产生的对象是一个完整的对象，可以正常使用。但是JAVA的无序写入可能会造成顺序的颠倒，即内存分配、返回对象引用、初始化的顺序，这种情况下对应到就是singleton已经不是null，而是指向了堆上的一个对象，但是该对象却还没有完成初始化动作。当后续的线程发现singleton不是null而直接使用的时候，就会出现意料之外的问题。

     之前我对单例模式的了解也就到这种地步，但是最近看了一本书，书中作者对双重校验模式非常厌恶，觉得这是一种非常丑陋复杂的方法，同时推荐了一种新的方法。
 4.结合懒汉式和饿汉式优点的单例模式
     public class StaticSingleton{
         private StaticSingleton(){};
         private static class SingletonHolder{
             private static StaticSingleton instance = new StaticSingleton();
         }
         public static StaticSingleton getInstance(){
             return SingletonHolder.instance;
         }
     }
     这种方式同时拥有懒汉式和饿汉式的优点，首先getInstance()方法中没有锁，在高并发环境下性能优越，其次就是只有在getInstance()方法被第一次调用的时候，实例才会被创建。这种方法巧妙的使用了内部类和类初始化的方式。将SingletonHolder申明为private，这使得不可能在外部访问并且初始化它，而我们只可能在getInstance()内部对SingletonHolder类进行初始化，利用虚拟机的类初始化机制创建单例。

另外推荐《实战Java高并发程序设计》一书，内容写的通俗易懂。本博客大部分内容参考该书。