Java设计模式-单例模式-饿汉-懒汉-饿汉线程不安全解决

最新推荐文章于 2022-09-01 22:29:04 发布

Nevercome_

最新推荐文章于 2022-09-01 22:29:04 发布

阅读量629

点赞数

分类专栏： Java 开发文章标签： Java 设计模式单例模式

本文链接：https://blog.csdn.net/Sunsscode/article/details/89741928

版权

Java 开发专栏收录该内容

9 篇文章 0 订阅

订阅专栏

为什么需要单例

单例模式能够保证一个类仅有唯一的实例，并提供一个全局访问点。

我们是不是可以通过一个全局变量来实现单例模式的要求呢？我们只要仔细地想想看，全局变量确实可以提供一个全局访问点，但是它不能防止别人实例化多个对象。通过外部程序来控制的对象的产生的个数，势必会系统的增加管理成本，增大模块之间的耦合度。所以，最好的解决办法就是让类自己负责保存它的唯一实例，并且让这个类保证不会产生第二个实例，同时提供一个让外部对象访问该实例的方法。自己的事情自己办，而不是由别人代办，这非常符合面向对象的封装原则。

单例模式主要有3个特点：

单例类确保自己只有一个实例。
单例类必须自己创建自己的实例。
单例类必须为其他对象提供唯一的实例。

饿汉模式

实现单例的饿汉模式主要有3步：

让默认的构造函数私有化，使外部类无法通过new的方式获取该类的实例

private SingletonHunger() {}

我们依旧要提供实例给外部，而外部类又无法取得该类的实例对象，所以我们将实例以静态变量的方式提供

public static SingletonHunger instance = new SingletonHunger();

public static void main(String[] args) {
    SingletonHunger s1 = SingletonHunger.instance;
    SingletonHunger s2 = SingletonHunger.instance;
    System.out.println(s1 == s2); // true
}

将instance类变量私有化并提供getter访问器

private static SingletonHunger instance = new SingletonHunger();

public static SingletonHunger getInstance() {
    return instance;
}

饿汉模式有什么特点呢，可以看到最明显的就是instance是静态成员变量，它在类被加载的时候就会被实例化，不管有没有被其它外部类访问，所以这种一开始就实例化好的，我们觉得它很着急，所以叫饿汉模式。

public class SingletonHunger {

    // 1. 将默认的构造函数私有化
    private SingletonHunger() {}

    // 2. 提供静态变量
    private static SingletonHunger instance = new SingletonHunger();

    // 3. 创建instance变量的getter访问器
    public static SingletonHunger getInstance() {
        return instance;
    }
}

懒汉模式

懒汉模式和饿汉模式的却别就在于懒汉模式只是声明类的实例变量，而在有外部类（线程）访问的时候才去真正实例化（开辟内存空间），之后的所有线程都共享最先创建的那个实例

public class SingletonLazy {

    // 1. 将默认的构造函数私有化
    private SingletonLazy() {
    }

    // 2. 声明类的唯一实例 只是声明
    private static SingletonLazy instance;

    // 3. 为instance提供访问器
    public static SingletonLazy getInstance() {
        if (instance == null) {
            instance = new SingletonLazy();
        }
        return instance;
    }
}

二者比较

饿汉模式：类加载时较慢，访问对象时较快，线程安全

懒汉模式：类加载时较快，访问对象时较慢，线程不安全

大多数应用场景下都使用懒汉模式，因为饿汉模式还有一个问题那便是内存空间的浪费。所以我们就需要解决懒汉模式的线程不安全问题

解决懒汉模式的线程不安全问题

主要解决的问题是两个

线程的并发
JVM的指令重排

第一个问题我们可以用加锁来实现，用sychronizd即可，第二个问题是Java的关键字volatile。

**加锁：**我们可以直接加在getter上，但是这样子的静态方法锁整个临界区比较大，比较耗费资源，所以使用同步代码块

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

为什么要判空两次？其实就是为了用同步代码块，你必须保证临界区完成一整套必不可少的操作，最开始的判空只是判断是否需要进入临界区。加入两个线程同时停在了第一个判空处，其中一个线程获得锁进去不判空直接new，那么它完成操作释放锁之后对于第二个等待锁的线程而言，它获得一释放的锁之后也是进去直接new，很显然，这一点都不符合临界区的设计。

volatile

instance = new Singleton();

这条语句并不是一个原子操作

分配内存给对象，在内存中开辟一段地址空间；// Singleton var = new Singleton();
对象的初始化；// var = init();
将分配好对象的地址指向instance变量，即instance变量的写；// instance = var;
设想一下，如果不使用volatile关键字限制指令的重排序，1-3-2操作，获得到单例的线程可能拿到了一个空对象，后续操作会有影响！因此需要引入volatile对变量进行修饰。

再详细的内容参考博客

所以最后我们得到的结果为这样

public class SingletonLazy {

    // 1. 将默认的构造函数私有化
    private SingletonLazy() {
    }

    // 2. 声明类的唯一实例 只是声明
    private volatile static SingletonLazy instance;

    // 3. 为instance提供访问器

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