第五章 单例模式（多方面解析）

最新推荐文章于 2025-11-23 13:11:19 发布
原创 最新推荐文章于 2025-11-23 13:11:19 发布 · 置顶 · 485 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Java #单例模式 #设计模式 #单例破坏

快速导航
单例模式的介绍
一. 1.1 懒汉模式(线程不安全)
     1.2 懒汉模式(线程安全)
二、DoubleCheck 模式（懒汉式）(线程安全)
三、静态内部类创建方式（懒汉式）
四、饿汉式单例模式（线程安全）
五、序列化和反序列化破坏单例模式及解决方式
六、通过反射破坏单例模式及解决方式
七、枚举类单例模式（推荐用法，既能解决序列化、反序列化，也能解决 反射攻击）
八、容器单例模式
九、基于 ThreadLocal 的“单例模式”
单例模式的介绍

定义：保证一个类只有一个实例，并提供一个全局访问点。
类型：创建型。
优点：

在内存中只有一个实例，减少了内存开销（尤其是创建和销毁比较麻烦的时候）
可以避免对资源的多重占用
设置全局访问点，严格限制访问

缺点：

没有接口，扩展困难

重点:

私有构造器
线程安全（非常重要）
延迟加载
序列化和反序列化安全（破坏单例模式）
反射（防止反射攻击）

对比：

单例模式--工厂模式
单例模式--享元模式



一.懒汉模式

1.1 懒汉模式Demo(线程不安全)：

/**
 * @program: adpn-pattern->LazySingleton
 * @description: 懒汉式
 * @author: Jstar
 * @create: 2019-11-22 09:01
 **/
public class LazySingleton {
    private static LazySingleton lazySingleton =null;
    //私有构造器
    private LazySingleton(){}
    public  static LazySingleton getInstance(){
        if(lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}


/**
 * @program: adpn-pattern->LazyThread
 * @description: 多线程
 * @author: Jstar
 * @create: 2019-11-22 09:04
 **/
public class LazyThread extends Thread {
    @Override
    public void run() {
        LazySingleton lazySingleton = LazySingleton.getInstance();
        System.out.println(Thread.currentThread().getName()+" "+lazySingleton);
    }
}

/**
 * @program: adpn-pattern->Test
 * @description: 测试类
 * @author: Jstar
 * @create: 2019-11-22 09:08
 **/
public class Test {
    public static void main(String[] args) {
        LazyThread lazyThread1 = new LazyThread();
        LazyThread lazyThread2 = new LazyThread();
        lazyThread1.start();
        lazyThread2.start();

        System.out.println("test over");
    }
}

执行结果：
在这里插入图片描述
常规模式下，可能不容易看出执行结果是否存在线程安全，我们用多线程的Debug方式来看一下，
首先我们让两个线程都进入 单例模式：
在这里插入图片描述
这时Thread0 获取的 lazySingleton 是 552,
在这里插入图片描述

这时Thread1 获取的 lazySingleton 是 564,
在这里插入图片描述
从Control ,看两个线程获取的 singleton ，也不是一个实例。
在这里插入图片描述
可见，这种模式下，获取的 单例模式是非线程安全的。



1.2 下面我们来改造成线程安全的 懒汉模式：

在这里插入图片描述
我们只在 获取单例模式的getInstance()方法上，添加了 synchronized 关键字，添加后，因方法上有 static 关键字，所以这种同步方法锁住的是整个类。
然后我们再来Debug一下：
在这里插入图片描述
我们可以看出，当一个线程获取锁以后，另一个线程是 处于监视 Monitor 状态。
当Thread0 释放锁后，Thread1获取锁并执行程序。
在这里插入图片描述
因Thread0已经创建实例，所以Thread1,直接取 lazySingleton。
在这里插入图片描述
最后Control 两个线程返回的实例是同一个。
在这里插入图片描述



二、DoubleCheck 模式 （懒汉式）

上代码，其实主要是在单例模式上做了双重检验：

/**
 * @program: adpn-pattern->DoubleCheckSingleton
 * @description: doublecheck单例模式
 * @author: Jstar
 * @create: 2019-11-22 11:42
 **/
public class DoubleCheckSingleton {
    // volatile 防止  DoubleCheckSingleton 创建的时候 重排序
    private static volatile DoubleCheckSingleton doubleCheckSingleton=null;
    private DoubleCheckSingleton(){  }

    public static DoubleCheckSingleton getInstance(){
        if(doubleCheckSingleton==null){
            synchronized (DoubleCheckSingleton.class){
                if(doubleCheckSingleton==null){
                    /** 这里的new 操作执行了以下3个步骤：
                     * 1、分配内存给这个对象
                     * 2、初始化对象
                     * 3、设置 doubleCheckSingleton 指向 新分配的内存地址
                     * 存在的问题：
                     * 有可能会有重排序 的 现象，创建顺序就变成了 1/3/2
                     **/
                    doubleCheckSingleton = new DoubleCheckSingleton();
                }
            }
        }
        return doubleCheckSingleton;
    }
}

有的小伙伴可能会问， doubleCheckSingleton 为什么要设置成 volatile 类型，因为创建对象有可能存在重排序的问题，上述代码已提示，多线程情况下，有可能因为重排序而导致程序报错。
在这里插入图片描述
所以在 doubleCheckSingleton 加上volatile 使 多线程情况下，禁止 创建 doubleCheckSingleton 时候重排序。volatile 修饰的变量会存入系统/共享内存，会使其它cpu缓存该变量的地址无效，无效后，其它cpu缓存又会从共享内存同步数据，多线程情况下都是可见的，

// 多线程模式创建 DoubleCheckSingleton 
public class DoubleCheckThread extends Thread {
    @Override
    public void run() {
        DoubleCheckSingleton doubleCheckSingleton = DoubleCheckSingleton.getInstance();
        System.out.println(doubleCheckSingleton);
    }
}

//测试类
public class DoubleCheckTest {
    public static void main(String[] args) {
        DoubleCheckThread doubleCheckThread1 = new DoubleCheckThread();
        DoubleCheckThread doubleCheckThread2 = new DoubleCheckThread();
        doubleCheckThread1.start();
        doubleCheckThread2.start();

        System.out.println("test over");
    }
}

现在我们让两个线程同时进入， if(doubleCheckSingleton==null){} 内，
在这里插入图片描述

当Thread1 释放锁后，Thread0 获取锁：
在这里插入图片描述

我们来看执行结果：
在这里插入图片描述
结果：两个线程获取的是同一个对象，DoubleCheck 此模式是线程安全的。



三、静态内部类创建方式（懒汉式）

上述的DoubleCheck 方式主要是使用，控制创建类时，禁止重排序，来实现创建单例模式时，实现的线程安全。
下面我们来用另一种方式，来解决重排序的问题，思想是：即使有重排序问题，但是我们使 会产生重排序的类，对其它线程不可见。

下面我们来coding,来演示：

/**
 * @program: adpn-pattern->StaticInnerClassSingleton
 * @description: 单例静态内部类
 * @author: Jstar
 * @create: 2019-11-23 09:59
 **/
public class StaticInnerClassSingleton {
    // 防止被 new,构造器必须设成 私有属性
    private  StaticInnerClassSingleton(){}
    /**
     **静态内部类：jvm在创建静态内部类的时候，会给类加锁，这样其它线程就无法看到静态内部类 创建过程
     * 在本例中：在创建 InnerClass 时，InnerClass 内 StaticInnerClassSingleton 的创建 不会被其它线程看到，
     *      即使创建 StaticInnerClassSingleton 有重排序的问题，StaticInnerClassSingleton 对其它线程来说也是一个完整的过程
     *      所以这种创建方式是线程安全的
     **/
    private static class InnerClass{
        private static StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
    }
    public static StaticInnerClassSingleton getInstance(){
        // 此处会创建静态内部类 InnerClass
        return InnerClass.staticInnerClassSingleton;
  

//多线程获取单例对象
public class StaticInnerThread implements Runnable{
    @Override
    public void run() {
        //
        StaticInnerClassSingleton instance = StaticInnerClassSingleton.getInstance();
        System.out.println(Thread.currentThread().getName()+"  "+instance);
    }
}

//测试类
public class StaticInnerTest {
    public static void main(String[] args) {
        StaticInnerThread staticInnerThread = new StaticInnerThread();
        Thread t1 = new Thread(staticInnerThread);
        Thread t2 = new Thread(staticInnerThread);
        t1.start();
        t2.start();
    }
}

如上述代码，StaticInnerClassSingleton 使用静态内部类实现线程安全，已在 StaticInnerClassSingleton 类中做说明，我们来看一下运行结果：
在这里插入图片描述
此种方式创建的是一个实例。



四、饿汉式单例模式（线程安全）
/**
 * @program: adpn-pattern->HungrySinglon
 * @description: 饿汉式单例模式
 * @author: Jstar
 * @create: 2019-11-23 11:12
 **/
public class HungrySinglon {
    private final static HungrySinglon hungrySinglon=new HungrySinglon();
    private HungrySinglon(){ }
    public HungrySinglon getInstance(){
        return hungrySinglon;
    }
}

说明：饿汉式单例模式在类初始化的时候就创建好了，所以在调用的时候是线程安全的。

经过测试，结果是同一个对象：
在这里插入图片描述



五、序列化和反序列化破坏单例模式及解决方式

本次测试我们使用了 静态内部类的创建方式测试：

/**
 * @program: adpn-pattern->SerializeDestroyTest
 * @description: 序列化和反序列化方式破坏单例模式
 * @author: Jstar
 * @create: 2019-11-23 11:41
 **/
public class SerializeDestroyTest implements Serializable {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        StaticInnerClassSingleton instance = StaticInnerClassSingleton.getInstance();
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("staticInner_singleton"));
        // 将StaticInnerClassSingleton 写出去
        outputStream.writeObject(instance);

        File file=new File("staticInner_singleton");
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(file));
        // 将StaticInnerClassSingleton 重新读进来
        StaticInnerClassSingleton newInstance = (StaticInnerClassSingleton) inputStream.readObject();
        //看两个对象是否是同一个
        System.out.println("原对象 instance："+instance);
        System.out.println("新对象 newInstance："+newInstance);
    }
}

来看测试结果：
在这里插入图片描述
可以看出，序列化前后两个类不是同一个。序列化和反序列化破坏了 单例类的问题。
我们来看一下，为什么，序列化破坏了单例模式，
按图示方向进入：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
因为类 序列化实现了 serializable，所以 desc.isInstantiable() 返回的true

在这里插入图片描述
在这里 obj 被赋值的是 反射的一个新类，所以，序列化后单例模式 得到了两个不同的实例。

那我们有办法来解决这个问题吗，答案是有的：
我们只需在单例类加入readResolve()方法即可，如图：
在这里插入图片描述
加入readResolve()方法，我们来看执行结果：
在这里插入图片描述
两个线程获取的是同一个对象，神奇不神奇。那为什么 inputStream.readObject() 时，实现内 desc.newInstance() 新建了实例，返回的两个对象相同。
其实是因为，我们单例类加入了 readResolve()方法 ，被 inputStream.readObject() 实现内调用执行，虽然内部 newInstance() ，但最后返回的是 return InnerClass.staticInnerClassSingleton; 所以还是一个实例。
具体可看：
在这里插入图片描述
在这里插入图片描述
到这里就一目了然了，实现里 因单例类 实现了serializable，所以执行了 readResolve()方法，将 方法内的InnerClass.staticInnerClassSingleton 返回，还是原实例。



六、通过反射破坏单例模式及解决方式

6.1、首先 我们来用最近的饿汉模式来演示

/**
 * @program: adpn-pattern->DeclareInstance
 * @description: 通过反射破坏单例对象
 * @author: Jstar
 * @create: 2019-11-23 16:10
 **/
public class DeclareInstance {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        HungrySinglon instance = HungrySinglon.getInstance();

        Class<HungrySinglon> hungrySinglonClass = HungrySinglon.class;
        Constructor c = hungrySinglonClass.getDeclaredConstructor();
        c.setAccessible(true);
        HungrySinglon newInstance= (HungrySinglon) c.newInstance();

        System.out.println("正常获取单例对象："+instance);
        System.out.println("反射获取单例对象："+ newInstance);
        System.out.println(instance==newInstance);
    }
}

结果： 不是同一个实例对象
在这里插入图片描述
那我们来解决：就是在HungrySinglon 的私有构造器中加条件判断，如果这个实例已经被创建了，不不允许调用私有构造器。
改造如下：

/**
 * @program: adpn-pattern->HungrySinglon
 * @description: 饿汉式单例模式
 * @author: Jstar
 * @create: 2019-11-23 11:12
 **/
public class HungrySinglon implements Serializable {
    private final static HungrySinglon hungrySinglon=new HungrySinglon();
    private HungrySinglon(){
        if(hungrySinglon!=null){
            throw new RuntimeException("不允许使用私有构造器创建对象");
        }
    }
    public static HungrySinglon getInstance(){
        return hungrySinglon;
    }
    public Object  readResolve(){
        return hungrySinglon;
    }
}

不论正常获取单例先执行还是后执行，都是 不允许使用私有构造器创建对象，因为类加载的时候，HungrySinglon 实例已经创建了。
在这里插入图片描述

6.2 匿名内部类方式的解决方式和 饿汉模式相同，因为在类初始化的时候已经创建了类实例，在这里就不演示了，读者可以自行尝试一下

6.3、懒汉模式
懒汉模式是无法解决反射攻击的，因为，类加载的时候，没有被实例化，不论在私有构造器加如何复杂的判断还是加全局属性作为 Flag 做标记判断，都是可以被反射获取并更改属性的，所以不存在解决的问题。如果在懒汉模式有解决 反射攻击的方法，你可以告诉小编呀，，



七、枚举类单例模式（推荐用法，既能解决序列化、反序列化，也能解决 反射攻击）
/**
 * @program: adpn-pattern->EnumInstance
 * @description: 枚举类单例模式
 * @author: Jstar
 * @create: 2019-11-23 17:22
 **/
public enum  EnumInstance {
    INSTANCE;
    public Object data;
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public EnumInstance getInstance(){
        return INSTANCE;
    }
}

写个序列化测试类：

/**
 * @program: adpn-pattern->EnumTest
 * @description: 枚举类单例测试
 * @author: Jstar
 * @create: 2019-11-23 17:39
 **/
public class EnumTest {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //测试序列化和反序列化
        EnumInstance instance = EnumInstance.INSTANCE;
        instance.setData(new Object());
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("enum_singleton"));
        // 将 EnumInstance 写出去
        outputStream.writeObject(instance);
        File file=new File("enum_singleton");
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(file));
        // 将 EnumInstance 重新读进来
        EnumInstance newInstance = (EnumInstance) inputStream.readObject();
        //看两个对象是否是同一个
        System.out.println("   原对象 instance："+ instance);
        System.out.println("新对象 newInstance："+newInstance);
        System.out.println("   原对象 instance data："+ instance.getData());
        System.out.println("新对象 newInstance data："+newInstance.getData());
    }
}

来看执行结果：
在这里插入图片描述
序列化和反序列对 枚举单例模式没影响。
再来看反射对枚举单例模式的影响：

运行测试类时，报 NoSuchMethodException，execuse me ??
在这里插入图片描述
那我们反编译来看一下，生成的 EnumInstance.class，我在反编译的结果上加了注释：

package com.jstar.adpnpattern.design.factory.creation.singleton;

public final class EnumInstance extends Enum
{

    public static EnumInstance[] values()
    {
        return (EnumInstance[])$VALUES.clone();
    }

    public static EnumInstance valueOf(String name)
    {
        return (EnumInstance)Enum.valueOf(com/jstar/adpnpattern/design/factory/creation/singleton/EnumInstance, name);
    }
    // 只有一个构造器，且是有参的，那我们待会反射的时候就传 two 个参数，嗯
    private EnumInstance(String s, int i)
    {
        super(s, i);
    }

    public Object getData()
    {
        return data;
    }

    public void setData(Object data)
    {
        this.data = data;
    }

    public EnumInstance getInstance()
    {
        return INSTANCE;
    }
    // EnumInstance 已声明为 static final 类型
    public static final EnumInstance INSTANCE;
    public Object data;
    private static final EnumInstance $VALUES[];
    // 构造代码块，类初始化的时候即执行，类似饿汉式
    static 
    {
        INSTANCE = new EnumInstance("INSTANCE", 0);
        $VALUES = (new EnumInstance[] {
            INSTANCE
        });
    }
}

构造器传参，运行之后，返回 IllegalArgumentException ，小编是没办法了。
看来反射也没破坏枚举的单例模式。
在这里插入图片描述

另外，我们在 INSTANCE 中添加以下代码，反编译看class文件到底做了什么：
在这里插入图片描述
反编译后：
在这里插入图片描述
INSTANCE 中的testPrint() 在类初始化时即构建了。



八、容器单例模式

介绍：容器类单例模式就是把多种单例模式放到同一个容器中，统一管理。
下面我们用代码来演示：

/**
 * @program: adpn-pattern->ContainerSingleton
 * @description: 容器单例类
 * @author: Jstar
 * @create: 2019-11-23 20:36
 **/
public class ContainerSingleton {
    private ContainerSingleton(){ }
    private static Map<String,Object> singletonMap=new HashMap<String,Object>();
    public static void putInstance(String key,Object value){
        if(StringUtils.isNotBlank(key) && value!=null){
            if(!singletonMap.containsKey(key)){
                singletonMap.put(key, value);
            }
        }
    }
    public static Object getInstance(String key){
        return singletonMap.get(key);
    }
}

/**
 * @program: adpn-pattern->ContainerThread
 * @description: 线程类
 * @author: Jstar
 * @create: 2019-11-23 20:42
 **/
public class ContainerThread implements Runnable {
    @Override
    public void run() {
        ContainerSingleton.putInstance("key",new Object());
        Object obj= ContainerSingleton.getInstance("key");
        System.out.println(Thread.currentThread().getName()+"  "+obj);
    }
}


/**
 * @program: adpn-pattern->ContainerTest
 * @description: 测试类
 * @author: Jstar
 * @create: 2019-11-23 20:45
 **/
public class ContainerTest {
    public static void main(String[] args) {
        ContainerThread containerThread = new ContainerThread();
        Thread t1 = new Thread(containerThread);
        Thread t2 = new Thread(containerThread);
        t1.start();
        t2.start();
        System.out.println("test over");
    }
}

我们用Debug 模式来看一下，这种模式是否是线程安全的。

Thread0 现在地址值 是 553
在这里插入图片描述
切换到 Thread1,Thread1的地址值是 557
在这里插入图片描述
至少从目前来看，容器单例模式使用的不是一个对象。最后我们来看执行结果。
在这里插入图片描述
从执行结果来看，容器类单例模式确实不是线程安全的。那我们可以改造一下。
把 容器 HashMap 换成 Hashtable。 我们再按刚才的方式测试一下。
Thread0 :
在这里插入图片描述
Thread1:
在这里插入图片描述
我们来看最后的执行结果：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
由此可见，此种方式，即使 Hashtable 的containsKey() 和 put() 方法都被 synchronized 修饰了，但在执行put()方法时，containsKey 此时的锁已经释放，导致 put 了两个对象。

所以，小编认为，容器类单例模式也是非线程安全的，我们要根据实际业务中的场景使用单例模式。
可以选择 HashMap、ConcurrentHashMap，不建议使用 Hashtable 。



九、基于 ThreadLocal 的“单例模式”

上代码

/**
 * @program: adpn-pattern->ThreadLocalSingleton
 * @description: 基于ThreadLocal单例模式
 * @author: Jstar
 * @create: 2019-11-23 21:33
 **/
public class ThreadLocalSingleton {
    private ThreadLocalSingleton() {
    }
   private static ThreadLocal<ThreadLocalSingleton> threadLocalSingleton=new ThreadLocal<ThreadLocalSingleton>(){
        @Override
        protected ThreadLocalSingleton initialValue() {
            return new ThreadLocalSingleton();
        }
    };
    public static ThreadLocalSingleton getInstance(){
        return threadLocalSingleton.get();
    }
}

//多线程
public class ThreadLocalThread implements Runnable {
    @Override
    public void run() {
        ThreadLocalSingleton instance = ThreadLocalSingleton.getInstance();
        System.out.println(Thread.currentThread().getName()+"  "+instance);
    }
}

//测试类
public class ThreadLocalTest {
    public static void main(String[] args) {
        ThreadLocalThread threadLocalThread = new ThreadLocalThread();
        Thread t1 = new Thread(threadLocalThread);
        Thread t2 = new Thread(threadLocalThread);
        t1.start();
        t2.start();
        System.out.println("主线程创建的单例对象为："+ThreadLocalSingleton.getInstance());
        System.out.println("主线程创建的单例对象为："+ThreadLocalSingleton.getInstance());
        System.out.println("主线程创建的单例对象为："+ThreadLocalSingleton.getInstance());
        System.out.println("test over");
    }
}

我们直接来看运行结果吧
在这里插入图片描述
我们可以看出 主线程创建的都是一个对象，每个线程创建的单例对象都不同。其实，这主要是基于 ThreadLocal 对象，ThreadLocal 会把每个线程隔离开来，每个线程各自创建一类对象，互不影响，这是一种以空间换时间的做法。

好了，单例模式，我们暂时就讲这么多了，多谢大家看到这，希望大家还是多总结，好记性不如烂笔头。实际业务中应用哪种单例模式，还需要理解每一种应用，使用相应的创建单例的方式。

Java 单例模式：深度解析与应用
Java小吕布的博客
11-29 1961
Java 单例模式是一种极为实用的设计模式，通过限制类的实例化次数为一次，并提供全局访问点，在资源管理、配置信息处理、线程池和日志记录等众多场景中都有着广泛的应用。本文详细介绍了饿汉式、懒汉式、双重检查锁定、静态内部类和枚举等多种单例模式的实现方式，深入分析了它们的线程安全性、懒汉式与饿汉式的区别以及应用场景。在实际开发过程中，开发人员需要依据具体的需求和场景，仔细权衡资源占用、线程安全和性能等多方面因素，从而选择最为合适的单例模式实现方式，以此构建高效、可靠的 Java 应用程序。
单例设计模式-容器单例
Leon_Jinhai_Sun的博客
06-03 727
基于容器的单例模式,与享元模式类似,我们也可以使用容器单例模式,来管理多个单例对象,那我们通过coding,debug, 讲解的方式来学习一下 package com.learn.design.pattern.creational.singleton; import org.apache.commons.lang3.StringUtils; import java.util.HashM...
创建型设计模式之单例模式
积跬步，至千里。
08-12 439
单例模式属于创建型模式。它保证一个对象在JVM中只能有一个实例，减少内存开销，避免对资源的多重占用。
单例设计模式之容器单例
智欣约的博客
06-30 1795
一、容器单例，就是指管理单例对象的容器。 二、代码呈上 package com.zxl.design.zxl.design.pattern.singleton; import com.sun.deploy.util.StringUtils; import java.util.HashMap; import java.util.Map; /** * Created by Adminis...
Java：单例模式详解
小小张自由—>张有博
09-02 1811
Java：单例模式详解，懒汉饿汉、枚举式、容器式原理、代码完整解释。
java6种单例模式(容器时单例，枚举式单例)
qq_45309010的博客
12-24 700
文章目录单例模式介绍1.饿汉式2.1 饱汉式/懒汉式_12.2 饱汉式/懒汉式_23.双重检测锁4.静态内部类防止暴力反射创建对象5.容器式单例6.枚举式单例 单例模式介绍 单例模式是创造型设计模式中的一种，目的是保证再一个jvm中只有一个对象 1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。 2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。 3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，
6、单例模式的深度解析与实现
chair的专栏
06-10 154
本文深入探讨了单例模式的实现方式，重点介绍了如何通过策略模式来管理单例对象的生命周期和线程安全。文章详细分析了单例模式的特点、挑战以及各种实现方法，并提供了完整的代码示例。同时，讨论了单例模式在多线程环境下的线程安全问题及解决方案，如双重检查锁定模式和内存屏障等。最后，给出了单例模式的应用场景、优缺点及未来发展方向，帮助读者更好地理解和使用单例模式。
7、Scala设计模式：单例模式与标记特质模式解析
最新发布
rust6ferris的博客
11-23 9
本文深入解析了Scala中的单例模式与标记特质模式。单例模式通过object关键字或结合工厂与代理模式，确保类型唯一实例并控制其生命周期；标记特质模式则利用无方法的特质为类型添加语义标识，提升类型系统的表达能力。文章对比了两种模式的核心目的、适用场景及优缺点，并结合日志管理、权限控制等实际案例，展示了它们在分布式系统、用户权限、支付策略等场景中的应用。同时探讨了模式间的组合使用，如单例与工厂、标记特质与策略模式的结合，帮助开发者构建高内聚、低耦合、可维护的Scala应用。
单例模式深度解析及常见错误
文章提及阅读后的感受：“一直觉得单例模式自己掌握的挺好，但是看完这篇文章后汗颜了”，可能说明该读者在阅读这篇文章后，发现了自己在理解和应用单例模式方面还有所欠缺，或许是对某些单例模式的细节和应用场合有...
12、单例模式（Singleton）全面解析
game4的博客
11-02 14
本文全面解析了单例模式（Singleton）的设计原理、使用条件、结构元素、实现方式及其在实际开发中的应用。文章详细介绍了如何确保类的唯一实例并提供全局访问点，对比了不同创建型模式在图形编辑器平台中的优劣，并提供了C++和Smalltalk的实现示例。同时探讨了单例模式的线程安全、子类扩展、注册表机制以及与其他设计模式的结合使用，帮助开发者提升系统的灵活性与可维护性。
设计模式 五种不同的单例模式 懒汉式 饿汉式 枚举单例 容器化单例(Spring单例源码分析) 线程单例
李虹柏的博客
12-17 1605
优点：执行效率高，性能高，没有任何的锁缺点：某些情况下，可能会造成内存浪费。
通过容器实现单例模式
jl19960421的博客
03-21 501
今天再为大家提供一个实现单例模式的方法，注册式单例模式。 首先创建一个容器类，用来盛放创建的单例。 public class ContainerSingleton2 { private ContainerSingleton2(){} private static Map<String,Object> ioc=new ConcurrentHashMap<>(); public static Object getInstance(String clas
C05 单例模式 容器单例
乌鲁木齐001号程序员
03-05 188
概述 容器单例的思路是这样的，维护一个Map，把单例的实例都存放进该Map中，用的时候只从该Map中取，试图实现单例；但这种思路有局限性，Map中存的单例对象是可以被更新掉的，如果两次取的间隔，发生了单例对象的更新，就会取到2个不同的对象，破坏了单例性； 如果程序中单例类很多，可以考虑用一个容器管理起来； 容器单例实现 很容易使用多线程Debug从容...
java设计模式——容器单例
小志的博客
06-05 589
目录一、定义一个容器单例二、多线程测试容器单例：三、结论 一、定义一个容器单例 package com.rf.designPatterns.singleton.containerSingleton; import org.apache.commons.lang.StringUtils; import java.util.HashMap; import java.util.Hashtable; import java.util.Map; import java.util.concurrent.Concurr
IOC容器单例与多例
热门推荐
最怕一生碌碌无为，还安慰自己平凡可贵
03-24 6万+
IOC默认使用单例模式创建Bean，默认在spring容器启动时会自动创建对象。 @Lazy 懒加载：容器启动不创建对象，而在第一次使用Bean时创建对象，并初始化。 @Configuration public class MainConfig2 { @Lazy @Bean public Person person() { System.out.println("创建------...
容器实现单例模式
ていひんのブログ
11-18 431
  容器单例模式使用的是HushMap，作为缓存使用，线程不安全，但是易于管理，可在合适的场景下使用，具体实现如下： public class ContainerSingleton { private ContainerSingleton(){} private static Map<String,Object> singletonMap = new HashMap&...
Spring（六）核心容器 - 注册单例 Bean 实例、SingletonBeanRegistry 简介
qq_36277052的博客
02-13 344
前言 上篇文章我们对注册 Bean 的核心类 BeanDefinitionRegistry 进行了讨论，这里的注册 Bean 是指保存 Bean 的相关信息，也就是将 Bean 定义成 BeanDefinition，然后放入容器中。除此之外，Spring 还提供一个统一操作单例 Bean 实例的类 SingletonBeanRegistry，通过该类可直接对单例 Bean 的实例进行存储、注册等操...
Java设计模式之容器单例模式
Crook的专栏
06-14 1725
Java设计模式之容器单例模式 public class ContainerSingleton { private ContainerSingleton(){} private static Map<String , Object> map=new HashMap<>(); public static void putInstance(Str...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值