1.设计模式是啥？

设计模式是前人经过总结，通过对不同应用场景应该运用何种方法解决问题的模式。我们可以将它看成NBA中的战术（例如：电梯门战术），在应对不同的队伍时，需要运用不同的战术，针对不一样的队伍用不一样的战术才能更高效的得分，这就相当于对不同的问题有固定的模板免得去思考，可以直接去使用。故可认为：它是解决待定问题的一系列套路，是前辈们的代码设计经验的总结，具有一定的普遍性，可以重复使用。其目的是为了提高代码的可重用性、代码的可读性和代码的可靠性。

2.单例模式

2.1什么是单例模式

这个就看字面意思就很好理解，就是只能有一个例子，也就是该类只能new一个对象。

官方的说就是：这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

目前单例模式有两种：1.饿汉式 2.懒汉式

如何实现单例模式呢？我们就从者两个模式的具体实现来说明吧！

2.2饿汉模式

饿汉式单例模式实现步骤：

1.将构造器私有化

 解释：防止用户构造新对象

2.在类中创建好一个对象

 解释：因为我们把构造器进行了私有化操作，但我们单例模式中需要有个对象，因此我们需要在类中实例化好一个对象。

3.创建一个方法，或者类中创建好的对象

 解释：因为我们外部不能创建对象，但是我们类中有创建好的对象，因此我们需要一个方法来将对象给取出来。

代码实现：

class Singleton {
    private static Singleton instance=new Singleton();
    public static Singleton getS() {
        return  instance;
    }
    private  Singleton(){};
}
public class testDemo1 {
    public static void main(String[] args) {
        Singleton singleton=Singleton.getS();
    }
}

注意：

观察代码，有几个细节需要注意；因为用户不可以创建对象，因此我们需要在类中创建好对象，不能创建对象，就意味着我们不能通过对象引用类中的成员方法与成员变量，即在类中new对象时和获得new好的对象时需要用静态成员变量和静态成员方法，通过类名来访问。

2.3懒汉模式

懒汉式单例模式实现步骤：

1.将构造器私有化

 解释：防止用户构造新对象

2.在类中创建好一个对象

 解释：因为我们把构造器进行了私有化操作，但我们单例模式中需要有个对象，因此我们需要在类中实例化好一个对象。

3.创建一个方法，或者类中创建好的对象

 解释：因为我们外部不能创建对象，但是我们类中有创建好的对象，因此我们需要一个方法来将对象给取出来。

class  SingleLazy{
    private static SingleLazy instance=null;
    public static SingleLazy getInstance() {
        if(instance==null) {
            instance=new SingleLazy();
        }
        return instance;
    }
    private SingleLazy() {
    }
}
public class testDemo2 {
    SingleLazy singleLazy=SingleLazy.getInstance();
}

注意：

观察代码，有几个细节需要注意；因为用户不可以创建对象，因此我们需要在类中创建好对象，不能创建对象，就意味着我们不能通过对象引用类中的成员方法与成员变量，即在类中new对象时和获得new好的对象时需要用静态成员变量和静态成员方法，通过类名来访问。

与饿汉模式不同之处时，懒汉模式只有在调用到这个对象时，对象才得以创建，在没有调用之前，创建出来的对象时null，懒汉模式要比饿汉模式节省一些不必要的资源。  

3.懒汉模式与饿汉模式的区别

3.1.线程安全方面

饿汉式天生就是线程安全的，因为饿汉模式当中仅仅只有读操作，可以直接用于多线程而不会出现问题，懒汉式本身是非线程安全的，懒汉模式线程不安全是因为他在创造对象时会产生指令重排序。

3.2.资源加载和性能

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成。

懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟。

4.如何保证懒汉模式的线程安全

首先我们要了解什么是线程不安全：

1. 1. 抢占式执行
2. 2.修改操作，不是原子性的
   
3. 3.内存可见性，引发的线程不安全
   
4. 4.指令重排序引发的线程不安全
   
5. 5.多线程修改同一个变量引发的线程不完全
6. 
   

我们对标一下在懒汉模式中有几条是符合上方条件的

在懒汉模式getInstance()方法中，对instance对象即包括了读操作，也包括了写操作；在操作时，会发生指令重排序这对于多线程是不完全的。

这样说不是很只管，我们画图来说明（这里的例子仅代表一种情况）：

这种情况我们如何避免呢？很好整，不同的问题，我们就不同的方案来解决，这时的解决方法就是给代码加锁。

这样我们就可以阻止指令重排序，让写操作在同一个线程内完成了！

真的就完成了吗？

并非如此，试想：在instance初始化之前，还是instance初始化之后，都会导致阻塞，存在大量的锁竞争，因此导致程序运行速度减慢（哪有一本万利的生意🐣）。

因此对于防止过多的锁竞争，我们需要再次改进代码：再加入一个判断（虽然有两个相同的if判断，但是两个判断的初心不同）,判断instance是否初始化，如果已经初始化过了，就不需要再次加锁了。

还有一个问题没有解决就是内存可见性的问题。

如果有多个线程都调用getInstance()方法，就会有大量的读instance操作，我们知道对于访问内存与寄存器，访问寄存器的速度要比内存高几个数量级；因此，编译器就会自作主张优化掉访问内存的操作；即：将读内存的操作优化为读寄存器的操作。

为了保证内存可见性，我们需要将 在创建instance对象的语句上加上volatile关键字，来保证内存可见性。

完整代码如下：

class  SingleLazy{
    private volatile static SingleLazy instance=null;
    //创建一个实例对象
    public static SingleLazy getInstance() {
        //判断是否需要加锁
        if(instance==null) {
            synchronized (SingleLazy.class) {
                //判断对象是否实例化
                if (instance == null) {
                    instance = new SingleLazy();
                }
            }
        }
        return instance;
    }
    private SingleLazy() {
    }
}