[Java]单例模式

进步·于辰

已于 2024-06-03 00:26:24 修改

阅读量1.3w

点赞数 1

分类专栏： Java知识点文章标签： Java单例模式

于 2023-03-15 11:49:53 首次发布

本文链接：https://blog.csdn.net/m0_69908381/article/details/129545153

版权

Java知识点专栏收录该内容

15 篇文章 2 订阅

订阅专栏

【版权声明】未经博主同意，谢绝转载！（请尊重原创，博主保留追究权）
https://blog.csdn.net/m0_69908381/article/details/129545153
出自【进步*于辰的博客】

参考笔记一，P28.3、P29.9、P71.1。

1、介绍

1.1 什么是单例模式？

“单例模式”指关闭对外实例化方法，需通过调用类方法获取实例，且多次调用都始终保持同一个实例的一种设计模式。

当一个线程改变此唯一实例的成员变量时，由于其他线程不可见，就会导致并发性问题。因此，往往不声明成员变量，仅定义了成员方法时使用单例模式。

1.2 如何实现单例模式？

看下述代码。（注：此示例未实现单例模式，仅用于说明实现单例模式的思想）

class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton newInstance() {
        return new Singleton();
    }
}

获取实例的方法不是通过new或者反射，而是通过调用newInstance()实现。说明：

instance定义为静态私有，一是为了newInstance()可访问，二是防止类外直接获取。
构造方法声明为private，使得无法主动实例化（new）.。
newInstance()是静态公共方法，使用static修饰是因为 Singleton 类无法实例化，故无法通过对象调用newInstance()；使用public修饰是为了方便类外调用。

$\color{green}{扩展说明}$ ：

“懒汉式”是在调用newInstance()时才创建实例，故无需分析。
判断“饿汉式”的情况：若instance为类变量，其在类初始化时创建，自然可保证唯一实例；若instance为成员变量，其在实例初始化时创建，但由于构造方法禁止实例化，故也是在调用newInstance()时创建，也可保证唯一实例。因此，instance定义为类变量与单例模式没有直接关系。

2、单例模式的两种形式

2.1 饿汉式

基础格式：

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

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

唯一实例在类内直接创建，不存在多实例可能，不违背“单例”，故不存在线程安全问题，但可能导致内存浪费。

2.2 懒汉式

基础格式：

class Singleton {
    private static Singleton instance;
    private Singleton() {}

    public static Singleton newInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

当newInstance()被调用时，才创建实例。

$\color{red}{存在的线程安全问题}$ ：
从表面上看，基础“懒汉式”没有问题。可实际上，由于newInstance()本身线程不安全，当多个线程同时调用时，就存在创建多个实例的可能，违背“单例”，故存在线程安全问题。

举个栗子。

public static Singleton newInstance(){
    if (instance == null) {---------------A
        instance = new Singleton();-------B
    }
    return instance;
}

假设有两个线程x、y同时调用newInstance()。

x先执行A，判断 instance 是否为null，为true，但还未执行B。可此时，x的CPU时间片用完，CPU被y抢去。y也执行A，判断instance是否为null，为true，执行B，创建一个实例。

然后，x重新获得时间片，继续执行，由于x已经判断过instance，故直接执行B，再创建一个实例。

至此，线程x、y都创建了一个实例，这就违背了“单例“。

在高并发下，这种情况很容易发生，而且这只是其中一种情况。

3、解决“懒汉式”线程安全问题的三种方法

3.1 锁方法

public static synchronized Singleton newInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
}

用synchronized同步锁将方法锁住，这样一次就只能有一个线程进入方法。

3.2 锁代码块

public static Singleton newInstance() {
    synchronized (Singleton.class) {
        if (instance == null) {-------------A
            instance = new Singleton();-----B
        }
    }
    return instance;
}

因为可能存在线程安全问题的代码是A，故用同步锁将其锁住，原理与“锁方法”相同。

3.3 DCL

public static Singleton newInstance() {
    if (instance == null) {--------------------A
        synchronized (Singleton.class) {-------B
            if (instance == null) {------------C
                instance = new Singleton();
            }
        }
    }
    return instance;---------------------------D
}