【Java】单例设计模式-饿汉模式和懒汉模式

单例模式

概念

单例是一种设计模式。单例指的是在全局范围内只有一个实例对象。比如在学习JDBC编码时使用的DataSource，定义了数据库的用户名，密码和连接串，定义好这些属性之后就可以通过DataSource的实例对象获取数据库连接。设计模式是大牛们根据以往的程序设计经验，总结出的一套方法，类似于棋谱。

如何设计

1.口头约定
对外提供一个方法，要求大家使用这个对象时，通过这个方法来获取。只要有人参与的事都不太靠谱，所以不能采用。
2.使用编程语言本身的特性来处理
首先要分析清楚在Java中哪些对象是全局唯一的。

①.class对象，比如String.class;
②用static修饰的变量是类的成员变量。所有的实例对象访问的都i是同一个成员变量；

通过类对象和static配合可以实现单例的目的。

public class Demo01_Singleton {
    public static void main(String[] args) {
        //验证单例是否正确
        Singleton singleton01 = new Singleton();
        Singleton singleton02 = new Singleton();
        Singleton singleton03 = new Singleton();
        //分别打印
        System.out.println(singleton01.getInstance());
        System.out.println(singleton02.getInstance());
        System.out.println(singleton03.getInstance());
    }
}
public class Singleton {
    //用static修饰变量，变量就是自己,并赋初值
    private static Singleton instance = new Singleton();
    //提供一个对外获取实例对象的方法
    public Singleton getInstance(){
        return instance;
    }
}

上述示例打印出的结果相同。instance在类加载时就完成初始化，所有的类对象之间共享这个实例，这样就完成了一个简单的单例模式。还可以进一步优化。既然是单例，通过new的方式获取对象是有歧义的，所以就不能让外部new这个对象。可以私有化构造方法来实现。

public class Demo01_Singleton {
    public static void main(String[] args) {
        //通过静态方法调用，获取单例
        Singleton singleton01 = Singleton.getInstance();
        Singleton singleton02 = Singleton.getInstance();
        Singleton singleton03 = Singleton.getInstance();
        //分别打印
        System.out.println(singleton01);
        System.out.println(singleton02);
        System.out.println(singleton03);
    }
}
public class Singleton {
    //用static修饰变量，变量就是自己,并赋初值
    private static Singleton instance = new Singleton();
    //构造方法私有化
    private Singleton(){

    }
    //提供一个对外获取实例对象的方法
    public static Singleton getInstance(){
        return instance;
    }
}

饿汉模式

类似于上述这种类一加载就完成初始化的方式称为饿汉模式。书写简单，不易出错。

懒汉模式

为了避免程序一启动就浪费过多的系统资源，当程序要使用这个对象时再对他进行初始化，这种方式称为懒汉模式。

public class Demo02_SingletonLazy {
    public static void main(String[] args) {
        SingletonLazy singletonLazy01 = SingletonLazy.getInstance();
        SingletonLazy singletonLazy02 = SingletonLazy.getInstance();
        SingletonLazy singletonLazy03 = SingletonLazy.getInstance();
        //打印
        System.out.println(singletonLazy01);
        System.out.println(singletonLazy02);
        System.out.println(singletonLazy03);
    }
}
public class SingletonLazy {
    //定义类成员变量
    private static SingletonLazy instance = null;
    //构造方法私有化
    private SingletonLazy(){}
    public static SingletonLazy getInstance(){
        //在获取成员变量时，判断一下是否已被创建
        //如果没创建再创建
        if(instance == null){
            instance = new SingletonLazy();
        }
        return instance;
    }
}

上面这个懒汉模式的示例在单线程环境下不会出错，打印出的结果相同，但是在多线程环境下可能会出现错误。

public class Demo03_SingletonLazyThread {
    public static void main(String[] args) {
        //创建多个线程并获取单例对象
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                //获取单例对象并打印
                SingletonLazy instance = SingletonLazy.getInstance();
                System.out.println(instance);
            });
            //启动线程
            thread.start();
        }
    }
}
public class SingletonLazy {
    //定义类成员变量
    private static SingletonLazy instance = null;
    //构造方法私有化
    private SingletonLazy(){}
    public static SingletonLazy getInstance(){
        //在获取成员变量时，判断一下是否已被创建
        //如果没创建再创建
        if(instance == null){
            instance = new SingletonLazy();
        }
        return instance;
    }
}

比如上述示例中，10个线程里打印出的instance对象不全是同一个对象，不符合预期，出现了线程不安全的现象。

分析造成线程不安全的原因

可能存在以下这种情况：线程1先将instance加载(LOAD)到自己的工作内存中，LOAD的值为null；此时线程1被调离CPU，线程2调入CPU；线程2此时LOAD的值也是null，比较(CMP)之后，初始化了一个instance对象，相当于给它分配了(ASSIGN)一个内存空间，然后保存(STORE)到主内存中。此时线程2执行完毕，继续执行线程1中的指令。线程1比较自己工作内存中的值为null，也初始化一个新的对象，然后再保存到主内存中。所以在多线程环境下，多个线程有可能创建多个实例，出现覆盖现象。

解决方法

在单例模式下，要保证任何时候都只能出现一个有效对象。所以在多线程环境下要给代码加锁。那加锁的范围该如何确定？
方法1：给整个方法加锁，可以解决这个问题；

    public synchronized static SingletonLazy getInstance(){
        //在获取成员变量时，判断一下是否已被创建
        //如果没创建再创建
        if(instance == null){
            instance = new SingletonLazy();
        }
        return instance;
    }

方法2：在方法内部加锁。此时有两种情况：一种是只给初始化对象的语句加锁，一种是给整个if语句块加锁。这两种加锁的方式效果也会不同。
情况1：只给初始化对象的语句加锁

    public static SingletonLazy getInstance(){
        //在获取成员变量时，判断一下是否已被创建
        //如果没创建再创建
        if(instance == null){
            synchronized (SingletonLazy.class){
                instance = new SingletonLazy();
            }
        }
        return instance;
    }

虽然加了锁，但是这种情况这种情况的加锁并没有阻挡多线程里的if语句判空，都将初始化实例对象和存储执行了两次，发生了覆盖现象，依然会有线程安全问题。
情况2：给整个if代码块加锁

public static SingletonLazy getInstance(){
        //在获取成员变量时，判断一下是否已被创建
        //如果没创建再创建
        synchronized (SingletonLazy.class){
            if(instance == null){
                instance = new SingletonLazy();
            }
        }
        return instance;
    }

此时让synchronized的包裹范围指定为整个初始化过程，可以达到预期的效果，与在方法定义中加synchronized是等价的。

目前来看这些解决方法是符合预期的，但是可以做进一步优化。以现在的写法，只要调用getInstance()方法，都需要参与锁竞争，频繁的进行用户态和内核态的切换，非常消耗资源的，相当于从用户态进入了内核态。在整个过程中，目的是让整个初始化的过程只执行一次，所以只需要让synchronized代码块在整个过程中执行一次就行。

用户态：Java层面，在JVM中执行的代码；
内核态：执行的是CPU指令。这里加了synchronized参与锁竞争之后就从应用层面进入到了系统层面。

    public static SingletonDCL getInstance(){
        //为了让后面线程调用该方法时，如果实例已经被创建，不再获取锁，直接返回实例
        if(instance == null){
            synchronized (SingletonDCL.class){
                //完成初始化操作，只执行一次
                if(instance == null){
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }

在这个优化中，内层的if语句是为了完成初始化操作，只执行一次。而外面的if判断语句是为了让后面线程调用该方法时，如果实例已经被创建，不再获取锁，直接返回实例，让用户态来完成自己的事，避免锁竞争造成的资源浪费。这种用两层if判断的方式叫双重检查锁，两层if的功能是不一样的。

还可以继续优化。在之前多线程的线程安全中介绍过synchronized只能保证原子性和内存可见性，不能保证有序性。初始化的过程并不是一条指令。在整个初始化过程中，经历了如下阶段：
①在内存中开辟一片空间；
②初始化的对象的属性(数据)；
③把内存中的地址赋给instance变量。
程序在正常执行的过程中是按照①②③这个顺序执行的。由于①和③是两个强相关的执行过程，②则是一个单独的执行过程，所以编译器或CPU就有可能进行指令重排序，使执行过程变为①③②，这样其他线程就有可能拿到一个创建了一半的对象，也就是第②步还没执行完，那么这个对象就是一个不安全的对象。所以需要用volatile修饰变量，禁止指令重排序。

public class Demo04_SingletonDCL {
    public static void main(String[] args) {
        //创建多个线程并获取单例对象
        for (int i = 0; i < 10; i++) {
            Thread thread = new Thread(() -> {
                //获取单例对象并打印
                SingletonDCL instance = SingletonDCL.getInstance();
                System.out.println(instance);
            });
            //启动线程
            thread.start();
        }
    }
}
public class SingletonDCL {
    //定义类成员变量
    private volatile static SingletonDCL instance = null;
    //构造方法私有化
    private SingletonDCL(){}
    public  static SingletonDCL getInstance(){
        //为了让后面线程调用该方法时，如果实例已经被创建，不再获取锁，直接返回实例。
        if(instance == null){
            synchronized (SingletonDCL.class){
                //完成初始化操作，只执行一次
                if(instance == null){
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }
}

总结

🐼工作中可以使用饿汉模式，因为书写简单不容易出错；
🐼饿汉模式在程序加载时完成初始化，但是由于计算资源有限，为了节约资源，使用懒汉模式加载；
🐼懒汉模式就是在使用对象的时候再去完成初始化操作；
🐼懒汉模式在多线程环境下可能出现线程不安全的问题；
🐼那么就需要使用synchronized包裹初始化的代码块；初始化代码只执行一次，后续的线程在调用getinstance()方法时，依然会产生锁竞争，频繁进行用户态和内核态的切换，非常浪费计算资源；
🐼这时可以使用Double Check Lock（DCL）的方式在外层加非空校验，避免无用的锁竞争；
🐼synchronized解决了原子性、内存可见性问题，再使用volatile修饰共享变量解决有序性问题。

---

继续加油~