单例模式浅析

Posted 2020-08-25 byron_nj

  单例模式 

　　单例模式是一种比较常见的模式，看起来很简单，但是要做到高效安全的使用，其中还是有很多要点的。参考了Head First及众多网友的文章，稍微总结一下，以备查看。

　　单例模式的定义：确保一个类只有一个实例，并且提供一个全局访问点。

1. 最简单的单例（饿汉模式），程序一加载就对 instance 变量进行初始化，好处是简单明了，缺点：如果初始化的耗费的资源特别多，而之后这个类可能未被使用到，就会造成浪费。

public class Singleton{
    // 单例类静态引用
    private static Singleton instance = new Singleton();  
    // 私有构造方法
    private Singleton(){}  
    // 静态方法：全局访问点
    public static Singleton getInstance(){  
        return instance;  
    }  
}  

 

2. 延迟加载（懒汉模式），作为改进，我们可以在使用到的时候才去创建单例类。

public class LazySingleton {

    private static LazySingleton instance = null;

    private LazySingleton() {}

    public static LazySingleton getInstance() {
        // 使用的时候去检测是否已经初始化
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

　　这种方式实现的单例是线程非安全的，假设有线程 A 和 B，同时去获取 LazySingleton 实例，当 A 线程进入 getInstance()，执行到 if (instance == null) 时，此时判断结果为真；之后切换到线程 B 执行，此时也执行到 if (instance == null) ，此时判断结果为真，会对 instance 变量进行初始化；此时切换回线程 A ，根据之前的判断结果，也会对 instance 变量进行初始化，此时就会得到两个不一样的实例，单例失败。

　　为了实现线程安全，只要在 getInstance() 方法上添加 synchronized 关键字即可。

 

3. 双重校验锁

　　加上 synchronized 关键字，实现了线程安全，但又带来了性能问题。通过同步方法会让性能大幅下降。

　　通过代码我们可以看到，instance 变量在整个程序执行期间只会初始化一次，如果只为了这一次初始化，每次获取单例对象都必须在synchronized这里进行排队，实在太损耗性能。为此我们可以如下改进：① instance 变量只会初始化一次，把 synchronized 关键字加载此处；② 为了避免每次获取单例对象都在同步代码上等待，可以在同步代码块外层再加一次 instance == null 判断。

public class DoubleCheckSingleton {

    private static DoubleCheckSingleton instance = null;

    private DoubleCheckSingleton() {}

    public static DoubleCheckSingleton getInstance() {
        // 两层校验才能确保单例
        if (instance == null) {
            synchronized (DoubleCheckSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

 

4. volatile 关键字

 　　Java中的指令重排优化是指在不改变原语义（即保证运行结果不变）的情况下，通过调整指令的执行顺序让程序运行的更快。JVM中并没有规定编译器优化相关的内容，也就是说JVM可以自由的进行指令重排序的优化。这种优化在单线程中是没有任何问题的，但是在多线程中就会出现问题。

　　创建一个变量需要2个步骤：一个是申请一块内存，调用构造方法进行初始化操作；另一个是分配一个指针指向这块内存。这两个操作谁在前谁在后呢？JVM规范并没有规定。那么就存在这么一种情况，JVM是先开辟出一块内存，然后把指针指向这块内存，最后调用构造方法进行初始化。假设线程A开始创建 SingletonClass 的实例，此时线程 B 调用了 getInstance() 方法，首先判断 instance 是否为 null。按照我们上面所说的内存模型，A 已经把 instance 指向了那块内存，只是还没有调用构造方法，因此 B 检测到 instance 不为 null，于是直接把 instance 返回了——问题出现了，尽管instance不为null，但它并没有构造完成，就像一套房子已经给了你钥匙，但你并不能住进去，因为里面还没有收拾。此时，如果B在A将instance构造完成之前就是用了这个实例，程序就会出现错误了！

　　在 JDK1.5 及之后版本赋予了volatile关键字明确用法。volatile的一个语义是禁止指令重排序优化，也就保证了instance变量被赋值的时候对象已经是初始化过的，从而避免了上面说到的问题。所以只需要在 instance 变量前加上 volatile 修饰符即可避免Java指令优化带来的问题。

public class DoubleCheckSingleton {

    private static volatile DoubleCheckSingleton instance = null;

    private DoubleCheckSingleton() {}

    public static DoubleCheckSingleton getInstance() {
        // 两层校验才能确保单例
        if (instance == null) {
            synchronized (DoubleCheckSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

注：volatile 关键字用法

　　① 可见性。可见性指的是在一个线程中对该变量的修改会马上由工作内存（Work Memory）写回主内存（Main Memory），所以会马上反应在其它线程的读取操作中（工作内存是线程独享的，主存是线程共享的）

　　② 禁止指令重排序优化。

 

5. 静态内部类

　　上述 volatile 关键字收到 JDK 版本限制，如下的静态内部类实现方式是确保了延迟加载和线程安全的。

public class StaticInnerSingleton {

    private static class Holder {
        private static StaticInnerSingleton instance = new StaticInnerSingleton();
    }

    private StaticInnerSingleton() {
    }

    public static StaticInnerSingleton getSingleton() {
        return Holder.instance;
    }
}

　　可以把 StaticInnerSingleton 实例放到一个静态内部类中，这样就避免了静态实例在 StaticInnerSingleton 类加载的时候就创建对象，并且由于静态内部类只会被加载一次，而类的构造必须是原子性的，非并发的，所以这种写法也是线程安全的

　　在上述代码中，因为 StaticInnerSingleton 没有 static 修饰的属性，因此并不会被初始化。直到调用 getInstance() 的时候，会首先加载 Holder

类，这个类有一个 static 的 StaticInnerSingleton 实例，因此需要调用 StaticInnerSingleton 的构造方法，然后 getInstance() 将把这个内部类的instance 返回给使用者。由于这个 instance 是 static 的，因此并不会构造多次。 

 

6. 枚举式单例

public enum EnumSingleton {

    INSTANCE;
    
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public String getSomething() {
        return "String";
    }
}

　　使用枚举除了线程安全和防止反射调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。因此，《Effective Java》书中推荐使用的方法。

 

参考：　深入Java单例模式  http://devbean.blog.51cto.com/448512/203501/

　　　　你真的会写单例模式吗--Java实现 http://www.importnew.com/18872.html　

　　　　感谢二位作者文章，本文仅作整理学习，侵删！