设计模式系列 — 单例设计模式

最新推荐文章于 2023-07-25 20:54:09 发布

一角钱技术

最新推荐文章于 2023-07-25 20:54:09 发布

阅读量298

点赞数 1

分类专栏：设计模式文章标签：设计模式 java 单例设计

本文链接：https://blog.csdn.net/org_hjh/article/details/109114150

版权

设计模式专栏收录该内容

18 篇文章 0 订阅

订阅专栏

点赞再看，养成习惯，微信搜一搜【一角钱技术】关注更多原创技术文章。
本文 GitHub org_hejianhui/JavaStudy 已收录，有我的系列文章。

前言

23种设计模式速记

前面写了一篇对23种设计模式快速记忆的文章，有小伙伴说能不能提供一些案例进行说明。设计模式系列文章安排上了，本篇就从最常用的单例模式和经常提到的反射机制对单例模式的攻击。

模式定义

保证一个类只有一个实例，并且提供一个全局访问点。

场景说明

重量级的对象，不需要多个实例，如线程池，数据库连接池。

单例模式有八种

饿汉式(静态常量)
饿汉式(静态代码块)
懒汉式(线程不安全)
懒汉式(线程安全，同步方法)
懒汉式(线程安全，同步代码块)
双重检查(DCL)
静态内部类
枚举

饿汉式（静态常量）

构造器私有化（防止 new）
类的内部创建对象
只向外部暴露一个静态的公共方法（getInstance）

代码示例

package com.niuh.designpattern.singleton.v1;

/**
 *  饿汉模式（静态变量）
 *  类加载到内存后，就实例化一个单例。JVM保证线程安全
 *  简单使用，推荐使用
 *  唯一缺点：不管用到与否，类装载时就完成实例化
 *  Class.forName("")
 *     (话说你不用的，你装载它干啥)
 */
public class Singleton {

    // 1. 构造器私有化（防止new）
    private Singleton () {

    }
    // 2. 本类内部创建对象
    private final static Singleton instance = new Singleton();

    // 3. 提供一个公有的静态方法，返回实例对象，提供给外部使用
    public static Singleton getInstance() {
        return instance;
    }
}

class SingletonTest01 {
    public static void main(String[] args) {
        // 测试
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();

        System.out.println(instance1 == instance2); // true

        System.out.println("instance1.hashCode=" + instance1.hashCode());
        System.out.println("instance2.hashCode=" + instance2.hashCode());
    }
}

优缺点

优点：写法简单，实际上在类装载的时候就完成类实例化，避免类线程同步问题。
缺点：在类装载的时候就完成了实例化，没有实现 Lazy Loading 懒加载 的效果。如果从始至终就没有使用过这个实例，会造成内存的浪费。

这种方法基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，在单例模式中大多数都是调用 getInstace 方法，但是导致类装载的原因有多种，因此不能确定有其他的方式(或者其他的静态方法)导致类装载，这时候初始化 instance 就没有达到懒加载的效果

因此：这种单例模式可用，但是可能会造成内存的浪费。除非开发人员能肯定，此类一定会被用到，那么内存就不会被浪费。

饿汉式（静态代码块）

代码示例

/**
 * 饿汉式（静态代码块）
 */
public class Singleton {

    // 1. 构造器私有化
    private Singleton() {

    }

    // 2. 本类内部创建对象实例
    private static Singleton instance;

    // 在静态代码块中，创建单例对象
    static {
        instance = new Singleton();
    }

    // 3. 提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance() {
        return instance;
    }
}

优缺点

和上面一种很类似，都是在类内部实例化，只不过类的实例化放在了静态代码块中。类一加载，就执行类静态代码块中的代码。优缺点和上面一样。

这种单例模式可用，但是如果不用，可能会造成内存的浪费。

懒汉式（线程不安全）

代码示例

package com.niuh.designpattern.singleton.v3;

/**
 *
 * 懒汉式（线程不安全）
 */
public class Singleton {
    private static Singleton instance;

    // 构造函数私有化
    private Singleton() {

    }

    // 提供一个静态的公共方法，当使用到该方法时，才创建 instance，即懒汉式
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

class SingletonTest02 {
    public static void main(String[] args) {
        // 测试
        for (int i = 0; i< 100; i++) {
            new Thread(() ->
                    System.out.println(Singleton.getInstance().hashCode())
            ).start();
        }
    }
}

优缺点

起到了懒加载的效果，但是只能在单线程下使用；
如果在多线程下，一个线程进入了 if(instance == null) 判断语句块，可能另外一个线程也通过了这个语句判断，这是会产生多个实例，所以在多线程环境下不可使用这种方式。

在实际开发中，不要使用这种方式。

懒汉式（线程安全，同步方法）

代码示例

/**
 * 懒汉式（线程安全，同步方法）
 */
public class Singleton {
    private static Singleton instance;

    // 构造函数私有化
    private Singleton() {

    }
    // 提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    public static synchronized  Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

注：加入关键字保证线程安全问题 synchronized

优缺点

虽然加入保证线程安全的关键字，解决线程安全问题（其实实际上并不一定线程安全：编译器(JIT),CPU 有可能对指令进行重排序）
效率低下，每个线程在想获得实例的时候，执行 getInstance 方法都要进行同步。方法的同步效率太低。

在实际开发中，不推荐这种方式

懒汉式（线程安全，同步代码块）

代码示例

/**
 * 懒汉式（线程安全，同步代码块）
 */
public class Singleton {private static Singleton instance;

    // 构造函数私有化
    private Singleton() {

    }
    // 提供一个静态的公有方法，加入同步处理的代码，解决线程安全问题
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

优缺点

虽然对加锁处做了一定优化，总体优缺点同上面一致。

双重检查（DCL）

代码示例

/**
 * 双重检查 DCL
 */
public class Singleton {

    // 添加 volatile 关键字，防止指令重排
    private static volatile Singleton instance;

    // 构造函数私有化
    private Singleton() {

    }

    // 提供对外引用的静态方法，使用双重检查机制 double check
    public static Singleton getInstance() {
        if (instance == null) { // Double Check Lock
            // 双重检查
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

编译器(JIT),CPU 有可能对指令进行重排序，导致使用到尚未初始化的实例，可以通过添加volatile 关键字进行修饰

优缺点

Double-Check 概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if(singleton== null) 检查，这样就可以保证线程安全了
实例化代码只用执行一次，后面在进行访问的时候，判断 if(singleton== null)，直接 return 实例化对象，也避免了反复进行方法同步。

最重要的是 线程安全，延迟加载，效率高
在实际开发中，推荐使用这种单例设计模式

静态内部类

代码示例

package com.niuh.designpattern.singleton.v7;

/**
 * 静态内部类完成，推荐使用
 */
public class Singleton {

    // 添加 volatile 关键字，防止指令重排
    private static volatile Singleton instance;

    // 构造函数私有化
    private Singleton() {

    }
    
    // 写一个静态内部类，该类中有一个静态属性 Singleton
    private static class SingletonInstance {
        private  static final Singleton INSTANCE = new Singleton();
    }
    
    // 提供一个静态的公有方法，直接返回 SingletonInstance.INSTANCE
    public static synchronized Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

优缺点

本质上是利用类的加载机制来保证线程安全
只有在实际使用的时候，才会触发类的初始化，所以也是懒加载的一种形式。
优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高

静态内部类的方式在 singleton 类被装载时并不会被立即实例化，而是在需要的实例化的时候，调用 getInstance 方法，才会装载 SingletonInstance 类，从而完成 Singleton 的实例化
类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM 帮助我们保证了线程的安全性，在类进行初始化的时，别的线程是无法进入的。
推荐上实际开发中使用

枚举

代码示例

package com.niuh.designpattern.singleton.v8;

/**
 * 使用枚举，可以实现单例, 推荐
 */
public enum Singleton {
    INSTANCE; // 属性

    public void hello() {
        System.out.println("hello word~");
    }

}

 class SingletonTest08 {
    public static void main(String[] args) {

        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;

        System.out.println(instance1 == instance2);

        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
        instance1.hello();
    }
}

优缺点

天然不支持反射创建对应的实例，且有自己的反序列化机制
利用类加载机制保证线程安全

这借助 JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，推荐使用。

反射攻击实例

我们拿饿汉模式作为例子进行测试，饿汉模式的代码如下：

package com.niuh.designpattern.singleton.reflect;

/**
 * 饿汉模式防止反射攻击
 */
public class HungrySingleton {
    private static final HungrySingleton instance;

    private HungrySingleton(){
    }
    
    static {
        instance = new HungrySingleton();
    }

    public static HungrySingleton getInstance(){
        return instance;
    }

    private Object readResolve(){
        return instance;
    }
}

先写一个利用反射获取实例的方法和直接获取实例的方法，将两者的返回值进行比较，看返回的是否是一个实例。代码如下：

package com.niuh.designpattern.singleton.reflect;


import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * 反射攻击实例
 */
public class Reflectattack {

    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        Constructor<HungrySingleton> declaredConstructor = HungrySingleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);

        HungrySingleton hungrySingleton = declaredConstructor.newInstance();

        HungrySingleton instance = HungrySingleton.getInstance();
        
        System.out.println(hungrySingleton);
        System.out.println(instance);
        System.out.println(hungrySingleton == instance);
    }
}

运行后的结果为：可见，两者的结果并不是一个对象，则饿汉模式毅然受到了反射的攻击。

那么改如何解决这反射攻击呢？我们知道是在类加载的时候就加载了这个实例的，因为是在类加载的时候就生成了词实例，那么我们可以在构造器里面加一个判断，进行反射防御。代码如下：

测试结果为：

这种方式有一个特点，也就是它对类加载这个时刻就把对象创建好的这种类是ok的，静态内部类的单例也可以用。对于不是静态类的也需要解决下，要根据创建实例的顺序进行解决。但是无论如何反射都可以访问到类的方法和变量，进行修改，所以非类加载这个时刻就把对象创建好的这种类，是不能防止反射攻击的。

源码中的应用

//JDK&Spring
java.lang.Runtime
org.springframework.aop.framework.ProxyFactoryBean
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
org.springframework.core.ReactiveAdapterRegistry
//Tomcat
org.apache.catalina.webresources.TomcatURLStreamHandlerFactory
// 反序列化指定数据源
java.util.Currency
......

java.lang.Runtime 分析，其他的感兴趣的自行查阅源代码。

PS：以上代码提交在 Github ：https://github.com/Niuh-Study/niuh-designpatterns.git

文章持续更新，可以微信搜一搜「一角钱技术」第一时间阅读。
本文 GitHub org_hejianhui/JavaStudy 已经收录，欢迎 Star。

一角钱技术

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
设计模式系列 — 单例设计模式

点赞再看，养成习惯，微信搜一搜【一角钱技术】关注更多原创技术文章。本文 GitHub org_hejianhui/JavaStudy 已收录，有我的系列文章。前言23种设计模式速记前面写了一篇对23种设计模式快速记忆的文章，有小伙伴说能不能提供一些案例进行说明。设计模式系列文章安排上了，本篇就从最常用的单例模式和经常提到的反射机制对单例模式的攻击。模式定义保证一个类只有一个实例，并且提供一个全局访问点。场景说明重量级的对象，不需要多个实例，如线程池，数据库连接池。单例模式有八..
复制链接

扫一扫