【JAVAEE】单例模式的介绍及实现（懒汉模式和饿汉模式）

目录

1.单例模式

1.1概念

1.2单例模式的实现方式

怎么去设计一个单例

饿汉模式

懒汉模式

懒汉模式-多线程版 

解决懒汉模式多线程不安全问题-synchronized

解决懒汉模式多线程不安全问题-volatile

---

1.单例模式

1.1概念

单例是一种设计模式。

啥是设计模式 ?

设计模式好比象棋中的 " 棋谱 ". 红方当头炮 , 黑方马来跳 . 针对红方的一些走法 , 黑方应招的时候有一些固定的套路 . 按照套路来走局势就不会吃亏 .

软件开发中也有很多常见的 " 问题场景 ". 针对这些问题场景 , 大佬们总结出了一些固定的套路 . 按照这个套路来实现代码 , 也不会吃亏 .

单例：在全局范围内只有一个实例对象。

单例模式能保证某个类在程序中只存在唯一一份实例，而不会创建多个实例。

例如：JDBC中的DateSourse实例就只需要一个。

1.2单例模式的实现方式

怎么去设计一个单例

1.口头约定

对外提供一个方法，要求大家使用这个对象的时候，通过这个方法来获取。（不太靠谱，一般不采用）

2.使用变成语言本身的特性来处理

首先分析一下在Java中哪些对象是全局唯一的：

①类对象  .class

②用static修饰的变量（static修饰的变量是类的成员变量，所有实例对象，访问的都是同一个成员变量）

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

示例（实现单例模式）：

用static修饰变量，变量就是自己，并且赋初始值。再提供一个对外获取实例对象的方法。

    private static Singleton instance=new Singleton();

    public Singleton getInstance() {
        return instance;
    }

验证单例是否正确

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());
    }

结果：

 既然是单例，那么通过new的方法去获取对象是有歧义的，不能让外部去new这个对象。

将构造方法私有化，通过静态方法调用，获取单例：

public class Singleton {
    private static Singleton instance=new Singleton();

    //构造方法私有化
    private Singleton(){};

    public static Singleton getInstance() {
        return instance;
    }
}

用类名去调用：

        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 {
    private static Singleton instance=new Singleton();

    //构造方法私有化
    private Singleton(){};

    public static Singleton getInstance() {
        return instance;
    }
}

懒汉模式

彼岸程序启动的时候浪费过多的系统资源，当程序使用这个对象时再对他进行初始化。即类加载的时候不创建实例，第一次使用的时候才创建实例的方式称为懒汉模式。

示例：

public class SingletonLazy {
    //定义一个类成员变量
    private static  SingletonLazy instance=null;

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

运行一下，结果如下：

public static void main(String[] args) {
        SingletonLazy singleton01=SingletonLazy.getInstance();
        SingletonLazy singleton02=SingletonLazy.getInstance();
        SingletonLazy singleton03=SingletonLazy.getInstance();
        System.out.println(singleton01);
        System.out.println(singleton02);
        System.out.println(singleton03);
    }

懒汉模式-多线程版 

懒汉模式的实现其实是线程不安全的。

例如（在多线程环境下获取单例对象）：

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();
        }
    }

结果：

发现获取到了不同的对象，并不符合我们的预期，也就是说出现了线程不安全的现象。

那具体是什么原因导致的线程不安全呢？

t1先LOAD，然后t2执行完所有指令后，t1再继续执行。如上图所示，进行了两次初始化。所以，再多线程环境下，多个线程又可能创建多个实例。

解决懒汉模式多线程不安全问题-synchronized

①可以给getInstance方法加锁。

②将synchronized的范围指定为整个初始化过程，与在方法中加锁是等价的

synchronized (SingletonLazy.class) {
            if (instance == null) {
                instance = new SingletonLazy();
            }
        }

 得到的结果目前看来是符合预期的。

但是有一个非常严重的问题：

每一次调用getInstance()方法的时候，都需要进行锁竞争，再进行判断，而锁竞争是非常耗费系统资源的。其实，synchronized代码块再整个程序运行过程中，只需要执行一次就够了。

用户态：Java层面，在JVM中执行的代码

内核态：执行的是CPU指令

也就是说加了synchronized参与锁竞争之后就从应用层面进入到了系统层面。

为了避免过度锁竞争，这里可以加入一层判断

public static SingletonDCL getInstance(){
        if(instance==null) {
            synchronized (SingletonDCL.class) {
                if (instance == null) {
                    instance = new SingletonDCL();
                }
            }
        }
        return instance;
    }

双重检查，避免了过度耗费系统资源。

执行一下，结果正确：

 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();
        }

    }

解决懒汉模式多线程不安全问题-volatile

synchronized关键字解决了原子性，内存可见性问题。

volatile关键字解决有序性问题。

初始化过程，并不是一条指令。在整个初始化过程中，经历如下阶段：

1.在内存中开辟一片空间

2.初始化对象的属性（数据）

3.把内存中的地址，赋给instance变量

程序在正在执行的过程中就是按1，2，3这个顺序执行的。1与3是强相关的执行过程，2是一个单独的过程，所以编译或者CPU就有可能进行指令重排序，使程序执行过程变1，3，2.。如果出现这种顺序，那么其它线程就又肯拿到一个创建了一半的对象，导致了线程不安全。

这个时候就需要用volatile修饰变量，禁止指令重排序。