精华内容
下载资源
问答
  • 2022-06-09 17:59:48

    今天面试被问了懒汉式单例模式,没有答上来,现将答案记录下来

    public class Solutionaaa {
     
        private volatile static Solutionaaa solutionaaa = null;  // 1
    
        private Solutionaaa(){
    
        }
    
        public static Solutionaaa getSolutionaaa(){
            if(solutionaaa == null){              // 2
                synchronized (Solutionaaa.class){ // 3
                    if(solutionaaa == null){      // 4
                        solutionaaa = new Solutionaaa(); // 5
                    }
                }
            }
            return solutionaaa;
        }
    
    }

    以上便是懒汉式单例模式的写法,现在对于代码做一个解析

    1. 使用volatile是为了防止指令重排

    2. 是为了加快多线程模式下的运行速率,比如已经创建了一个实例,那么就不需要去竞争锁了

    3+4. 是为了防止多线程模式下重复创建单例。有可能线程A竞争到了锁,然后创建了实例,退出了锁,此时线程B也进到临界区,此时如果没有if判断是否为null,那么就会重复创建实例

    5. 创建单例

    更多相关内容
  • 单例模式的实现3.1 饿汉式3.2 懒汉式4. 线程安全问题5. 解决懒汉式线程安全问题 1. 定义 什么是单例模式呢? 我们引用一下维基百科: ​ 单例模式,也叫单子模式,是一种常用的软件设计模式。在应用这个模式时,...

    单例模式

    1. 定义

    什么是单例模式呢? 我们引用一下维基百科:

    单例模式,也叫单子模式,是一种常用的软件设计模式。在应用这个模式时,单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象,这样有利于我们协调系统整体的行为。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。还有就是我们经常使用的servlet就是单例多线程的。使用单例能够节省很多内存。

    2. 如何使用单例模式

    ​ 实现单例模式的思路是:一个类能返回对象一个引用(永远是同一个)和一个获得该实例的方法(必须是静态方法,通常使用getInstance这个名称);当我们调用这个方法时,如果类持有的引用不为空就返回这个引用,如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用;同时我们还将该类的构造函数定义为私有方法,这样其他处的代码就无法通过调用该类的构造函数来实例化该类的对象,只有通过该类提供的静态方法来得到该类的唯一实例。

    3. 单例模式的实现

    3.1 饿汉式

    ​ 为什么叫饿汉式呢?我们看代码,其中定义了一个 私有的(保证外部不能直接访问) 静态的 final的实例,并且直接new了一个对象,并将构造方法也设置为私有的(保证外部不能创建实例),这样就会导致Singleton 类在加载字节码到虚拟机的时候就会实例化这个实例,当你调用getInstance方法的时候,就会直接返回,不必做任何判断,这样做的好处是代码量明显减少了,坏处是,当我们没有使用该单例的时候,该单例却被加载了,如果这个单例很大的话,将会浪费很多的内存。

    static class Singleton
    {
       //创建static成员变量,标识Singleton类的唯一实例
        private static final Singleton instance = new Singleton();
    
        //创建private权限的构造方法
        private Singleton()
        {
    
        }
    
        /**
         * 获取实例的唯一方式,确保得到实例唯一
         * 在类外部可以获取到唯一实例
         * @return
         */
        public static Singleton getInstance()
        {
            return instance;
        }
    }
    

    3.2 懒汉式

    我们可以看到,这是一个简单的获取单例的一个类,首先我们定义一个私有静态实例 single, 并将构造方法变成私有的(保证外部不能创建实例),并且给外界一个静态获取实例的方法。如果对象不是null,就直接返回实例,从而保证实例。也可以保证不浪费内存。但是有部分问题。

    static class Singleton
    {
        //创建static成员变量,标识Singleton类的唯一实例
        private static Singleton instance = null;
    
        //创建private权限的构造方法
        private Singleton()
        {
    
        }
    
        /**
         * 获取实例的唯一方式,确保得到实例唯一
         * 在类外部可以获取到唯一实例
         * 第一次实例化时 线程可能不安全
         * @return
         */
        public static Singleton getInstance()
        {
            //如果为空,说明实例还未存在(即第一次使用),则创建实例
            if (instance == null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }
    
    

    4. 线程安全问题

    通过对代码的分析,我们可以发现

    饿汉式单例模式线程安全的,由于饿汉式单例模式在加载时已经创建了对象,这就保证了在其他线程再次访问时将会访问到同一个对象。

    而上述的懒汉单例模式线程不安全,如下图所示,如果在线程1发现instance为空后,线程2抢占到了执行权,也进行了判断,接着两个线程都发现instance为空,将会创建两个不同的instance对象返回,所以这就不能保证单例模式,即不是线程安全的

    image-20210804212653692

    5. 解决懒汉式线程安全问题

    我们可以通过三个方面来优化并解决懒汉式线程安全问题

    • 加锁 synchronized保证同时只有一个进程进入此方法,从而保证并发安全。

      synchronized (Singleton.class)
      {
          if (instance == null)
          {
              instance = new Singleton();
          }
      }
      
    • 双if

      由于加锁只是为了避免第一次创建实例时线程不安全,其后都只会降低性能,所以添加if判断,当发现其为空时才加锁,否则直接返回已经创建好的实例对象。

      if (instance == null) //由于加锁只是为了避免第一次创建实例时线程不安全,其后都只会降低性能,所以添加if判断
      {
          //如果有多个线程进入进入同步块,其他线程等待
          synchronized (Singleton.class)
          {
              if (instance == null)
              {
                  instance = new Singleton();
              }
          }
      }
      
    • 添加volatile

      由于会进行 instance == null 判断(多个线程会出现一个读一个写),编译器优化后可能导致内存可见性问题

      //创建static成员变量,标识Singleton类的唯一实例,为避免内存可见性问题,添加volatile
      private static volatile Singleton instance = null;
      

    综上,优化后的懒汉式单例模式代码如下

    static class Singleton
    {
        //创建static成员变量,标识Singleton类的唯一实例,为避免内存可见性问题,添加volatile
        private static volatile Singleton instance = null;
    
        //创建private权限的构造方法
        private Singleton()
        {
    
        }
    
        /**
         * 获取实例的唯一方式,确保得到实例唯一
         * 在类外部可以获取到唯一实例
         * 第一次实例化时 线程可能不安全
         * @return
         */
        public static Singleton getInstance()
        {
            //如果为空,说明实例还未存在(即第一次使用),则创建实例
            //加锁,确保判断为空和 new对象两个操作 成为原子操作
            if (instance == null) //由于加锁只是为了避免第一次创建实例时线程不安全,其后都只会降低性能,所以添加
            {
                synchronized (Singleton.class)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
    		//如果不为null,直接返回已经创建好的对象
            return instance;
        }
    }
    
    展开全文
  • 单例模式(Singleton ...单例模式实现方式分为非延时加载(饿汉式 Eager Singleton)和 延时加载(懒汉式 Lazy Singleton),延时加载( 节省内存)可以有效提高系统资源的利用效率,所以通常使用延时加载的懒汉式实现

    单例模式(Singleton Pattern)是一种对象创建型模式

    单例模式:确保一个类仅有一个实例,且自行实例化,并对外提供这个唯一的实例

    单例模式实现方式分为非延时加载(饿汉式 Eager Singleton)和 延时加载(懒汉式 Lazy Singleton),延时加载( 节省内存)可以有效提高系统资源的利用效率,所以通常使用延时加载的懒汉式实现


    懒汉式,线程不安全
    /**
     * 懒汉式单例模式,线程不安全
     */
    class LazySingleton {
    
        //这里省略了属性...
    
    	//将构造函数设为private
        private LazySingleton(){
    
        }
    
    	//与饿汉式不同,懒汉式并不会立即初始化
        private static LazySingleton instance = null;
    
        public static LazySingleton getInstance(){
            if(instance == null){
                instance = new LazySingleton();
            }
            return instance;
        }
    }
    

    懒汉式单例模式在第一次调用 getInstance() 方法时,实例化 LazySingleton 对象,在类加载时并不自行实例化,这种技术称为:延时加载技术(Lazy Load)

    上诉代码存在线程安全问题。在多线程情况下:

    🍁1️⃣ 线程A进入 if (instance == null) 中,还没来的及执行 instance = new LazySingleton(); 语句创建 instance 对象,时间片就切换给了线程B ;🍁2️⃣ 此时由于instance 对象还没创建,instance 对象为空,所以线程B也进入if (instance == null) 中,并顺利执行 instance = new LazySingleton(); 语句创建了instance 对象 ;🍁3️⃣ 在线程A重新获得时间片后,开始执行 instance = new LazySingleton(); 语句,也创建了instance 对象。🍀4️⃣ 此时线程A 和 线程B都创建了instance对象,这就违背了单例模式的初衷。


    所以严格意义上 懒汉式,线程不安全 并不算单例模式,因为它在多线程情况下不能正常工作。



    懒汉式,线程安全(同步方法)
    /**
     * 懒汉式单例模式,线程安全
     */
    class LazySingleton {
    
        //这里省略了属性...
    
    	//将构造函数设为private
        private LazySingleton(){
    
        }
    
    	//与饿汉式不同,懒汉式并不会立即初始化
        private static LazySingleton instance = null;
    
        public static synchronized LazySingleton getInstance(){ //静态同步方法的同步监视器是:LazySingleton.class
            if(instance == null){
                instance = new LazySingleton();
            }
            return instance;
        }
    }
    

    懒汉式,线程安全(同步代码块)
    /**
     * 懒汉式单例模式,线程安全
     */
    class LazySingleton {
    
        //这里省略了属性...
    
    	//将构造函数设为private
        private LazySingleton(){
    
        }
    
    	//与饿汉式不同,懒汉式并不会立即初始化
        private static LazySingleton instance = null;
    
        public static LazySingleton getInstance(){ //静态同步方法的同步监视器是:LazySingleton.class
        	synchronized(LazySingleton.class){
    			if(instance == null){
                	instance = new LazySingleton();
            	}
    		}
            return instance;
        }
    }
    

    上诉代码解决了线程安全问题。但可以发现一个问题:无论是在 instance 初始化之前,还是 instance 已经初始化了,getInstance都一直有加锁。但 instance 已经初始化后,还对 getInstance 加锁就会产生不必要的锁竞争,降低效率。


    懒汉式,线程安全(同步代码块 优化 👉 Double-Check-Lock双检式

    优化:在 instance 初始化之前,才加锁;instance 已经初始化后就不需要加锁了。只需在加锁之前,加上一个if判断条件,条件是instance是否已经初始化了,如果已经初始化了,线程就不会进入到里面,自然就不会产生锁竞争了。

    /**
     * 懒汉式单例模式,线程安全
     */
    class LazySingleton {
    
        //这里省略了属性...
    
    	//将构造函数设为private
        private LazySingleton(){
        }
    
    	//与饿汉式不同,懒汉式并不会立即初始化
        private static volatile LazySingleton instance = null;
    
    
        public static LazySingleton getInstance(){ //静态同步方法的同步监视器是:LazySingleton.class
        	//双重检查锁定(Double-Check Lock)
            if (instance == null){
            	//加锁之前,添加判断条件,防止不必要的锁竞争
            	synchronized(LazySingleton.class){
    				if(instance == null){
                		instance = new LazySingleton();
            		}
    			}
            }
            return instance;
        }
    }
    

    蔡栋
    https://blog.csdn.net/weixin_39713814/article/details/111009079


    懒汉式,线程安全(静态内部类实现),推荐使用
    /**
     * 利用jvm加载静态内部类的特性,可以实现单例对象的延时创建,且保证了线程安全
     */
    public class StaticInnerClassSingleton {
    
        //私有化构造方法,防止被通过常规方式实例化
        private StaticInnerClassSingleton() {
        }
    
        //外部类被加载时,静态内部类不会被加载,只有第一次调用该静态内部类时,才会被加载
        private static class StaticInnerClass {
            // jvm保证了静态内部类被加载的时候是线程安全的(多线程情况下),且只被实例化一次
            /*private*/ static final StaticInnerClassSingleton instance = new StaticInnerClassSingleton();
           // 这里私有化没什么意义
        }
        
        //供外界获取该唯一实例
        public static StaticInnerClassSingleton getInstance() {
            //调用静态内部类的静态字段,此时内部类才开始初始化
            return StaticInnerClass.instance;
        }
    }
    

    通过代码可看出,在类加载时不会实例化 StaticInnerClassSingleton 对象,而是在第一次调用 getInstance() 方法时,加载静态内部类 StaticInnerClass ,并初始化静态成员变量 StaticInnerClassSingleton,由jvm保证其线程安全,使得静态成员变量 StaticInnerClassSingleton 只能初始化一次。且 getInstance() 方法没有加锁,不会影响性能。

    通过这种方式实现的懒汉式单例模式,即实现了延时加载,又保证了线程安全,且不影响性能。(推荐使用)







    https://wenku.baidu.com/view/14c1e2f2b24e852458fb770bf78a6529647d356b.html?rec_flag=default&fr=Recommend_RelativeRecommend-80225,100225,80204,110168,80166,110010,80139,90193,80163,110192-search_rec_append-a75ad10ab7daa58da0116c175f0e7cd1842518cf

    https://wenku.baidu.com/view/fefc9d57cb50ad02de80d4d8d15abe23482f032a.html?rec_flag=default&fr=Recommend_RelativeRecommend-80225,100225,80204,110168,80166,110010,80139,90193,80163,110192-search_rec_append-a75ad10ab7daa58da0116c175f0e7cd1842518cf

    https://www.csdn.net/tags/MtTaEg0sMjQ0NTUtYmxvZwO0O0OO0O0O.html

    https://wenku.baidu.com/view/28c4184124d3240c844769eae009581b6bd9bd87.html

    https://www.runoob.com/design-pattern/singleton-pattern.html

    https://blog.csdn.net/laijinxiang0108/article/details/104911916

    展开全文
  • 单例模式之懒汉式单例模式 本文将探讨三种懒汉式单例模式,会从代码的运行效率,线程安全等方面探讨。 在上一篇文章中,刚刚介绍饿汉式单例模式,在本文开头先简单的说一下懒汉式单例模式和饿汉式单例模式的区别: ...

    单例模式之懒汉式单例模式

    本文将探讨三种懒汉式单例模式,会从代码的运行效率,线程安全等方面探讨。

    在上一篇文章中,刚刚介绍饿汉式单例模式,在本文开头先简单的说一下懒汉式单例模式和饿汉式单例模式的区别:
    首先懒汉式单例模式,是在程序需要用到该实例时才会创建的。这样就不会像饿汉式一样,在类加载过程中就会创建。这样就减少了内存的浪费,当然也自然而然的带来了一些缺点:需要时才创建,影响程序的执行效率。另外,懒汉式单例模式在使用时进行创建,势必会带来线程安全的问题,需要解决以上问题,就需要用到锁。锁的使用也在一定程度上会带来一定的执行效率问题。

    第一种:普通的懒汉式单例模式
    直接上代码:

    public class LazySingleton {
        private LazySingleton() {
        }
    
        private volatile static LazySingleton instance;
    
        public synchronized static LazySingleton getInstance() {
            if (instance == null) {
                instance = new LazySingleton();
            }
            return instance;
        }
    }
    

    这种设计明显的一个问题就是执行效率低,无论是否已经存在实例,在多线程的情况下都会发生阻塞。
    对以上代码进行改进,首先让当程序中实例存在的时候,直接返回实例,不需要抢占锁。当程序中不存在实例时,再抢占锁进行创建。根据以上的思想,出现了第二种懒汉式方式:

    第二种:双重判断型单例模式

    public class LazyDoubleCheckSingleton {
        private LazyDoubleCheckSingleton() {
        }
    
        private volatile static LazyDoubleCheckSingleton instance;
    
        public static LazyDoubleCheckSingleton getInstance() {
            //确定是否需要阻塞
            if (instance == null) {
                synchronized (LazyDoubleCheckSingleton.class) {
                    //确定是否需要创建实例
                    if (instance == null) {
                        //这里在多线程的情况下会出现指令重排的问题,所以对共有资源instance使用关键字volatile修饰
                        instance = new LazyDoubleCheckSingleton();
                    }
                }
            }
            return instance;
        }
    
    }
    
    

    对于第二种方式,较第一种方式而言,性能提高了。但是代码的可读性差了。

    第三种:利用java语法本身特性

    public class LazyStaicSingleton {
        private LazyStaicSingleton(){}
    
        public static LazyStaicSingleton getInstance(){
            return Hander.INSTANCE;
        }
    
        private static class Hander{
            private static final LazyStaicSingleton INSTANCE=new LazyStaicSingleton();
        }
    }
    
    

    针对以上三种方式,都可以通过反射破坏其单例模式的特性,这个时候可以在私有构造方法种如下设计:

      private LazyStaicSingleton(){
            if(Hander.INSTANCE!=null){
                throw new RuntimeException("不允许非法访问");
            }
        }
    

    这样在通过反射创建实例时就会报错。

    测试代码如下:

    public class LazyStaticSingletonTest {
        public static void main(String[] args) {
            //先创建一个实例
            LazyStaicSingleton instance=LazyStaicSingleton.getInstance();
            System.out.println(instance);
            //通过反射创建实例
            try{
                Class<?> clazz=LazyStaicSingleton.class;
                Constructor c = clazz.getDeclaredConstructor(null);
                c.setAccessible(true);
                Object lazyStaicSingleton=c.newInstance();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    
    

    结果:

    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 com.example.singleton.LazyStaticSingletonTest.main(LazyStaticSingletonTest.java:17)
    Caused by: java.lang.RuntimeException: 不允许非法访问
    	at com.example.singleton.lazy.LazyStaicSingleton.<init>(LazyStaicSingleton.java:6)
    	... 5 more
    
    展开全文
  • 单例模式详解一、单例模式的定义及应用场景二、饿汉式单例模式(一)、饿汉式单例模式的优缺点(二)、饿汉式单例模式的代码案例三、懒汉式单例模式(一)、懒汉式单例模式的特点(二)、懒汉式单例模式的代码案例一...
  • 本文先简单说一下懒汉式单例,再着重叙述饿汉式单例,饿汉式单例是本文的叙述重点。懒汉式的优点是:写起来比较简单,而且不存在多线程同步问题,避免了synchronized所造成的性能问题;缺点是:初始化类的时候就需要...
  • 单例模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。 使用Singleton的好处还在于可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收。...如下为线程安全的懒汉式单例模式: ...
  • 懒汉式单例模式,使用的时候才创建 但懒汉式单例在多线程情况下会出现一个问题, 就是在多线程情况下会出现单例对象会创建多个实例; /** * 懒汉式单例模式,使用的时候才创建, * 在多线程情况下会出现一个问题,...
  • 主要介绍了java 单例模式的相关资料,这里对懒汉式与饿汉式都做了实例介绍,需要的朋友可以参考下
  • 懒汉式单例模式是线程不安全的,这里有两个实现单例模式线程安全的方法(枚举方法不写了) 1.DCL双端锁 通过volatile禁止指令重排,防止得到null public class Study { private volatile static Study instance; ...
  • 3 个答案babab答案时间:2020-10-19public class Item {// 懒汉式单例模式,等用的时候再创建// 1、构造方法私有化private Item(){}// 2、单例属性私有化private static Item instance;// 3、通过方法返回单例属性...
  • 随手记。 单例模式作为23种设计模式种比较经典的,一般都要求能够手写(很简单),下面写一下两种实现方式: ... // 饿汉 单例模式 public static void main(String[] args) { Bank b1 = Bank.getI
  • Java设计模式——懒汉式单例模式

    千次阅读 2019-03-10 17:45:13
    一、懒汉式单例模式 懒汉式单例模式在被外部类调用时创建实例,因类加载速度快,但运行时获取对象的速度慢 二、实例 1、懒汉式1(线程不安全) public class LazySingleton{ private static LazySingleton...
  • 懒汉式单例模式--解决线程安全最完整版详解

    万次阅读 多人点赞 2019-05-22 17:21:52
    懒汉式单例模式 首先我们先来回顾一下饿汉式单例模式: class Singleton{ private static Singleton singleton=new Singleton(); private Singleton(){} public static Singleton getInstrance(){ return ...
  • 懒汉式单例模式解决线性安全问题如下: (1) 使用双重检查锁机制解决线程安全问题。 (2) 单例模式还有更好的解决方案,即使用静态类方式。 懒汉式单例模式典型代码: public class SingleTonDemo { /** * 单例...
  • C#饿汉式与懒汉式单例模式 何为单例模式: 单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 这种模式涉及到一个单一的类,该类...
  • 所谓的单例模式就是我们在日常开发中,可能某些类的设计最好只产生一个对象,然后我们需要用到...饿汉单例模式代码: class Singleon { public: static Singleon *getInstance() { return &instanc...
  • 本文实例讲述了Python单例模式。分享给大家供大家参考,具体如下: ...懒汉式单例类:在第一次被引用时,才将自己实例化。避免开始时占用系统资源,但是有多线程访问安全性问题。 实例: #encoding=
  • JAVA使用同步机制将单例模式中的懒汉式改写为线程安全的 JAVA设计模式是日常开发中用的比较多的,这里就举例说明一种使用同步机制将单例模式中的懒汉式改写为线程安全的,据说面试经常会被考到,大家可以保存下来哦...
  • 什么是单例模式,单例模式的优点,饿汉和懒汉式单例模式的区别什么是单例模式单例模式的优点和适用场景饿汉式和懒汉式单例模式区别改进 什么是单例模式 单例模式是一种设计模式,是创建式模式的一种。它确保了一个类...
  • 饿汉式改良——懒汉式单例(线程安全效率低,推荐方法二) package pojo; /** * 懒汉式线程安全写法 : 延迟加载,即当需要用到此单一实例的时候,才去初始化此单一实例。(经典写法去掉线程安全限制) * * ...
  • 1. //懒汉式单例模式  2. public class MySingleton {  3.  4. //设立静态变量  5. private static MySingleton mySingleton = null;  6.  7. private MySingleton(){  8. //私有化...
  • 单例模式---> 懒汉式 public class Student { private static Student instance = null; private Student() {} /** * 双重检索方式(效率最高) * * Thread-1---->...
  • public class Singleton { //volatile 防止指令重排 和可见性... 便返回 uniqueInstance,此时uniqueInstance已经实例化,但是此时线程2获得锁,如果没有第二个if块则会再次new 一个新的实例出来,就违反了单例的规则。
  • 1.饿汉式单例模式 GiantDragon (大龙)只有一只,通过私有化其构造方法,使得外部无法通过new 得到新的实例。 GiantDragon 提供了一个public static的getInstance方法,外部调用者通过该方法获取12行定义的对象,...
  • c++实现懒汉式单例的实例 class singleton { private: singleton() {} static singleton *p; public: static singleton *instance(); }; singleton *singleton::p = nullptr; singleton* singleton::instance()...
  • 单例模式无论在生活中还是在工程中都有很广泛...下面是实现的一个懒汉式单例模式的代码: #include &lt;iostream&gt; #include &lt;cstdio&gt; using std::cout; using std::endl; class Singlet...
  • 饿汉式单例模式是在类加载时就创建对象,懒汉式是在外界需要时创建对象。 二、饿汉式 饿汉式就是不管用不用,在类加载时都会先给你创建出来。这就好比快餐去了选好就可以吃,省去了点餐后等待时间。这是一种空间换...
  • 一般我们在项目开发中有时候常会遇到数据库的连接(不使用框架),我们常会在dao类中写一些通用的方法以供后面使用。一般的做法是哪里需要操作数据库的方法哪里就会创建一个对象,然后再引用对象...懒汉式单例顾名思...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,187
精华内容 19,674
关键字:

懒汉式单例模式

友情链接: VJOS.rar