单例模式详解

特点： 
- 1、 保证从系统启动到系统终止， 全过程只会产生一个实例。 
- 2、 当我们在应用中遇到功能性冲突的时候， 需要使用单例模式。

穷举法： 
- 配置文件： 如果不是单例（针对于某一种功能的配置） 
- Spring Context Factory 上下文

单例模式的七种写法： 
- 懒汉式，需要用的时候才初始化 
- 饿汉式，先实例化 
- 注册登记式，相当于有个容器装在所有的实例，在实例产生之前先检查下容器看有没有，如果有就直接取出来，如果没有就先new一个放进去，然后给后面的人用，Spring IOC容器就是一种典型的注册登记单例。

七种单例模式：

• 懒汉式单例模式

/**
 * 懒汉式单例模式
 * @author DoubleChina
 * @date 2018/1/6 11:51
 */
public class Singleton {
    //1、第一步先将构造方法私有化，在反射面前，没用
    private Singleton(){}
    //2、然后先声明一个静态变量保存单例的引用
    private  static Singleton singleton=null;
    //3、通过提供一个静态方法来获得单例的引用
    public static  Singleton getInstance(){
        if (singleton==null){
            singleton=new Singleton();
        }
        return singleton;
    }
}

• 懒汉式单例模式，保证线程安全

/**
 * 懒汉式单例模式，保证线程安全
 * @author DoubleChina
 * @date 2018/1/6 11:51
 */
public class Singleton1 {
    //1、第一步先将构造方法私有化，在反射面前，没用
    private Singleton1(){}
    //2、然后先声明一个静态变量保存单例的引用
    private  static Singleton1 singleton=null;
    //3、通过提供一个静态方法来获得单例的引用
    //为了保证多行程环境下正确访问，给方法加上同步锁synchronized
    //存在一定的性能问题
    public static synchronized Singleton1 getInstance(){
        if (singleton==null){
            singleton=new Singleton1();
        }
        return singleton;
    }
}

• 懒汉式单例模式，双重锁检查

/**
 * 懒汉式单例模式，双重锁检查
 * @author DoubleChina
 * @date 2018/1/6 11:51
 */
public class Singleton2 {
    //1、第一步先将构造方法私有化，在反射面前，没用
    private Singleton2() {
    }

    //2、然后先声明一个静态变量保存单例的引用
    private static Singleton2 singleton = null;

    //3、通过提供一个静态方法来获得单例的引用
    //为了保证多行程环境下正确访问，给方法加上同步锁synchronized
    //存在一定的性能问题
    public static Singleton2 getInstance() {
        if (singleton == null) {
            synchronized (Singleton2.class) {
                if (singleton == null) {
                    singleton = new Singleton2();
                }
            }
        }
        return singleton;
    }
}

• 最牛B的方式实现单例模式

/**
 * 最牛B的方式实现单例模式
 * @author DoubleChina
 * @date 2018/1/6 11:51
 */
public class Singleton4 {
    //2.声明一个静态内部类
    private static class InnerClass {
        //final是为了防止内部将这个属性覆盖掉
        private static final Singleton4 INSTANCE = new Singleton4();
    }

    //1.先把构造方法私有化
    private Singleton4() {

    }

    //3.提供获取实例方法
    //防止子类重写父类方法
    public static final Singleton4 getInstance() {
        return InnerClass.INSTANCE;
    }
    //内部类的初始化，需要依赖主类
    //也就是说，当我们的JVM加载Singleton4类的时候，我们的InnerClass也同时被加载过来了
    //目前还没有被实例化，需要等主类先实例化之后，内部类才开始实例化
    //加final是为了防止子类重写父类方法
    //
}

• 饿汉式

/**
 * 饿汉式
 * 单例模式，在类初始化，已经有自行的实例化
 * @author DoubleChina
 * @date 2018/1/6 11:51
 */
public class Singleton3 {
    //1、第一步先将构造方法私有化，在反射面前，没用
    private Singleton3() {
    }

    //2、声明变量，在类实例化之前就初始化变量，将对象引用保存
    private static final Singleton3 singleton = new Singleton3();

    //3、开放静态方法，获取实例，但是占用内存空间
    public static Singleton3 getInstance() {
        return singleton;
    }
}

• 枚举式单例模式

/**
 * 枚举式单例模式
 * 不常用
 * @author DoubleChina
 * @date 2018/1/6 11:52
 */
public enum Singleton5 {
    INSTANCE;
    public void getInstance() {

    }
}

• 登记式单例模式

/**
 * 登记式单例模式
 * 类似Spring里面的方法，讲类名注册，下次从里面直接获取
 * @author DoubleChina
 * @date 2018/1/6 11:52
 */
public class Singleton6 {
    private static Map<String ,Singleton6> map=new ConcurrentHashMap<String, Singleton6>();
    static {
        Singleton6 single=new Singleton6();
        map.put(single.getClass().getName(),single);
    }
    //保护默认的构造函数
    protected Singleton6(){}
    public static  Singleton6 getInstance(String  name){
        if (name==null){
            name=Singleton6.class.getName();
        }
        if (map.get(name)==null){
            try {
                map.put(name,(Singleton6)Class.forName(name).newInstance());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return map.get(name);
    }
}