单例模式的实现方式及如何有效防止防止反射和反序列化

最新推荐文章于 2023-04-01 22:10:46 发布
最新推荐文章于 2023-04-01 22:10:46 发布
阅读量1k 收藏 5
点赞数 3
文章标签： android 设计模式
原文链接：https://www.cnblogs.com/call-me-pengye/p/11169051.html
版权

方式一：饿汉式(静态常量)

public class Singleton {
    
    private final static Singleton SINGLETON = new Singleton();
    
    private Singleton(){
    }
    
    public void doAction(){
        //TODO 实现你需要做的事
    }
    
    public static Singleton getInstance(){
        return SINGLETON;
    }
}

 

 

测试用例:

 

public class Test {
    public static void main(String[] args) {
        Signleton singleton1 = Singleton.getInstance();
        Signleton singleton2 = Singleton.getInstance();
        
        System.out.println("两个singleton对象是否是同一个对象:"+ (singleton1 == singleton2) );
        System.out.println("singleton1的hashCode:"+singleton1.hashCode());
        System.out.println("singleton2的hashCode:"+singleton2.hashCode());
    }
}

复制代码

运行结果:

两个singleton对象是否是同一个对象:true
singleton1的hashCode:366712642
singleton2的hashCode:366712642

优点：

  1. 代码实现简单
  2. 利用类加载机制避免了多线程同步问题

缺点：

  1. 在类加载时就完成了实例化，没有达到Lazy loading的效果，有可能造成内存浪费

 

方式二：饿汉式(静态代码块)

 

public class Singleton {
    
    private final static Singleton SINGLETON;
    static{
        SINGLETON = new Singleton();
    }
    
    private Singleton(){
    }
    public void doAction(){
        //TODO 实现你需要做的事
    }
    
    public static Singleton getInstance(){
        return SINGLETON;
    }
}

 

测试用例：

 

public class Test {
    public static void main(String[] args) {
        Signleton singleton1 = Singleton.getInstance();
        Signleton singleton2 = Singleton.getInstance();
        
        System.out.println("两个singleton对象是否是同一个对象:"+ (singleton1 == singleton2) );
        System.out.println("singleton1的hashCode:"+singleton1.hashCode());
        System.out.println("singleton2的hashCode:"+singleton2.hashCode());
    }
}

 

运行结果：

两个singleton对象是否是同一个对象:true
singleton1的hashCode:366712642
singleton2的hashCode:366712642

这种实现方式优缺点和方式一是一样的，也是利用了类加载，唯一不同的就是将实例化的过程放在了静态代码块中。

 

方式三：懒汉式(线程不安全)

 

public class Singleton {

    private static Singleton singleton;
    private Singleton(){
    }
    public void doAction(){
        //TODO 实现你需要做的事
    }
    
    public static Singleton getInstance(){
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

 

测试代码：

 

public class Test {
    public static void main(String[] args) {
        //多线程获取对象，存在线程不安全问题
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton1 = Singleton.getInstance();
                System.out.println("singleton1的hashCode:"+singleton1.hashCode());
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton2 = Singleton.getInstance();
                System.out.println("singleton2的hashCode:"+singleton2.hashCode());
            }
        });
        thread1.start();
        thread2.start();
    }
}

 

运行结果：

 

第一次运行结果:
    singleton2的hashCode:1813990537
    singleton1的hashCode:1813990537
第二次运行结果:
    singleton1的hashCode:1813990537
    singleton2的hashCode:1481479505

 

从两次运行结果来看，我们发现singleton1与singleton2的hashCode存在相同和不想同的两种情况，这就已经证明了这种方式的线程不安全性

优点:

  1. 起到了Lazy loading效果，适合在单线程环境中使用

缺点:

  1. 在多线程环境中存在线程不安全问题

 

 方式四：懒汉式(方法同步)

 

public class Singleton {
    private static Singleton singleton;

    private Singleton(){
    }
    public void doAction(){
        //TODO 实现你需要做的事
    }
    public synchronized static Singleton getInstance(){
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

 

测试用例(可多做几次测试)：

 

public class Test {
    public static void main(String[] args) {
        //多线程获取对象，线程安全问题
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton1 = Singleton.getInstance();
                System.out.println("singleton1的hashCode:"+singleton1.hashCode());
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton2 = Singleton.getInstance();
                System.out.println("singleton2的hashCode:"+singleton2.hashCode());
            }
        });
        thread1.start();
        thread2.start();
    }
}

 

运行结果：

 

第一次运行结果:
    singleton1的hashCode:1947425526
    singleton2的hashCode:1947425526
第二次运行结果:
    singleton1的hashCode:1430007319
    singleton2的hashCode:1430007319

 

从两次运行结果来看，我们发现singleton1与singleton2的hashCode是一样的，说明这种方法是线程安全的

优点：

  1. 实现了Lazy loading想过
  2. 避免了多线程同步问题

缺点：

  1. 效率太低，每个线程在执行getInstance()方法都要进行同步。实际上这个方法只要执行一次实例化就行，当实例化完成，后面的线程是通不过if判断的

 

方式五：懒汉式(实例化代码同步)

public class Singleton {
    private static Singleton singleton;
    
    public Singleton() {
    }
    public void doAction(){
        //TODO 实现你需要做的事
    }
    public  static Singleton getInstance(){
        if (singleton == null) {
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

 

测试用例：

 

public class Test {
    public static void main(String[] args) {
        //多线程获取对象，存在线程不安全问题
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton1 = Singleton.getInstance();
                System.out.println("singleton1的hashCode:"+singleton1.hashCode());
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton2 = Singleton.getInstance();
                System.out.println("singleton2的hashCode:"+singleton2.hashCode());
            }
        });
        thread1.start();
        thread2.start();
    }
}

 

运行结果：

singleton2的hashCode:1813990537
singleton1的hashCode:1430007319

从两次运行结果来看，我们发现singleton1与singleton2的hashCode是不相同的，证明这种方式是线程不安全的

有点：

  1. 实现了Lazy loading的现过
  2. 相对于第四种的同步，该方法的效率得到了提升

 缺点：

  1. 在多线程环境中存在线程不安全问题

 

方式六：双重检测

public class Singleton {
    private static Singleton singleton;
    
    private Singleton(){
    }
    public void doAction(){
        //TODO 实现你需要做的事
    }
    public  static Singleton getInstance(){
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

 

测试用例：

 

public class Test {
    public static void main(String[] args) {
        //多线程获取对象，线程安全
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton1 = Singleton.getInstance();
                System.out.println("singleton1的hashCode:"+singleton1.hashCode());
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton2 = Singleton.getInstance();
                System.out.println("singleton2的hashCode:"+singleton2.hashCode());
            }
        });
        thread1.start();
        thread2.start();
    }
}

 

运行结果：

singleton2的hashCode:1481479505
singleton1的hashCode:1481479505

优点：

  1. 线程安全
  2. 实现Lazy loading
  3. 效率较高

 

 

方式七：静态内部类

 

public class Singleton {
    public Singleton() {
    }
    public void doAction(){
        //TODO 实现你需要做的事
    }
    private static class SingletonInstance{
        private final static Singleton SINGLETON = new Singleton();
    }
    public  static Singleton getInstance(){
        return SingletonInstance.SINGLETON;
    }
}

复制代码

测试用例:

 

public class Test {
    public static void main(String[] args) {
        //多线程获取对象，线程安全
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton1 = Singleton.getInstance();
                System.out.println("singleton1的hashCode:"+singleton1.hashCode());
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton2 = Singleton.getInstance();
                System.out.println("singleton2的hashCode:"+singleton2.hashCode());
            }
        });
        thread1.start();
        thread2.start();
    }
}

 

运行结果：

singleton2的hashCode:1481479505
singleton1的hashCode:1481479505

这种方式利用了类装载机制来保证初始化实例时只有一个线程，静态内部类在Singleton被装载时并不会立即实例化，而是在调用getInstance()时才会装载静态内部类，从而完成Singleton实例化。由于类的静态属性只会在第一次加载类的时候进行初始化，这里我们通过JVM加载类时的线程安全的特性来保证了线程安全

优点：

  1. 利用JVM加载静态内部类的机制保证多线程安全
  2. 实现Lazy loading效果
  3. 效率高

方式八：使用枚举(《Effective Java》作者的Josh Bloch提倡的方式)

public enum Singleton {
    INSTANCE;
    public void doAction(){
        //TODO 实现你需要做的事
    }
}

 

测试用例：

 

public class Test {
    public static void main(String[] args) {
        //多线程获取对象，线程安全
        Thread thread1 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton1 = Singleton.INSTANCE;
                System.out.println("singleton1的hashCode:"+singleton1.hashCode());
            }
        });
        Thread thread2 = new Thread(new Runnable() {
            public void run() {
                Singleton singleton2 = Singleton.INSTANCE;
                System.out.println("singleton2的hashCode:"+singleton2.hashCode());
            }
        });
        thread1.start();
        thread2.start();
    }
}

 

运行结果：

singleton2的hashCode:321306952
singleton1的hashCode:321306952

优点：

  1. 线程安全(枚举实例的创建默认就是线程安全的)
  2. 不会因为序列化而产生新实例
  3. 防止反射攻击

 

 

 

破环单例模式的三种方式：反射，序列化，克隆

以双重检测方式为例测试反射，序列化，克隆是否能破环单例模式:

 

public class Singleton  implements Serializable,Cloneable{
    private static final long serialVersionUID = 6125990676610180062L;
    private static Singleton singleton;
    
    private Singleton(){
    }
    public void doAction(){
        //TODO 实现你需要做的事
    }
    public  static Singleton getInstance(){
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

 

测试用例：

 

public class DestroySingleton {
    
    public static void main(String[] args) throws Exception {
        //通过getInstance()获取
        Singleton singleton = Singleton.getInstance();
        System.out.println("singleton的hashCode:"+singleton.hashCode());
        //通过反射获取
        Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton reflex = constructor.newInstance();
        System.out.println("reflex的hashCode:"+reflex.hashCode());
        //通过克隆获取
        Singleton clob = (Singleton) Singleton.getInstance().clone();
        System.out.println("clob的hashCode:"+clob.hashCode());
        //通过序列化，反序列化获取
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(Singleton.getInstance());
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        Singleton serialize = (Singleton) ois.readObject();
        if (ois != null)    ois.close();
        if (bis != null) bis.close();
        if (oos != null) oos.close();
        if (bos != null) bos.close();
        System.out.println("serialize的hashCode:"+serialize.hashCode());
    }
}

 

运行结果：

singleton的hashCode:366712642
reflex的hashCode:1829164700
clob的hashCode:2018699554
serialize的hashCode:990368553

运行结果表明通过getInstance()、反射、克隆、序列化这四种方式得到的Singleton对象的hashCode是不一样的，此时单例模式已然被破环

 

如何防止反射、克隆、序列化对单例模式的破环

1、防止反射破环(虽然构造方法已私有化，但通过反射机制使用newInstance()方法构造方法也是可以被调用):

  • 首先定义一个全局变量开关isFristCreate默认为开启状态
  • 当第一次加载时将其状态更改为关闭状态

2、防止克隆破环

  • 重写clone()，直接返回单例对象

3、防止序列化破环

  • 添加readResolve()，返回Object对象

 

public class Singleton  implements Serializable,Cloneable{
    private static final long serialVersionUID = 6125990676610180062L;
    private static Singleton singleton;
    private static boolean isFristCreate = true;//默认是第一次创建
    
    private Singleton(){
            if (isFristCreate) {
                synchronized (Singleton.class) {
　　　　　　　　　　　　if (isFristCreate) {
　　　　　　　　　　　　　　isFristCreate = false;
　　　　　　　　　　　　}
                }
            }else{
                throw new RuntimeException("已然被实例化一次，不能在实例化");
            }
    }
    public void doAction(){
        //TODO 实现你需要做的事
    }
    public  static Singleton getInstance(){
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    @Override
    protected Singleton clone() throws CloneNotSupportedException {
        return singleton;
    }
    private Object readResolve() {
        return singleton;
    }
}

 

测试用例：

 

public class DestroySingleton {
    
    public static void main(String[] args) throws Exception {
        //通过getInstance()获取
        Singleton singleton = Singleton.getInstance();
        System.out.println("singleton的hashCode:"+singleton.hashCode());
        //通过克隆获取
        Singleton clob = (Singleton) Singleton.getInstance().clone();
        System.out.println("clob的hashCode:"+clob.hashCode());
        //通过序列化，反序列化获取
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(Singleton.getInstance());
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        Singleton serialize = (Singleton) ois.readObject();
        if (ois != null)    ois.close();
        if (bis != null) bis.close();
        if (oos != null) oos.close();
        if (bos != null) bos.close();
        System.out.println("serialize的hashCode:"+serialize.hashCode());
        //通过反射获取
        Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        Singleton reflex = constructor.newInstance();
        System.out.println("reflex的hashCode:"+reflex.hashCode());
    }
}

 

运行结果：

 

singleton的hashCode:366712642
clob的hashCode:366712642
serialize的hashCode:366712642
Exception in thread "main" java.lang.reflect.InvocationTargetException
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at designPatterns.singleton.doublecheck.DestroySingleton.main(DestroySingleton.java:33)
Caused by: java.lang.RuntimeException: 已然被实例化一次，不能在实例化
    at designPatterns.singleton.doublecheck.Singleton.<init>(Singleton.java:16)
    ... 5 more

从运行结果上看重写clone()，添加readResolve()后通过克隆和序列化得到的对象的hashCode与从getInstance()得到的对象得而hashCode值相同，而通过反射运行得到的结果符合预想的报错；因为以上三种手段对防止单例被破坏起作用了，至于枚举为什么能做到防止反射，克隆及序列化对单例的破坏将留在下次分享

　　如有写的不对的地方请书友们及时指出，谨诚拜谢！！

饭小粒
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
final修饰的变量能否被反射所修改
及时雨的csdn
04-15 1937
结论: 当定义为基本数据类型的数据和String的时候,只要赋值的时候右边是常量表达式,就会进行编译器的优化. 只要不会被编译器内联优化的final属性就可以通过反射进行有效的修改 https://blog.csdn.net/guohengcook/article/details/81264746?depth_1-utm_source=distribute.pc_relevant...
序列化破坏单例模式以及如何防御
小灰狼与大白兔的博客
12-07 6516
序列化介绍 Serializable介绍 如果单例类实现了序列化接口Serializable，那么就可能被序列化攻击来破坏单例模式。 public class Singleton implements Serializable { private static final long serialVersionUID = 1L; private static Singleton singleton = new Singleton(); private Singleton(){
sqoop远程连接出现的两个小错误
Kang Hao‘s Blog
07-31 1854
sqoop连接MYSQL数据库时出现以下错误： 错误一： 19/07/31 03:56:24 ERROR manager.CatalogQueryManager: Failed to list tables com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure Last p...
单例模式实现及防止反射与序列化
Better_YZQ的博客
07-19 780
单例模式 模式动机 对于系统中的某些类来说，只有一个实例很重要，如一个系统中只有一个计时工具和 ID（序号）生成器。 单例模式适用情况包括：系统只需要一个实例对象；客户调用类的单个实例只允许使用一个公共访问点。 定义 顾名思义，用来保证一个对象只能创建一个实例，除此之外，它还提供了对实例的全局访问方法。 单例模式的要点有三个：一是类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。 实现 为了确保单例实例的唯一性，所有的 单例构造器都要被声明为私有 的，再通过声明 静态方法实
Kotlin 静态内部类单例模式的正确实现方式
m0_70748845的博客
04-01 1659
最近在整理基础库的时候，需要一个基础类来存储初始化的数据，例如应用的 Application Context，用户的登录 token 等等信息，这些基本都是应用全局类的信息，在应用的整个生命周期都会用到，因此我将这个基础类设计为单例模式来优化性能。Easy，类的静态属性和静态代码块，会在类加载的初始化阶段赋值和执行，但类的静态方法不会呀，把单例作为静态方法的返回值就可以完美地让单例懒加载了。喔，看着挺简单的，看看有没其他实现，陆续点击第二条第三条搜索内容，发现一整页的静态内部类单例都是返回这样的结果。
单例设计模式实现总结
12-22
单例模式的总体概述 单例模式，属于创建型模式，《设计模式》一书对它做了定义：保证一个类仅有一个实例，并提供一个全局访问点...防止序列化破坏单例模式 多种实现方式与比较 线程安全的饿汉模式 public class HungryS
单例模式简介和java代码实现
最新发布
07-05
不过，这种方式在某些场景下可能不适用，如需要序列化单例对象。 总结： 单例模式是软件设计中常用的一种模式，它的核心在于限制类的实例化次数，保证全局只有一个实例，并提供统一的访问接口。单例模式在很多场景...
JAVA 枚举单例模式及源码分析的实例详解
08-29
JAVA 枚举单例模式是一种特殊的单例模式实现方式，它使用枚举类型来保证线程安全、防止序列化问题和反射攻击。下面我们将详细解释这个模式的实现原理和源码分析。 线程安全 在 Java 中，枚举类型的实例是在类加载...
java 单例的五种实现方式及其性能分析
08-30
饿汉式是单例模式的实现方式之一。饿汉式的实现方式是，类加载时就完成实例的初始化，保证线程的安全性。 优点： 1. 实例的初始化由 JVM 装载类的时候进行，保证了线程的安全性。 2. 实现简单方便。 3. 实例的访问...
常见设计模式-单例模式
07-06
枚举是最简洁且安全的单例实现方式，天然线程安全，支持序列化，并且防止反射攻击。但单例的创建时机不可控，不能在运行时动态实例化。 在Spring框架中，单例模式的实现主要依赖于IoC容器。Spring通过`...
JAXBContext.newInstance线程阻塞
andQ的博客
05-21 1694
问题现象： java.lang.Thread.State: BLOCKED (on object monitor) at java.util.zip.ZipFile$ZipFileInputStream.read(ZipFile.java:719) - waiting to lock <0x0000000080af2208> (a sun.net.www.protocol.jar.URLJarFile) at java.io.FilterI...
java 无法初始化类_java.lang.NoClassDefFoundError：无法初始化类
weixin_34617955的博客
02-16 1125
我正在尝试从BingAds下载报告 . 我的代码在IDEA内部下载报告，没什么大问题 . 当我试图让它在sbt里面运行时：H24_BING_CONFIG = / home / oleber / del / develop_bing.json sbt clean'project importerBing''run'执行失败如：[oleber] [WARN] [home24-aws] [org.apa...
Struts2 报错记录-StrutsSpringObjectFactory
axinyuei的博客
05-29 507
报错信息： Caused by: java.lang.NoSuchMethodError: com.opensymphony.xwork2.spring.SpringObjectFactory.<init>(Lcom/opensymphony/xwork2/inject/Container;)V at org.apache.struts2.spring.StrutsSpringObjectFactory.<init>(StrutsSpringObjectFactory.java
java链接mysql出问题_java连接MySQL出现问题
weixin_29710403的博客
01-21 333
该楼层疑似违规已被系统折叠隐藏此楼查看此楼Exception in thread "main" com.mysql.jdbc.exceptions.jdbc4.MySQLNonTransientConnectionException: Could not create connection to database server. Attempted reconnect 3 times. Givi...
Spring 源码解析之 防止反射和序列化破解的单例写法
Java持续实践
03-07 243
文章目录使用枚举内部类的单例尝试直接通过枚举反射创建实例反编译查看枚举单例模式源码(证明其是饿汉模式) 使用枚举内部类的单例 如下的类, 使用枚举的内部类方式创建单例. 在枚举中的构造方法创建对象 . public class EnumStaringSingleton { // 私有无参构造函数 private EnumStaringSingleton() { } public static EnumStaringSingleton getInstance() {
测试类报错java.lang.ExceptionInInitializerError
jinyu_mobao的博客
01-17 1639
编写测试类的踩坑记录
你写的单例模式，能防止反序列化和反射吗？
CTO_1649900265的专栏
02-01 323
前言 说起单例模式，相信大家都不会陌生。因为相比其他设计模式，实现一个单例模式是比较简单的。单例模式的意思就是一个类只有一个实例。 获取类的实例，我们往往采用new关键字，但是要保证一个类只能有一个实例，所以不能让使用这个类的开发人员利用new关键字来创建实例。也就是不能让外部调用类的构造方法，所以很容易想到类的构造方法私有，这样开发人员就不能在类之外通过new的方法创建该类的对象了。 由于外部不能通过new关键字来创建单例类的对象了，所以单例类本身必须提供一个静态方法，使得外部可以通过类名 + 方法名的方
反射破坏单例模式以及怎样防御
小灰狼与大白兔的博客
12-05 7326
先贴几个比较全的java反射博客 Java反射：用最直接的大白话来聊一聊Java中的反射机制 Java基础之—反射（非常重要） Java反射技术详解 前面介绍的单例模式的实现方式： 设计模式之单例模式 单例模式的设计在于只保留一个公有静态函数来获取唯一的实例，其他方法（构造函数）或字段为私有，外界不能访问。 而java反射则突破了构造函数私有的限制，可以获取单例类的私有构造函数并使用。 //得到该类在内存中的字节码对象 Class objectClass = Class.forName("com.xt
java 实例化异常_spring实例化对象异常？
weixin_29997523的博客
02-13 350
Instantiation of bean failed; nested exception is java.lang.ExceptionInInitializerErrorException in thread "main" java.lang.ExceptionInInitializerErrorat com.sohu.smc.wechat.applet.service.impl.NewsSe...
枚举单例模式如何防止反射
03-28
单例模式可以通过在私有构造函数中添加判断，防止通过反射创建新的实例。 示例代码： ``` public class Singleton { private static Singleton instance = null; private Singleton() { if (instance != null...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值