手撸设计模式之-单例模式

最新推荐文章于 2024-06-05 10:12:36 发布
最新推荐文章于 2024-06-05 10:12:36 发布
阅读量855 收藏 1
点赞数 1
分类专栏： 设计模式 文章标签： 单例模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_21077715/article/details/113809709
版权

手撸设计模式之-单例模式

单例模式应用场景

单例模式（Singleton Pattern）是指确保一个类在单线程和多线程情况下绝对只有一个实例，并且提供一个全局的访问点。单例模式是创建型模式。单例模式在现实生活中也很广泛。比如：公司CEO、CTO、都是单已存在的，是常见的单例模式。在J2EE标准中，ServletContext、ServletContextConfig等。在Spring框架应用中ApplicationContext，数据库的连接池都是单例模式。

饿汉式单例

  • 介绍
    我们先观察一下单例模式的类图如下：
    在这里插入图片描述

饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，在线程还没有出现以前就是实例化了，不可能存在线程访问安全问题。

  • 优点：

没有加任何的锁、执行效率比较高，在用户体验上来考虑，比懒汉式更好。

  • 缺点：

类加载的时候就初始化，不管用户是否需要使用都占着空间，比较浪费内存，有着占着茅坑不拉屎的蕴意。

  • 注意：

在SpringIOC容器中ApplicationContext本身就是典型的饿汉式单例模式。

饿汉式单例-代码案例

/**
 * Description: 饿汉式单例模式
 * <br/>
 * HungrySimpleSingleton
 *
 * @author laiql
 * @date 2021/1/17 2:25 下午
 */
public class HungrySimpleSingleton {

    private static final HungrySimpleSingleton instance = new HungrySimpleSingleton();

    private HungrySimpleSingleton() {}
    
    public static HungrySimpleSingleton getInstance() {
        return instance;
    }
}

饿汉式静态代码块单例-代码案例

/**
 * Description: 静态饿汉式单例模式
 * <br/>
 * HungrySaticSingleton
 *
 * @author laiql
 * @date 2021/1/17 2:25 下午
 */
public class HungrySaticSingleton {
    private static HungrySaticSingleton instance;
    
    private HungrySaticSingleton() {}
    static {
        instance = new HungrySaticSingleton();
    }
    public static HungrySaticSingleton getInstance() {
        return instance;
    }
}

以上两种写法都很简单，也很好理解，但是饿汉式适用单例对象较少的情况，更优的写法请看下面介绍。

懒汉式单例

  • 介绍

懒汉式单例模式的特点：只有被外部类调用内部类的才会加载，称为懒汉式单例模式。

懒汉式单例模式-代码案例

/**
 * Description: 懒汉式简单-单例模式
 * <br/>
 * LazySimpleSingleton
 *
 * @author laiql
 * @date 2021/1/17 2:28 下午
 */
public class LazySimpleSingleton {

    private static LazySimpleSingleton simpleSingleton = null;
    
    private LazySimpleSingleton() {}
    /**
     * 存在线程安全问题
     * 在方法加锁：{
     *     隐患1：会导致整个类的所有方法被锁死。
     *     隐患2：加锁会导致性能降低。
     * }
     * @return
     */
    public static LazySimpleSingleton getInstance() {
        if (simpleSingleton == null) {
            simpleSingleton = new LazySimpleSingleton();
        }
        return simpleSingleton;
    }
}

注意⚠️

懒汉式单例模式会存在线程不安全，再并发环境下一定纪几率出现创建两个不同的的对象结果，意味着懒汉式单例模式存在多线程不安全问题。
解决方案：
就是在获取实例上加上synchronized关键字，问题解决，但是引出新的问题。比如 因为在方法加了synchronized关键字会导致整个类被锁，同时用synchronized加锁，在线程数量比较多的时候，如果CPU分配压力上升，会导致大批量的线程出现堵塞，从而导致程序运行性能大幅度下降。所以该方法不是最优解决方案，更优写法请看下面介绍。

双重检验锁单例

  • 介绍：

双重检验锁，就是在在原来基础上进行优化，对创建实例对象过程中增加多次检验，只有检验通过才能创建实例对象，这样即兼顾了线程安全有提升了程序性能问题。

懒汉式双重检验锁单例模式-代码案例

/**
 * Description: 双重检验锁单利模式
 * <br/>
 * DoubleCheckLockSingleton
 *
 * @author laiql
 * @date 2021/2/7 8:48 上午
 */
public class DoubleCheckLockSingleton {

    private volatile static DoubleCheckLockSingleton instance;

    private DoubleCheckLockSingleton() {
    }

    /**
     * 可能出现的问题：
     * 1：指令重排会导致线程不安全
     * {
     * 1.分配内存给这个对象
     * 2.初始化对象
     * 3.设置lazy指向刚分配的内存地址
     * 4.初次访问对象
     * }
     * 解决方案：
     * 在静态常量增加 volatile关键字防止指令重排
     *
     * @return
     */
    public static DoubleCheckLockSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckLockSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckLockSingleton();
                }
            }
        }
        return instance;
    }
}

注意⚠️

双重检验锁单例模式可能出现的问题：指令重排
因为代码编译完成被加载进JVM虚拟机的时候字节码会进行指令重排，所以我们需要增加防止指令重排关键字volatile，可以解决指令重排问题。

Java机制单例模式（性能最优）

  • 介绍

这里利用Java中内部类加载机制实现单例模式，默认内部类不加载，只有使用具体Class类的时候会先进行内部类初始化，实现单例模式，具体实现如下：

Java机制静态内部类-代码案例实现

/**
 * Description: 静态内部类实现单例模式
 * <br/>
 * LazyInnerSingleton
 *
 * @author laiql
 * @date 2021/2/14 7:25 下午
 */
public class LazyInnerSingleton {

    private LazyInnerSingleton() {}

    /**
     * 对外部提供调用实例
     * 该方法不允许被重写
     *
     * @return
     */
    public final static LazyInnerSingleton getInstance() {
        return LazyHolder.LAZY;
    }

    /**
     * 默认不加载
     */
    private static class LazyHolder {
        public static final LazyInnerSingleton LAZY = new LazyInnerSingleton();
    }
}

注意⚠️

好处：这种形式兼顾了饿汉式的内存浪得问题，也兼顾synchronized加锁性能问题，内部类一定要在方法调用前初始化，巧妙的避免了线程问题。
坏处：会导致反射破坏单例模式和序列化破坏单例情况。

反射破坏单例模式-代码案例

public class Test {
    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
        //通过字节码创建对象
        Class<LazyInnerSingleton> lazyInnerSingletonClass = LazyInnerSingleton.class;
        //通过反射拿到私有的构造方法
        Constructor<LazyInnerSingleton> declaredConstructor = lazyInnerSingletonClass.getDeclaredConstructor(null);
        //设置访问权限
        declaredConstructor.setAccessible(true);
        LazyInnerSingleton obj1 = LazyInnerSingleton.getInstance();
        LazyInnerSingleton obj2 = declaredConstructor.newInstance();
        System.out.println(obj1 == obj2); //false
    }
}

优化方案

经过上述案例的复现，两次创建的对象都是不一样的，破坏了单例原则，解决方案，我们在构造方法做一下限制，如果通过反射强制访问，直接抛出异常。
优化过后的代码如下：

/**
 * Description: 静态内部类实现单例模式
 * <br/>
 * LazyInnerSingleton
 *
 * @author laiql
 * @date 2021/2/14 7:25 下午
 */
public class LazyInnerSingleton {

    /**
     * 增加构造方法限制，防止非法创建
     */
    private LazyInnerSingleton() {
        if (LazyHolder.LAZY != null) {
            throw new RuntimeException("非法创建对象！");
        }
    }

    /**
     * 对外部提供调用实例
     * 该方法不允许被重写
     *
     * @return
     */
    public final static LazyInnerSingleton getInstance() {
        return LazyHolder.LAZY;
    }
    /**
     * 默认不加载
     */
    private static class LazyHolder {
        public static final LazyInnerSingleton LAZY = new LazyInnerSingleton();
    }
}

反序列化破坏单利模式

当我们创建完成一个单例对象后，有时候需要将对象序列化写入到磁盘，下次使用时候再次从磁盘中读取到对象，反序列化转化成内存对象，反序列化后的对象会重新分配内存，即就是重新创建，那如果序列化的目标对象为单例对象，就违背了单例模式的原则，相当于破坏了单例模式。

反序列化破坏单例模式-代码案例

/**
 * Description: 反序列化破坏单例模式案例
 * <br/>
 * SerializableDestroySingleton
 *
 * @author laiql
 * @date 2021/2/14 8:09 下午
 */
public class SerializableDestroySingleton implements Serializable {

    private SerializableDestroySingleton() {
    }

    private final static SerializableDestroySingleton INSTANCE = new SerializableDestroySingleton();

    public static SerializableDestroySingleton getInstance() {
        return INSTANCE;
    }
}

测试案例

public class TestDemo {

    public static void main(String[] args) {
        SerializableDestroySingleton obj1 = null;
        SerializableDestroySingleton obj2 = SerializableDestroySingleton.getInstance();
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream("SerializableDestroySingleton.class");
            ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
            outputStream.writeObject(obj2);
            outputStream.flush();
            outputStream.close();

            FileInputStream fileInputStream = new FileInputStream("SerializableDestroySingleton.class");
            ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
            obj1 = (SerializableDestroySingleton) inputStream.readObject();
            inputStream.close();
            System.out.println(obj1);
            System.out.println(obj2);
            System.out.println(obj1 == obj2);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出结果：
在这里插入图片描述
解决方案：

从上面运行结果中，可以看出，反序列化后的对象和手动创建的对象是不一致的，实例化两次违背了单例模式的原则，那么，我们如何保证反序列化的情况也能实现单例模式？其实很简单，我们只需要在在单例对象增加readResolve()方法即可。来看代码优化：

package com.laiql.dp.singleton.serializable;

import java.io.Serializable;

/**
 * Description: 反序列化破坏单例模式案例
 * <br/>
 * SerializableDestroySingleton
 *
 * @author laiql
 * @date 2021/2/14 8:09 下午
 */
public class SerializableDestroySingleton implements Serializable {

    private SerializableDestroySingleton() {
    }

    private final static SerializableDestroySingleton INSTANCE = new SerializableDestroySingleton();

    public static SerializableDestroySingleton getInstance() {
        return INSTANCE;
    }

    /**
     * 增加该方法防止序列化破坏单例模式
     * @return
     */
    private Object readResolve() {
        return INSTANCE;
    }
}

运行结果：
在这里插入图片描述
有关readResolve()方法解释：

我们一起来看一下JDK源码，为什么重写readResolve()方法可以实现反序列化单例模式呢！
请看这篇文章：https://blog.csdn.net/u011499747/article/details/50982956

注册单例

  • 介绍

注册式单例模式又称为登记式单利，就是将每个实例都登记到某一个地方，使用唯一的标识获取实例，注册式单利有两种写法：一种为容器缓存，一种为枚举登记。

枚举登记单例模式-代码案例

public enum EnumSingleton {
    /**
     * 实例
     */
    INSTANCE;

    private Object data;

    public Object getData() {
        return data;
    }

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

    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

测试代码

public class TestRegistryDemo {

    public static void main(String[] args) {
        EnumSingleton obj1 = null;
        EnumSingleton obj2 = EnumSingleton.getInstance();
        //设置对象
        obj2.setData(new Object());
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream("EnumSingleton.class");
            ObjectOutputStream outputStream = new ObjectOutputStream(fileOutputStream);
            outputStream.writeObject(obj2);
            outputStream.flush();
            outputStream.close();

            FileInputStream fileInputStream = new FileInputStream("EnumSingleton.class");
            ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
            obj1 = (EnumSingleton) inputStream.readObject();
            inputStream.close();
            System.out.println(obj1.getData());
            System.out.println(obj2.getData());
            System.out.println(obj1.getData() == obj2.getData());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意⚠️

在枚举登记模式中，我们可以发现我们没有做任何特别处理，结果和我们预期的一样，请看下面字节码解释：
在这里插入图片描述
原来，枚举单例在静态代码块中对INSTANCE赋值，是饿汉式的实现。至此，我们还可以试想一下，序列化能否破坏枚举单例，请看下面源码实现：
在这里插入图片描述
具体可以看readEnum()方法实现：
在这里插入图片描述
经过源码翻译，枚举登记模式不会被序列化破坏。我们在试想一下，会不会被反射破坏呢？
经过笔者测试是不会被破坏的。

测试案例：

public class TestRegistryDemo1 {

    public static void main(String[] args) {
        try {
            Class<EnumSingleton> enumSingletonClass = EnumSingleton.class;
            Constructor<EnumSingleton> declaredConstructor = enumSingletonClass.getDeclaredConstructor(null);
            declaredConstructor.setAccessible(true);
            EnumSingleton enumSingleton = declaredConstructor.newInstance();
            System.out.println(enumSingleton);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出结果：
在这里插入图片描述
容器缓存式-单例模式

  • 介绍：

容器式写法适用于创建实例非常多的请看，便于管理，但是，是在非线程安全的。

代码案例如下：

/**
 * Description: 注册式容器缓存单例模式
 * <br/>
 * ContainerSingleton
 *
 * @author laiql
 * @date 2021/2/14 9:31 下午
 */
public class ContainerSingleton {
    private static Map<String, Object> ioc = new ConcurrentHashMap<>();

    public static Object getBean(String className) {
        synchronized (ioc) {
            if (!ioc.containsKey(className)) {
                Object obj = null;
                try {
                    obj = Class.forName(className).newInstance();
                    ioc.put(className, obj);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return obj;
            } else {
                return ioc.get(className);
            }
        }
    }
}

注意⚠️

我们也还可以看一下Spring中的容器单例实现代码实现：
在这里插入图片描述

ThreadLocal 线程单例

  • 介绍：

在线程中也存在单例实现的如TreadLocal，TreadLocal不能保证其创建的对着的全局唯一，但是能保证单个线程中式唯一的，天生的线程安全。

案例代码：

/**
 * Description: ThreadLocal单例模式案例
 * <br/>
 * ThreadLocalSingleton
 * 
 * @author laiql
 * @date 2021/2/14 9:41 下午
 */
public class ThreadLocalSingleton {
    
    private static final ThreadLocal<ThreadLocalSingleton> threadLocalInstance = ThreadLocal.withInitial(() -> new ThreadLocalSingleton());

    private ThreadLocalSingleton() {
    }
    public static ThreadLocalSingleton getInstance() {
        return threadLocalInstance.get();
    }
}

案例解释：
在主线程 main 中无论调用多少次，获取到的实例都是同一个，都在两个子线程中分别获取到了不同的实例。那么 ThreadLocal 是如果实现这样的效果的呢？我们知道上面的单例模式为了达到线程安全的目的，给方法上锁，以时间换空间。ThreadLocal 将所有的对象全部放在 ThreadLocalMap 中，为每个线程都提供一个对象，实际上是以空间换时间来实现线程间隔离的。

总结

单例模式在我们日常开发也是频繁常见，单例模式可以保证内存里只有一个实例，减少了内存开销；可以避免对资源的多重占用。

Coding工匠
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
设计模式 之 单例模式
weixin_45074185的博客
03-31 351
设计模式 之 单例模式 在某些特定的情况下，例如 线程池，内存池的管理类，要求只能创建一个实例的时候所使用的设计模式就是单例模式。我们可以通过将构造函数私有化的方法来实现单例模式。本文着重于多线程下的单例模式。 #include<stdio.h> #include<mutex> using namespace std; mutex m; class Singleton { ...
设计模式之---单例模式
m0_69424697的博客
06-07 308
注意答案的重点标黑了。对于单例模式，掌握，我下面这几点就很棒棒。小伙伴们有兴趣想了解内容和更多相关学习资料的请点赞收藏+评论转发+关注我，后面会有很多干货。我有一些面试题、架构、设计类资料可以说是程序员面试必备！ 所有资料都整理到网盘了，需要的话欢迎下载！私信我回复【111】即可免费获取 在java中的定义是：一个类有且仅有一个实例，[]，并且自行实例化向整个系统提供。 饿汉式(静态常量/静态代码块)懒汉式(线程不安全/线程安全，同步方法/线程安全，同步代码块)双重检查静态内部类枚举饿汉式：在类内部一
单例模式，面试让你手撸一个单例怎么办，不怕，这里有【单例模式】
MrChaun的博客
08-23 148
面试让手撸单例咋办，怕啥，来整不就行了
PuTsangTo-单撸游戏开发02 测试场景与单轴移动
wuji3390的博客
05-03 421
且不说立项与设计阶段的工作量，一个完整的游戏在开发阶段设计的职责范围也是很广，还有个大问题就是PuTsangTo项目也是本人在边学边做，截止目前还是满满的无从下手的感觉，一方面是技能与经验不足，另一方面就是要做的事情实在很多，虽然大致有哪些多少都有点数，但从感觉从那一部分先做都不太爽。 静下心来思考所有的工作，要做的主要有这么几点： 1. 美术资源。具体到2d游戏那就是贴图资源，动画切
1-2元撸纸巾项目升级版，一手链接，自己单撸都能日入100+，适合新手操作！
最新发布
tutujunjun的博客
06-05 473
另外，也可以考虑加入一些社交电商平台，通过分享商品链接，吸引更多人购买，从而实现日入100+的目标。总的来说，1-2元撸纸巾项目的升级版，一手链接，自己单撸都能日入100+，是一个新颖而具有吸引力的创业项目，尤其适合想要尝试创业的新手们。1-2元撸纸巾项目一直备受关注，而如今更有升级版问世，一手链接，自己单撸都能日入100+，成为新手操作的热门选择。这个项目究竟是怎样的呢？当然，要想在这个项目中取得成功，还需要不断学习和提升自己的销售技巧，了解市场需求和趋势，才能够保持竞争力并持续赚取利润。
单例模式
深水流静
11-24 187
文章目录一、定义二、Java实现2.1、饿汉式（静态常量）[可用]2.2、饿汉式（静态代码块）[可用]2.3、懒汉式(线程不安全)[不可用]2.4、懒汉式(线程安全，同步方法)[不推荐用]2.5、懒汉式(线程安全，同步代码块)[不可用]2.6、双重检查[推荐用]2.7、静态内部类[推荐用]2.8、枚举[推荐用] 一、定义 单例模式（Singleton Pattern）是 Java 中最简单的设计模...
JAVA设计模式之单例模式
热门推荐
一个本科小生的奋斗史
04-16 99万+
本文继续介绍23种设计模式系列之单例模式。 概念： 　　java中单例模式是一种常见的设计模式，单例模式的写法有好几种，这里主要介绍三种：懒汉式单例、饿汉式单例、登记式单例。 　　单例模式有以下特点： 　　1、单例类只能有一个实例。 　　2、单例类必须自己创建自己的唯一实例。 　　3、单例类必须给所有其他对象提供这一实例。　　单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例...
ava常用设计模式-单例模式
08-26
ava常用设计模式-单例模式 单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，有以下特点： 1. 单例类只能有一个实例。 2. 单例类必须自己创建自己的唯一实例。 3. 单例类必须给所有其他对象提供这一...
Java设计模式-单例模式详解
11-24
Java设计模式-单例模式详解 单例模式是 Java 设计模式中的一种常用的设计模式，旨在保证一个类仅有一个实例，并提供一个访问它的全局访问点。单例模式的目的是为了保证在一个进程中，某个类有且仅有一个实例。 ...
常见设计模式-单例模式
07-06
单例模式是设计模式中的一种，其主要目的是确保一个类只有一个实例，并且提供一个全局访问点来获取这个实例。在Java编程中，实现单例模式有多种方式，每种方式都有其优缺点。 1. **饿汉式**： 饿汉式在类加载时即...
JAVA-设计模式-创建型模式-单例模式
08-10
JAVA-设计模式-创建型模式-单例模式
java设计模式-单例.pdf
05-16
设计模式 java设计模式-单例.pdf
设计模式——单例模式
qq_51114283的博客
07-11 2246
创建型模式——单例模式
设计模式之单例模式（七种方法超详细）
weixin_63834061的博客
04-22 9865
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象，也就是说不能使用new关键字来创建对象。
设计模式之——单例模式
很高兴你能看到这里
06-19 2593
更酷的是，创建对象的职责和管理单例的职责被拆分在两个不同的方法中，这两个方法组合起来才具有单例模式的威力。你学到了吗，少年？
设计模式--单例模式详解
想着百万年薪努力的小赵
04-13 2323
单例模式的定义 单例模式(Singleton Pattern ）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛，例如，公司CEO、部门经理等。J2EE标准中的ServletContext，ServletContextConfig等、Spring框架应用中的ApplicationContext、数据库的连接池等也都是单例形式。 饿汉式单例模式 饿汉式单例模式在类加载的时候就立即初始化，并且创建单例对象。它绝对线程安全，在线程还没 出
设计模式之单例模式（通俗易懂，超详细）
CodeJR
07-15 2440
1 什么是单例模式 单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例（根据需要，也有可能一个线程中属于单例，如：仅线程上下文内使用同一个实例） ——《百度百科》 简单来说单例模式就是指在内存中只会创建且仅创建一次对象的设计模式，当程序中其他地方需要使用到该对象的相同功能时，都会调用创建好的这一个，不会再额外创建实例，这样做的好处就是避免过多的创建相同作用的对象使得内存浪费。 2 单例模式分类 在单例模式中主要分为两类，分别是懒汉式和饿汉式 懒汉式：在程
单例模式（单例设计模式）详解
GJ_007的博客
03-31 4万+
在有些系统中，为了节省内存资源、保证数据内容的一致性，对某些类要求只能创建一个实例，这就是所谓的单例模式。 单例模式的定义与特点 单例（Singleton）模式的定义：指一个类只有一个实例，且该类能自行创建这个实例的一种模式。例如，Windows 中只能打开一个任务管理器，这样可以避免因打开多个任务管理器窗口而造成内存资源的浪费，或出现各个窗口显示内容的不一致等错误。 在计算机系统中，还有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程
聊聊设计模式-单例模式
09-29
单例模式是一种创建型设计模式，它保证类仅有一个实例，并提供一个全局访问点。在单例模式中，类会自行创建一个实例，并对外提供一个访问该实例的方法。 单例模式有多种实现方式，其中常见的有懒汉式和饿汉式。懒汉式单例的实现方式适用于单线程环境，但不推荐在多线程环境使用。另外，单例模式还可以通过序列化和反射来破坏，因此需要注意相应的解决方案。 例如，在Java中，可以通过以下方式实现一个懒汉式的单例模式： ```java public class Singleton { private static Singleton instance; private Singleton() {} public static Singleton getInstance() { if (instance == null) { instance = new Singleton(); } return instance; } } ``` 该实现方式在第一次调用`getInstance()`方法时会创建一个实例，并在后续调用时直接返回该实例。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Coding工匠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值