脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java23种设计模式中的单例模式

Java23种设计模式中的单例模式你了解吗

 更新时间：2022年02月22日 16:45:59   作者：OASISHzzggg  
这篇文章主要为大家详细介绍了Java23种设计模式中的单例模式，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下，希望能够给你带来帮助

1、定义

单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。
隐藏其所有的构造方法。
属于创建型模式。

2、适用场景

确保任何情况下都绝对只有一个实例。

3、常见写法

第一种：饿汉式单例：在单例类首次加载时就创建实例

/**
 * @Package: com.hzg.study.design.pattern.singleton.hungry
 * @Description: 饿汉式单例
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 16:15
 */
public class HungrySingleton {
    private static final HungrySingleton INSTANCE = new HungrySingleton();
    /**
     * 私有化构造器
     */
    private HungrySingleton() {
    }
    /**
     * 全局访问点
     */
    public static HungrySingleton getInstance() {
        return INSTANCE;
    }
}

饿汉式单例静态代码块写法：

/**
 * @Package: com.hzg.study.design.pattern.singleton.hungry
 * @Description: 饿汉式单例(静态代码块初始化)
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 16:15
 */
public class HungryStaticSingleton {
    private static final HungryStaticSingleton INSTANCE;
    /**
     * 静态代码块
     */
    static {
        INSTANCE = new HungryStaticSingleton();
    }
    /**
     * 私有化构造器
     */
    private HungryStaticSingleton() {
    }
    /**
     * 全局访问点
     */
    public static HungryStaticSingleton getInstance() {
        return INSTANCE;
    }
}

第二种：懒汉式单例：被外部类调用时才创建实例

/**
 * @Package: com.hzg.study.design.pattern.singleton.lazy
 * @Description: 懒汉式单例
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 16:24
 */
public class LazySingleton {
    private static LazySingleton INSTANCE = null;
    /**
     * 私有化构造器
     */
    private LazySingleton() {
    }
    /**
     * 全局访问点
     */
    public static LazySingleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazySingleton();
        }
        return INSTANCE;
    }
}

懒汉式单例静态匿名内部类写法(性能最优)：

/**
 * @Package: com.hzg.study.design.pattern.singleton.lazy
 * @Description: 懒汉式单例(匿名静态内部类)(性能最优)
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 18:00
 */
public class LazyInnerClazzSingleton implements Serializable {
    /**
     * 私有化构造器
     */
    private LazyInnerClazzSingleton() {
    }
    /**
     * 全局访问点
     */
    public static final LazyInnerClazzSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();
    }
}

第三种：注册式单例：将每一个实例都缓存到统一的容器中，使用唯一标识获取实例

注册式单例枚举写法：

/**
 * @Package: com.hzg.study.design.pattern.singleton.registry
 * @Description: 注册式单例-枚举单例
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-21 10:24
 */
public enum EnumSingleton {
    INSTANCE;
    /**
     * 如果需要让其他对象成为单例，只需要将data改为目标类对象即可
     * <p/>
     * 通过getter和setter操作
     */
    private Object data;
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

Spring中常见的注册式单例写法：

/**
 * @Package: com.hzg.study.design.pattern.singleton.registry
 * @Description: Spring中常见的注册式单例写法
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-21 10:54
 */
public class ContainerSingleton {
    /**
     * spring ioc
     */
    private static Map<String, Object> container = new ConcurrentHashMap<>();
    private ContainerSingleton() {
    }
    public static Object getBean(String clazzName) {
        // 加synchronized代码块保证线程安全
        synchronized (container) {
            if (!container.containsKey(clazzName)) {
                Object object = null;
                try {
                    object = Class.forName(clazzName).newInstance();
                    container.put(clazzName, object);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return object;
            }
            return container.get(clazzName);
        }
    }
}

第四种：ThreadLocal线程单例：保证线程内部的全局唯一，且天生线程安全

/**
 * @Package: com.hzg.study.design.pattern.singleton.threadlocal
 * @Description: ThreadLocal线程单例(伪安全)
 * @Description: 可以使用ThreadLocal动态切换数据源
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-21 11:10
 */
public class ThreadLocalSingleton {
    public static final ThreadLocal<ThreadLocalSingleton> THREAD_LOCAL = new ThreadLocal<ThreadLocalSingleton>() {
        @Override
        protected ThreadLocalSingleton initialValue() {
            return new ThreadLocalSingleton();
        }
    };
    private ThreadLocalSingleton() {
    }
    public static ThreadLocalSingleton getInstance() {
        return THREAD_LOCAL.get();
    }
}

4、如何防止单例被破坏

1.多线程破坏单例以及解决方法

以懒汉式单例LazySingleton为例：

首先写一个线程实现类，如下：

import com.hzg.study.design.pattern.singleton.lazy.LazySingleton;
/**
 * @Package: com.hzg.study.design.pattern.singleton.lazy.test
 * @Description:
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 16:32
 */
public class ExecutorThread implements Runnable {
    @Override
    public void run() {
        LazySingleton instance = LazySingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + instance);
    }
}

main方法测试：

public class LazySingletonTest {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new ExecutorThread());
        thread1.start();
        Thread thread2 = new Thread(new ExecutorThread());
        thread2.start();
        System.out.println("----------------------------------------");
    }
}

测试结果：显然出现了两个不同的实例

解决方法1：加synchronized关键字修饰getInstance方法

public class LazySingleton {
    private static LazySingleton INSTANCE = null;
    /**
     * 私有化构造器
     */
    private LazySingleton() {
    }
    /**
     * 全局访问点
     * <p/>
     * synchronized关键字修饰方法
     */
    public static synchronized LazySingleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazySingleton();
        }
        return INSTANCE;
    }
}

解决方法2：双重检查锁DoubleCheck

/**
 * @Package: com.hzg.study.design.pattern.singleton.lazy
 * @Description: 懒汉式单例(双重检查锁)
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 17:08
 */
public class LazyDoubleCheckSingleton {
    /**
     * volatile关键字修饰，避免指令重排序引发问题
     */
    private volatile static LazyDoubleCheckSingleton INSTANCE = null;
    /**
     * 私有化构造器
     */
    private LazyDoubleCheckSingleton() {
    }
    /**
     * 全局访问点
     * <p/>
     * 双重检查锁
     */
    public static LazyDoubleCheckSingleton getInstance() {
        if (INSTANCE == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new LazyDoubleCheckSingleton();
                }
            }
        }
        return INSTANCE;
    }
}

2.反射破坏单例以及解决方法

以懒汉式单例静态匿名内部类写法LazyInnerClazzSingleton为例：

main方法测试：

public class LazyInnerClazzSingletonTest {
    public static void main(String[] args) {
        try {
            Class<LazyInnerClazzSingleton> aClazz = LazyInnerClazzSingleton.class;
            Constructor<LazyInnerClazzSingleton> declaredConstructor = aClazz.getDeclaredConstructor(null);
            declaredConstructor.setAccessible(true);
            LazyInnerClazzSingleton instance1 = declaredConstructor.newInstance();
            LazyInnerClazzSingleton instance2 = LazyInnerClazzSingleton.getInstance();
            System.out.println(instance1);
            System.out.println(instance2);
            System.out.println(instance1 == instance2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

测试结果：构建了两个不同的实例

解决方法：在构造器中增加如下if判断

public class LazyInnerClazzSingleton implements Serializable {
    /**
     * 私有化构造器
     */
    private LazyInnerClazzSingleton() {
        if (null != LazyHolder.INSTANCE) {
            throw new RuntimeException("不允许构建多个实例");
        }
    }
    /**
     * 全局访问点
     */
    public static final LazyInnerClazzSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();
    }
}

再次测试：

3.序列化破坏单例以及解决方法

以懒汉式单例静态匿名内部类写法LazyInnerClazzSingleton为例：注意必须先实现序列化接口Serializable

main方法测试：

    public static void main(String[] args) {
        LazyInnerClazzSingleton instance1 = LazyInnerClazzSingleton.getInstance();
        LazyInnerClazzSingleton instance2 = null;
        try (
                FileOutputStream fileOutputStream = new FileOutputStream("LazyInnerClazzSingleton.obj");
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
                FileInputStream fileInputStream = new FileInputStream("LazyInnerClazzSingleton.obj");
                ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        ) {
            // 序列化
            objectOutputStream.writeObject(instance1);
            objectOutputStream.flush();
            // 反序列化
            instance2 = (LazyInnerClazzSingleton) objectInputStream.readObject();
            System.out.println(instance1);
            System.out.println(instance2);
            System.out.println(instance1 == instance2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

测试结果：构建了两个不同的实例

解决方法：新增readResolve方法

public class LazyInnerClazzSingleton implements Serializable {
    /**
     * 私有化构造器
     */
    private LazyInnerClazzSingleton() {
        if (null != LazyHolder.INSTANCE) {
            throw new RuntimeException("不允许构建多个实例");
        }
    }
    /**
     * 全局访问点
     */
    public static final LazyInnerClazzSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();
    }
    /**
     * 重写readResolve方法，实际还是创建了两次，只不过是覆盖了反序列化出来的对象，之前反序列化出来的对象会被GC回收
     * 发生在JVM层面，相对来说比较安全
     */
    private Object readResolve() {
        return LazyHolder.INSTANCE;
    }
}

5、优缺点

优点：

在内存中只有一个实例，减少了内存开销。
可以避免对资源的多重占用。
设置全局访问点，严格控制访问。

缺点：

没有接口，扩展困难。
如果要扩展单例对象，只有修改代码，没有其他途径。
不符合开闭原则

6、总结

1、私有化构造器

2、保证线程安全

3、延迟加载

4、防止序列化和反序列化破坏单例

5、防御反射攻击单例

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注脚本之家的更多内容!  

您可能感兴趣的文章:

相关文章

  • JNDI在JavaEE中的角色_动力节点Java学院整理

    JNDI在JavaEE中的角色_动力节点Java学院整理

    这篇文章主要介绍了JNDI在JavaEE中的角色，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2017-08-08
  • java读取配置文件(properties)的时候,unicode码转utf-8方式

    java读取配置文件(properties)的时候,unicode码转utf-8方式

    这篇文章主要介绍了java读取配置文件(properties)的时候，unicode码转utf-8方式，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2022-02-02
  • SpringBoot Redis用注释实现接口限流详解

    SpringBoot Redis用注释实现接口限流详解

    Redis 除了做缓存，还能干很多很多事情：分布式锁、限流、处理请求接口幂等性。。。太多太多了～今天想和小伙伴们聊聊用 Redis 处理接口限流，这也是最近的 项目涉及到这个知识点了，我就拎出来和大家聊聊这个话题
    2022-07-07
  • JAVA算法起步之快速排序实例

    JAVA算法起步之快速排序实例

    这篇文章主要介绍了JAVA算法起步之快速排序实例,需要的朋友可以参考下
    2014-02-02
  • Java实现的图片高质量缩放类定义与用法示例

    Java实现的图片高质量缩放类定义与用法示例

    这篇文章主要介绍了Java实现的图片高质量缩放类定义与用法,涉及java针对图片的运算与转换等相关操作技巧,需要的朋友可以参考下
    2017-11-11
  • Spring boot自定义http反馈状态码详解

    Spring boot自定义http反馈状态码详解

    这篇文章主要给大家介绍了Spring boot自定义http反馈状态码的相关资料，文中介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友们下面跟着小编一起来学习学习吧。
    2017-06-06
  • Mybatis plus通用字段自动填充的示例

    Mybatis plus通用字段自动填充的示例

    这篇文章主要介绍了Mybatis plus通用字段自动填充的示例，帮助大家更好的理解和使用Mybatis，感兴趣的朋友可以了解下
    2021-01-01
  • SpringBoot中支持Https协议的实现

    SpringBoot中支持Https协议的实现

    本文主要介绍了SpringBoot中支持Https协议的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2023-01-01
  • Spring boot热部署devtools过程解析

    Spring boot热部署devtools过程解析

    这篇文章主要介绍了Spring boot热部署devtools过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-07-07
  • Java生成CSV文件实例详解

    Java生成CSV文件实例详解

    这篇文章主要介绍了Java生成CSV文件的方法,很实用的功能,需要的朋友可以参考下
    2014-07-07

最新评论