Java设计模式系列 单例模式的8种实现方式

---

一、什么是单例模式？

单例模式：是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。
ServletContext、ServletContextConfig、ApplicationContext、数据库的连接池也都是单例形式。

二、八种写法

1、饿汉式（通过静态常量实现）

public class SingletonObject {

    private final static SingletonObject INSTANCE = new SingletonObject();

    // 私有化构造函数
    private SingletonObject() {
    }

    // 通过此静态方法 拿到实例
    public static SingletonObject getInstance() {
        return INSTANCE;
    }

}

• 优点：这种写法比较简单，在类装载的时候就已经完成了实例化，同时也避免了线程同步问题
• 缺点：在类装载的时候就完成实例化，没有实现懒加载的效果，如果从始至终都没有使用过此单例对象的话，那么会造成内存的浪费

2、饿汉式（通过静态代码块实现）

public class SingletonObject {

    private final static SingletonObject INSTANCE;

    static {
        INSTANCE = new SingletonObject();
    }

    // 私有化构造函数
    private SingletonObject() {
    }

    // 通过此静态方法 拿到实例
    public static SingletonObject getInstance() {
        return INSTANCE;
    }

}

从本质上来讲，同上述静态常量实现类似

3、懒汉式（是线程不安全的）

public class SingletonObject {

    private static SingletonObject instance;

    // 私有化构造函数
    private SingletonObject() {
    }

    // 通过此静态方法 拿到实例
    public static SingletonObject getInstance() {
        if (instance == null) {
            instance = new SingletonObject();
        }
        return instance;
    }

}

使用这种办法的话 能够起到懒加载效果，不会造成内存浪费等问题，但是如果是在多线程的环境下，一个线程通过了 if (instance == null)判断语句块的时候，还未来得及执行，另一个线程也通过了此判断语句，那么会被创建两次实例 也就是instance = new SingletonObject(); 会被执行两次，最终导致单例失效。

4、懒汉式（线程安全，同步方法）

public class SingletonObject {

    private static SingletonObject instance;

    // 私有化构造函数
    private SingletonObject() {
    }

    // 通过此静态方法 拿到实例
    public static synchronized SingletonObject getInstance() {
        if (instance == null) {
            instance = new SingletonObject();
        }
        return instance;
    }

}

解决了上述所出现的线程安全问题，但是synchronized会导致执行的效率降低很多。并且每个线程在想要获得此单例对象的时候，都要进入此同步代码块（其实只需要第一次执行的时候，保证其线程安全即可），因此对方法进行同步效率太低。

5、懒汉式（线程不安全，同步方法）

public class SingletonObject {

    private static SingletonObject instance;

    // 私有化构造函数
    private SingletonObject() {
    }

    // 通过此静态方法 拿到实例
    public static SingletonObject getInstance() {
        if (instance == null) {
            synchronized (SingletonObject.class) {
                instance = new SingletonObject();
            }
        }
        return instance;
    }

}

由第四种改进而来，因为同步方法效率太低，因此改进为同步**instance = new Singleton5();但是这种同步并不能起到线程同步的作用。跟第3种实现方式遇到的情形一致，加入一个线程进入到了if (instance == null)**判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这是便会产生多个实例。

6、双重检查（推荐使用）

public class SingletonObject {

    private volatile static SingletonObject instance;

    // 私有化构造函数
    private SingletonObject() {
    }

    // 通过此静态方法 拿到实例
    public static SingletonObject getInstance() {
        if (instance == null) {
            synchronized (SingletonObject.class) {
                if (instance == null) {
                    instance = new SingletonObject();
                }
            }
        }
        return instance;
    }

}

双重检查 double checked locking，保证线程安全和性能
volatile作用：创建对象这个过程不是原子操作，要防止重排序

7、静态内部类

public class SingletonObject {

    // 私有化构造函数
    private SingletonObject() {
    }
    
    private static class SingletonInstance {
        private final static SingletonObject INSTANCE = new SingletonObject();
    }

    public static SingletonObject getInstance() {
        return SingletonInstance.INSTANCE;
    }

}

静态内部类在SingletonObject装载的时候不会立刻实例化，而是在调用getInstance()方法的时候，才会装载此SingletonInstance静态内部类，完成SingletonObject的单例对象的创建。
且类的静态属性只会在加载类的时候初始化，我们也不需要考虑线程安全的问题

8、枚举

public enum  Singleton8 {
    INSTANCE;

    public void getInstance() {

    }
}

不仅能避免多线程同步问题，并且还是懒加载，还能防止反序列化重新创建新的对象。