spring源码学习之设计模式（1）单例模式

众所周知，单例模式分为饿汉式和懒汉式，昨天在看了《spring5核心原理与30个类手写实战》之后才知道饿汉式有很多种写法，分别适用于不同场景，避免反射，线程不安全问题。下面就各种场景、采用的方式及其优缺点介绍。

饿汉式 （绝对的线程安全）

代码示例

1.第一种写法 （ 定义即初始化）

public class Singleton{
    private static final Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

1. 第二种写法 （静态代码块）

public class Singleton{
    private static final Singleton instance = null;
    static {
        instance = new Singleton();
    }
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

饿汉式基本上就这两种写法。在spring框架中IoC的ApplicantsContext就是使用的饿汉式单例，保证了全局只有一个ApplicationContext 和在应用启动后就能获取实例，一遍进行接下来的操作.

优点

因其在程序启动后就已经初始化，也不需要任何锁保证线程安全 ，所以执行效率高

缺点

因为在程序启动后就已经进行了初始化，即便是不用也进行了初始化，所以无论何时都占用内存空间，浪费了内存空间。

懒汉式 （线程安全需要另外的操作）

##### 代码示例

1. 第一种写法

public class Singleton{
    private static final Singleton instance = null;
 
    private Singleton() {}
    public static Singleton getInstance() {
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }

}

上面的代码不难看出，在单线程下执行是没有问题的，但在多线程情况下，线程执行速度和顺序无法控制确定，故有可能会产生多个实例对象，这样就违背了单例模式的初衷了。

1. 第二种写法

   加锁保证线程安全（synchronized关键字）

public class Singleton{
    private static final Singleton instance = null;
 
    private Singleton() {}
    public synchronized static Singleton getInstance() {
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }

}

​ 可以看到在getInstance（）上加了synchronized关键字，就能保证线程同步。但又有一个问题:使用synchronized关键字是，当一个线程调用获取实例的方法时，会锁住整个类，其他的线程再调用，会使线程状态由 RUNNING 变成 MONITOR ，进而导致线程阻塞，执行效率下降；知道这个线程执行完实例方法，其他线程才能继续执行，两个线程时，效率下降还在可以接受范围内，但在实际应用场景中，使用线程池来管理线程的调度，会有大量的线程，如果这些线程都阻塞了，其结果可以预见。

上述问题有什么更好的问题解决呢？使用双重检查锁机制可以完美的解决这个问题。其代码如下

public class Singleton{
    private volatile  static final Singleton instance = null;
 
    private Singleton() {}
    public  static Singleton getInstance() {
        if(instance == null){
            synchronized(Singleton.class){
                if (instance == null) {
                    instance = new Singleton();
                }
            }
            
        }
        return instance;
    }

}

这里需要解释下，童鞋们都知道一个对象使用要经历一下步骤：

• 为对象分配内存

• 初始化对象

• 实例对象指向第一布分配的内存地址

  在java中JVM为了提高执行效率，会进行指令重排。那什么时指令重排呢？指令重排是指JVM为了优化指令，提高程序的运行效率，在不影响单线程执行结果的情况下，进行指令重排序，以期提高并行度。

有上述可以指令重排在单线程情况下，对程序的执行不会产生影响，但在多线程情况下就不一定了。所以上述过程的执行顺序可能发生变化，进而导致程序并不会按照预想的执行。

为解决上述问题以及保证并发编程的正确性，java中定义了 **happens-before**原则。在 《JSR-133:Java Memory Model and Thread Specification》 书中关于happens-before定义是这样的：

1.如果一个操作happens-before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。

2.两个操作之间存在happens-before关系，并不意味着Java平台的具体实现必须要按照happens-before关系指定的顺序来执行。如果重排序之后的执行结果，与按happens-before关系来执行的结果一致，那么这种重排序并不非法。

在Java中 为 避免指令重排出现，引入了volatile 关键字。正如你所看到那样在实例对象前就能保证执行结果的正确性。当一个线程调用getInstance（）方法时，执行到synchronized关键字时就会上锁，其他线程也调用时就会发生阻塞，当然这种阻塞不是锁住整个类，而是仅仅锁住了方法。如过方法中的逻辑不是太复杂的话，对于外界来说是感知不到的。

​ 这种方法终归还是要加锁的，只要加锁就会对程序性能产生影响。有什么解决办法可以实现不加锁，又能保证线程安全呢？

内部类：是指 一个类定义在另一个类里面或者一个方法里面 的类。有以下特点ÿ