设计模式之单例模式

        单例模式就是采取一定方法保证整个的软件系统中，对于某个类只能存在一个对象实例，并且该类只能提供一个取得该对象实例的方法（静态方法）。

单例模式主要有下面几种实现方式：

1）饿汉式

2）懒汉式（同步，双重检查，以及静态内部类）

3）枚举

1. 饿汉式（采用静态常量）

package com.singleton.type1;

public class singletonTest01 {
    public static void main(String[] args){
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);

    }

}
class Singleton{
    //构造器私有化
    private Singleton(){}
    //定义一个静态对象
    private static Singleton instance = new Singleton();
    public static Singleton getInstance(){
        return instance;
    }
}

上面这个饿汉式的单例模式，使得构造器私有化，且在类装载的时候就完成了实例化，避免了线程同步的问题。但是作为饿汉式，在装载的时候就完成实例化，没有达到“懒加载”的效果，也就是说如果从始至终没有用过这个实例则会造成内存浪费。也就说说，此模式可以用但是可能造成内存浪费。

饿汉式（静态代码块）

package com.singleton.type1;

public class singletonTest01 {
    public static void main(String[] args){
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);

    }

}
class Singleton{
    //构造器私有化
    private Singleton(){}
    //定义一个静态对象
    private static Singleton instance;
    //定义一个静态代码块
    static{
        instance = new Singleton();
    }
    public static Singleton getInstance(){
        return instance;
    }
}

上面这种静态代码块的形式，同静态变量的形式相同。也是在类加载的时候完成了实例化。所以同静态变量的方法，也可能造成内存浪费。

2. 懒汉式：

package com.singleton.type3;

public class singletonTets03 {
    public static void main(String[] args){
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);

    }
}

class Singleton{
    private Singleton(){}
    private static Singleton instance;
    //懒汉式在下面需要加synchronize关键字保证线程安全
    public static synchronized Singleton getInstance(){
        if(instance == null) instance = new Singleton();
        return instance;
    }
}

首先懒汉式解决了线程安全的问题，但是也出现了问题：效率过低。因为本身getInstance如果频繁调用的话，会造成大量的函数同步浪费时间。同步效率太低，在实际开发中不太推荐。

那么有什么改进呢？就是使用双重检查的方式（推荐使用）：

package com.singleton.type3;

public class singletonTets03 {
    public static void main(String[] args){
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);

    }
}

class Singleton{
    private Singleton(){}
    private static Singleton instance;
    //懒汉式在下面需要加synchronize关键字保证线程安全
    public static synchronized Singleton getInstance(){
        if(instance == null){
            /*即使有两个线程同时进入这个if，那么在同步代码块保证了只能有一个线程进行实例化instance，
            另一个线程因为之后再进入代码块则会判断instance!=null从而保证同步*/
            synchronized (Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
            /*这么写是错误的无法保证只有一个instacne,这也是双重检查的精髓
            * synchronized (Singleton.class){
                instance = new Singleton();
            }*/
        }
        return instance;
    }
}

假设有两个线程同时进入第一个if，那么及时他们同时进入，同步代码块也可以保证只有一个线程进入同步代码块的空间，然后实例化；而第二个进入的线程则判断第二个if不为空退出了。之后第三个第四个线程也就连第一个if判断都进不去，从而提升了效率，不用每一个判断都需要同步加锁。这个方法是推荐使用的。

懒汉式（静态内部类，推荐）

对于静态内部类，不会随着外部类的加载而被加载，所以说符合懒汉式懒加载的特点。当调用getInstance时候jvm会加载静态内部类，并且保证静态内部类的加载是线程安全的，也就是保证了有且只有一个静态内部类被加载。从而返回一个对象。

package com.singleton.type3;

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader;

public class singletonTets03 {
    public static void main(String[] args){
        Singleton instance = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance == instance2);

    }
}

class Singleton{
    private Singleton(){}
    private static class SingletonInstance{
        private static final Singleton Instance = new Singleton();
    }
    public static Singleton getInstance(){
        return SingletonInstance.Instance;
    }
}

3. 枚举（推荐）

package com.singleton.type3;

import com.sun.xml.internal.bind.v2.runtime.unmarshaller.XsiNilLoader;

public class singletonTets03 {
    public static void main(String[] args){
        Singleton instance = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance == instance2);

    }
}
//枚举类里面每个属性的类型都是枚举类型，因此每个属性都是一个单例
enum Singleton{
    INSTANCE;
}

借助枚举类型来实现单例模式，可以防止多线程同步问题的出现，并且比较简单，推荐使用。

综上，懒汉式中的双重检查，静态内部类以及枚举都是实现单例模式的好方法。