三、单例模式详解

4.单例模式详解

4.1.课程目标

1、掌握单例模式的应用场景。

2、掌握IDEA环境下的多线程调试方式。

3、掌握保证线程安全的单例模式策略。

4、掌握反射暴力攻击单例解决方案及原理分析。

5、序列化破坏单例的原理及解决方案。

6、掌握常见的单例模式写法。

4.2.内容定位

1、听说过单例模式，但不知道如何应用的人群。

2、单例模式是非常经典的高频面试题，希望通过面试单例彰显技术深度，顺利拿到Offer的人群。

4.3.单例模式的应用场景

单例模式（SingletonPattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛，例如，公司CEO、部门经理 等 。 J2EE 标 准 中 的 ServletContext 、 ServletContextConfig 等 、 Spring 框 架 应 用 中 的ApplicationContext、数据库的连接池BDPool等也都是单例形式。

4.4.饿汉式单例模式

方法1.静态方法获得私有成员对象

/**
 * 优点：执行效率高，性能高，没有任何的锁
 * 缺点：某些情况下，可能会造成内存浪费
 */
public class HungrySingleton {
    //先静态、后动态 
    //先属性、后方法 
    //先上后下
    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton(){}

    public static HungrySingleton getInstance(){
        return  hungrySingleton;
    }
}

方法2.利用静态代码块与类同时加载的特性生成单例对象

//饿汉式静态块单例模式
public class HungryStaticSingleton {
    //先静态后动态
    //先上，后下
    //先属性后方法
    private static final HungryStaticSingleton hungrySingleton;

    //装个B
    static {
        hungrySingleton = new HungryStaticSingleton();
    }

    private HungryStaticSingleton(){}

    public static HungryStaticSingleton getInstance(){
        return  hungrySingleton;
    }
}

类结构图

优缺点

优点：没有加任何锁、执行效率比较高，用户体验比懒汉式单例模式更好。

缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存，有可能“占着茅坑不拉屎”。

源码

Spring中IoC容器ApplicationContext本身就是典型的饿汉式单例模式

4.5.懒汉式单例模式

特点

懒汉式单例模式的特点是：被外部类调用的时候内部类才会加载。

方法1.加大锁

/**
 * 优点：节省了内存,线程安全
 * 缺点：性能低
 */
//懒汉式单例模式在外部需要使用的时候才进行实例化
public class LazySimpleSingletion {
    private static LazySimpleSingletion instance;
    //静态块，公共内存区域 
    private LazySimpleSingletion(){}

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

public class ExectorThread implements Runnable {
    public void run() {
        LazySimpleSingletion instance = LazySimpleSingletion.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + instance);
    }
}

public class LazySimpleSingletonTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread());
        t1.start();
        t2.start();
        System.out.println("End");
    }
}

给getInstance()加上synchronized关键字，使这个方法变成线程同步方法：

当执行其中一个线程并调用getInstance()方法时，另一个线程在调用getInstance()方法，线程的状态由 RUNNING 变成了 MONITOR，出现阻塞。直到第一个线程执行完，第二个线程才恢复到RUNNING状态继续调用getInstance()方法

线程切换调试

上图完美地展现了 synchronized 监视锁的运行状态，线程安全的问题解决了。但是，用synchronized加锁时，在线程数量比较多的情况下，如果CPU分配压力上升，则会导致大批线程阻塞，从而导致程序性能大幅下降。那么，有没有一种更好的方式，既能兼顾线程安全又能提升程序性能呢？答案是肯定的。我们来看双重检查锁的单例模式：

方法2.双重检查锁

/**
 * 优点:性能高了，线程安全了
 * 缺点：可读性难度加大，不够优雅
 */
public class LazyDoubleCheckSingleton {
    // volatile解决指令重排序
    private volatile static LazyDoubleCheckSingleton instance;

    private LazyDoubleCheckSingleton() {
    }

    public static LazyDoubleCheckSingleton getInstance() {
        //检查是否要阻塞，第一个instance == null是为了创建后不再走synchronized代码，提高效率。可以理解是个开关。创建后这个开关就关上，后面的代码就不用执行了。
        if (instance == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                //检查是否要重新创建实例
                if (instance == null) {
                    instance = new LazyDoubleCheckSingleton();
                    //指令重排序的问题
                    //1.分配内存给这个对象 
                    //2.初始化对象
                    //3.设置 lazy 指向刚分配的内存地址
                }
            }
        }
        return instance;
    }
}

public class ExectorThread implements Runnable {
    public void run() {
        LazyDoubleCheckSingleton instance = LazyDoubleCheckSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + instance);
    }
}

public class LazySimpleSingletonTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread());
        t1.start();
        t2.start();
        System.out.println("End");
    }
}

当第一个线程调用 getInstance()方法时，第二个线程也可以调用。当第一个线程执行到synchronized时会上锁，第二个线程就会变成 MONITOR状态，出现阻塞。此时，阻塞并不是基于整个LazySimpleSingleton类的阻塞，而是在getInstance()方法内部的阻塞，只要逻辑不太复杂，对于调用者而言感知不到。

但是，用到 synchronized 关键字总归要上锁，对程序性能还是存在一定影响的。难道就真的没有更好的方案吗？当然有。我们可以从类初始化的角度来考虑，看下面的代码，采用静态内部类的方式：

方法3.静态内部类

/*
  ClassPath : LazyStaticInnerClassSingleton.class
              LazyStaticInnerClassSingleton$LazyHolder.class
   优点：写法优雅，利用了Java本身语法特点，性能高，避免了内存浪费,不能被反射破坏
   缺点：不优雅
 */
//这种形式兼顾饿汉式单例模式的内存浪费问题和 synchronized 的性能问题 
//完美地屏蔽了这两个缺点
//自认为史上最牛的单例模式的实现方式 
public class LazyStaticInnerClassSingleton {

    //使用 LazyInnerClassGeneral 的时候，默认会先初始化内部类 
    //如果没使用，则内部类是不加载的
    private LazyStaticInnerClassSingleton(){
        // if(LazyHolder.INSTANCE != null){
        //     throw new RuntimeException("不允许非法创建多个实例");
        // }
    }

    //每一个关键字都不是多余的，static 是为了使单例的空间共享，保证这个方法不会被重写、重载 
    private static LazyStaticInnerClassSingleton getInstance(){
        //在返回结果以前，一定会先加载内部类 
        return LazyHolder.INSTANCE;
    }

    //默认不加载 
    private static class LazyHolder{
        private static final LazyStaticInnerClassSingleton INSTANCE = new LazyStaticInnerClassSingleton();
    }
}

这种方式兼顾了饿汉式单例模式的内存浪费问题