设计模式之单例模式

定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
单例模式结构图：

static

• 不管该class有没有实例化，static静态块总会在ClassLoader执行完以后，就加载完毕。
• 静态块中的内容，只能访问静态属性和方法。
• 只要是静态方法和属性，直接可以用Class的名字就能点出来。
• JVM内存中的静态区，这一块内容是公共的。

类装载到JVM中的过程：
1、从上往下(必须声明在前，使用在后)
2、先属性、后方法
3、先静态，后动态

第一种：饿汉模式

这种方式在类加载时就完成了初始化，影响到类加载过程速度，但获取该对象的速度会很快。 这种方式基于类加载机制避免了多线程的同步问题，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance显然没有达到懒加载的效果（存在线程安全的问题）。

package com.hejs.singleton;

/**
 * @Author: hejis
 * @Description: 饿汉模式
 * @Date: Create in 22:30 2019/3/10
 * @Modified By:
 */
public class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}

第二种：懒汉模式（线程不安全）

懒汉模式申明一个静态对象，在第一次调用时初始化（静态对象初始化赋值），这样在类加载结束并未真正的实例化对象，因此节约了资源，但第一次加载时需要实例化，反映稍慢一些，另外在多线程不能正常工作。

package com.hejs.singleton;

/**
 * @Author: hejis
 * @Description:
 * @Date: Create in 22:35 2019/3/10
 * @Modified By:
 */
public class Singleton1 {

    private static Singleton1 instance;
    
    private Singleton1 (){
    }

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

}

第三种：懒汉模式（线程安全）

该写法能够在多线程中很好的工作，但是每次调用getInstance方法时都需要进行同步（synchronized ），造成不必要的同步开销，而且大部分时候我们是用不到同步的，所以不建议用这种模式。

package com.hejs.singleton;

/**
 * @Author: hejis
 * @Description:
 * @Date: Create in 22:39 2019/3/10
 * @Modified By:
 */
public class Singleton2 {

    private static Singleton2 instance;

    private Singleton2(){}

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

}

第四种：双重检查模式（DCL）

该写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，不了解volatile关键字的可以查看volatile域。
在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。 DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。DCL虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是他还是在某些情况会出现失效的问题，也就是DCL失效，在《java并发编程实践》一书建议用静态内部类单例模式来替代DCL。

package com.hejs.singleton;

/**
 * @Author: hejis
 * @Description:
 * @Date: Create in 22:42 2019/3/10
 * @Modified By:
 */
public class Singleton3 {

    private static Singleton3 instance;

    private Singleton3(){}

    public static Singleton3 getInstance(){
        if(instance == null){
            synchronized (Singleton3.class) {
                if(instance == null){
                    instance = new Singleton3();
                }
            }
        }
        return instance;
    }

}

第五种：静态内部类单例模式（线程安全）

第一次加载Singleton类时并不会初始化INSTANCE ，只有第一次调用getInstance方法时虚拟机加载LazyHolder 并初始化INSTANCE ，这样不仅能确保线程安全也能保证Singleton类的唯一性，所以推荐使用静态内部类单例模式。

package com.hejs.singleton;

/**
 * @Author: hejis
 * @Description:
 * @Date: Create in 16:50 2019/3/10
 * @Modified By:
 */
// 懒汉式（静态内部类）
// 这种写法，即解决安全问题，又解决了性能问题
public class Singleton4 {
    // 1、先声明一个静态内部类
    // private 私有的保证别人不能修改
    // static 保证全局唯一
    private static class LazyHolder {
        // final 为了防止内存误操作，代理模式，CGLib的代理模式
        private static final Singleton4 INSTANCE = new Singleton4();
    }

    // 2、将默认构造方法私有化
    private Singleton4(){}
    // 不写private，相当于一个默认的public的无参的构造方法，就意味着代码中随时都可以new出来

    // 3、同样提供静态方法提供获取实例
    // final 确保别人不能覆盖
    public static final Singleton4 getInstance(){
        // 方法中的逻辑，是要在用户调用的时候才开始执行的
        // 方法中实现逻辑需要分配内存，也是在调用时分配的
        return LazyHolder.INSTANCE;
    }
}
// 我们所写额所有代码，在java的放射机制面前，都是裸奔的
// 发射机制都可以拿到private修饰的内容的
// 我们可以理解成即使加上private也不靠谱（按正常套路出牌，貌似可以）

第六种：枚举单例

默认枚举实例的创建是线程安全的，并且在任何情况下都是单例。

package com.hejs.singleton;

/**
 * @Author: hejis
 * @Description:
 * @Date: Create in 22:49 2019/3/10
 * @Modified By:
 
public enum Singleton5 {

    INSTANCE;
    
    public void doSomeThing() {
    }

}

上述讲的几种单例模式实现中，有一种情况下他们会重新创建对象，那就是反序列化，将一个单例实例对象写到磁盘再读回来，从而获得了一个实例。反序列化操作提供了readResolve方法，这个方法可以让开发人员控制对象的反序列化。在上述的几个方法示例中如果要杜绝单例对象被反序列化是重新生成对象，就必须加入如下方法：

private Object readResolve() throws ObjectStreamException{
	return singleton;
}

枚举单例的优点就是简单，但是大部分应用开发很少用枚举，可读性并不是很高，不建议用。

第七种：使用容器实现单例模式

用SingletonManager 将多种的单例类统一管理，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

package com.hejs.singleton;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author: hejis
 * @Description:
 * @Date: Create in 22:51 2019/3/10
 * @Modified By:
 */
public class SingletonManager {

    private static Map objectMap = new HashMap();

    private SingletonManager (){}

    public static void register(String key, Object instance){
        if(objectMap.get(key) == null){
            objectMap.put(key, instance);
        }
    }

    public static Object getInstance(String key){
        objectMap.get(key);
    }
}

总结

到这里七中写法都介绍完了，至于选择用哪种形式的单例模式，取决于你的项目本身，是否是有复杂的并发环境，还是需要控制单例对象的资源消耗。