精华内容
下载资源
问答
  • JAVA设计模式之单例模式

    万次阅读 多人点赞 2014-04-16 06:51:34
     java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。  单例模式有以下特点:  1、单例类只能有一个实例。  2、单例类必须自己创建自己的...

    本文继续介绍23种设计模式系列之单例模式。

    概念:
      java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。
      单例模式有以下特点:
      1、单例类只能有一个实例。
      2、单例类必须自己创建自己的唯一实例。
      3、单例类必须给所有其他对象提供这一实例。
      单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机,但只能有一个Printer Spooler,以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口,系统应当集中管理这些通信端口,以避免一个通信端口同时被两个请求同时调用。总之,选择单例模式就是为了避免不一致状态,避免政出多头。


    一、懒汉式单例

     

    //懒汉式单例类.在第一次调用的时候实例化自己 
    public class Singleton {
        private Singleton() {}
        private static Singleton single=null;
        //静态工厂方法 
        public static Singleton getInstance() {
             if (single == null) {  
                 single = new Singleton();
             }  
            return single;
        }
    }

     

    Singleton通过将构造方法限定为private避免了类在外部被实例化,在同一个虚拟机范围内,Singleton的唯一实例只能通过getInstance()方法访问。

    (事实上,通过Java反射机制是能够实例化构造方法为private的类的,那基本上会使所有的Java单例实现失效。此问题在此处不做讨论,姑且掩耳盗铃地认为反射机制不存在。)

    但是以上懒汉式单例的实现没有考虑线程安全问题,它是线程不安全的,并发环境下很可能出现多个Singleton实例,要实现线程安全,有以下三种方式,都是对getInstance这个方法改造,保证了懒汉式单例的线程安全,如果你第一次接触单例模式,对线程安全不是很了解,可以先跳过下面这三小条,去看饿汉式单例,等看完后面再回头考虑线程安全的问题:

     

    1、在getInstance方法上加同步

     

    public static synchronized Singleton getInstance() {
             if (single == null) {  
                 single = new Singleton();
             }  
            return single;
    }

     

     

     

    2、双重检查锁定

     

    public static Singleton getInstance() {
            if (singleton == null) {  
                synchronized (Singleton.class) {  
                   if (singleton == null) {  
                      singleton = new Singleton(); 
                   }  
                }  
            }  
            return singleton; 
        }

     

    3、静态内部类

     

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

    这种比上面1、2都好一些,既实现了线程安全,又避免了同步带来的性能影响。

     

     

     

     

     

     

    二、饿汉式单例

     

    //饿汉式单例类.在类初始化时,已经自行实例化 
    public class Singleton1 {
        private Singleton1() {}
        private static final Singleton1 single = new Singleton1();
        //静态工厂方法 
        public static Singleton1 getInstance() {
            return single;
        }
    }

    饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变,所以天生是线程安全的。

     

     

     

     

    三、登记式单例(可忽略)

    //类似Spring里面的方法,将类名注册,下次从里面直接获取。
    public class Singleton3 {
        private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();
        static{
            Singleton3 single = new Singleton3();
            map.put(single.getClass().getName(), single);
        }
        //保护的默认构造子
        protected Singleton3(){}
        //静态工厂方法,返还此类惟一的实例
        public static Singleton3 getInstance(String name) {
            if(name == null) {
                name = Singleton3.class.getName();
                System.out.println("name == null"+"--->name="+name);
            }
            if(map.get(name) == null) {
                try {
                    map.put(name, (Singleton3) Class.forName(name).newInstance());
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
            return map.get(name);
        }
        //一个示意性的商业方法
        public String about() {    
            return "Hello, I am RegSingleton.";    
        }    
        public static void main(String[] args) {
            Singleton3 single3 = Singleton3.getInstance(null);
            System.out.println(single3.about());
        }
    }

     登记式单例实际上维护了一组单例类的实例,将这些实例存放在一个Map(登记薄)中,对于已经登记过的实例,则从Map直接返回,对于没有登记的,则先登记,然后返回。 

    这里我对登记式单例标记了可忽略,我的理解来说,首先它用的比较少,另外其实内部实现还是用的饿汉式单例,因为其中的static方法块,它的单例在类被装载的时候就被实例化了。

     

    饿汉式和懒汉式区别

    从名字上来说,饿汉和懒汉,

    饿汉就是类一旦加载,就把单例初始化完成,保证getInstance的时候,单例是已经存在的了,

    而懒汉比较懒,只有当调用getInstance的时候,才回去初始化这个单例。

    另外从以下两点再区分以下这两种方式:

     

    1、线程安全:

    饿汉式天生就是线程安全的,可以直接用于多线程而不会出现问题,

    懒汉式本身是非线程安全的,为了实现线程安全有几种写法,分别是上面的1、2、3,这三种实现在资源加载和性能方面有些区别。


     

    2、资源加载和性能:

    饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,但是相应的,在第一次调用时速度也会更快,因为其资源已经初始化完成,

    而懒汉式顾名思义,会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。

    至于1、2、3这三种实现又有些区别,

    第1种,在方法调用上加了同步,虽然线程安全了,但是每次都要同步,会影响性能,毕竟99%的情况下是不需要同步的,

    第2种,在getInstance中做了两次null检查,确保了只有第一次调用单例的时候才会做同步,这样也是线程安全的,同时避免了每次都同步的性能损耗

    第3种,利用了classloader的机制来保证初始化instance时只有一个线程,所以也是线程安全的,同时没有性能损耗,所以一般我倾向于使用这一种。

     

    什么是线程安全?

    如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的,就是线程安全的。

    或者说:一个类或者程序所提供的接口对于线程来说是原子操作,或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题,那就是线程安全的。

     

    应用

    以下是一个单例类使用的例子,以懒汉式为例,这里为了保证线程安全,使用了双重检查锁定的方式:

     

    public class TestSingleton {
    	String name = null;
    
            private TestSingleton() {
    	}
    
    	private static volatile TestSingleton instance = null;
    
    	public static TestSingleton getInstance() {
               if (instance == null) {  
                 synchronized (TestSingleton.class) {  
                    if (instance == null) {  
                       instance = new TestSingleton(); 
                    }  
                 }  
               } 
               return instance;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public void printInfo() {
    		System.out.println("the name is " + name);
    	}
    
    }

    可以看到里面加了volatile关键字来声明单例对象,既然synchronized已经起到了多线程下原子性、有序性、可见性的作用,为什么还要加volatile呢,原因已经在下面评论中提到,

    还有疑问可参考http://www.iteye.com/topic/652440
    和http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

     

     

     

    public class TMain {
    	public static void main(String[] args){
    		TestStream ts1 = TestSingleton.getInstance();
    		ts1.setName("jason");
    		TestStream ts2 = TestSingleton.getInstance();
    		ts2.setName("0539");
    		
    		ts1.printInfo();
    		ts2.printInfo();
    		
    		if(ts1 == ts2){
    			System.out.println("创建的是同一个实例");
    		}else{
    			System.out.println("创建的不是同一个实例");
    		}
    	}
    }
    

     运行结果:

    结论:由结果可以得知单例模式为一个面向对象的应用程序提供了对象惟一的访问点,不管它实现何种功能,整个应用程序都会同享一个实例对象。

    对于单例模式的几种实现方式,知道饿汉式和懒汉式的区别,线程安全,资源加载的时机,还有懒汉式为了实现线程安全的3种方式的细微差别。

    更多设计模式:23种设计模式系列

    作者:jason0539

    博客:http://blog.csdn.net/jason0539(转载请说明出处)

    展开全文
  • java安全单例模式

    单例设计模式中的懒汉式:

    //饿汉式:
    class Single
    {
    private static final Single s = new Single();
    private Single(){}
    public static Single getInstance()
    {

      if(s == null)
    s = new Single();

    return s;
    }
    }

    当多个线程并发访问该方法时,有可能出现线程安全问题。

    所以在getInstance方法上加入了同步。

    class Single
    {
    private static Single s = null;
    private Single(){}
    public static  Single getInstance()
    {
    if(s==null)
    {
    synchronized(Single.class)
    {
    if(s == null)
    s = new Single();
    }
    }
    return s;
    }
    }


    虽然解决了安全问题。但是效率降低了,可以通过双重判断的形式进行一下优化。


    class Single
    {
    private static Single s = null;
    private Single(){}
    public static  Single getInstance()
    {
    if(s==null)
    {
    synchronized(Single.class)
    {
    if(s == null)
    s = new Single();
    }
    }
    return s;
    }
    }


    //饿汉模式:
    class Single
    {
    private static final Single s = new Single();
    private Single(){}
    public static Single getInstance()
    {
    return s;
    }
    }

    展开全文
  • JavaDLC单例模式

    2019-11-28 18:58:33
    Java DLC单例模式 懒汉式单例模式 public void Singleton{ //私有化静态对象 private static Singleton singleton; //私有化构造方法 private Singleton(){} //公有的get对象方法 public static Singleton ...

    Java DLC单例模式

    懒汉式单例模式

    public void Singleton{
        //私有化静态对象
        private static Singleton singleton;
        //私有化构造方法
        private Singleton(){}
        //公有的get对象方法
        public static Singleton getInstance(){
            if(singleton==null){
                //当需要调用是,才会new对象
                singleton=new Singleton();
            }
            return singleton;
        }
    }
    

    这种方法在单线程模式下是可取的,但是在并发情况下无法保证线程安全,可以加一个synchronized关键字进行优化

    public void Singleton{
        //私有化静态对象
        private static Singleton singleton;
        //私有化构造方法
        private Singleton(){}
        //公有的get对象方法
        public static Singleton getInstance(){
            synchronized(Singleton.class) {
                if(singleton==null){
                    //当需要调用是,才会new对象
                    singleton=new Singleton();
                }
            }
            return singleton;
        }
    }
    

    但是上述代码也有问题,singleton=new Singleton();分为三步执行,首先会为对象分配内存空间,然后初始化对象,最后返回对象的引用,但由于jvm编译器的优化产生的重排序缘故,步骤2、3可能会发生重排序,可能会导致return的对象为null

    饿汉式单例模式

    public void Singleton{
        //直接new好对象
        private static Singleton singleton = new Singleton();
    
        private Singleton(){}
    
        public static Singleton getInstance(){
            return singleton;
        }
    }
    

    DCL:Double Checked Locking (双重检查锁定)

    ​单例模式(懒汉式的基础上加入并发控制):在多线程环境下,对外存在一个对象

    • 1.构造器私有化(避免外部new构造器)

    • 2.提供私有的静态属性(存储对象的地址)

    • 3.提供共有的静态方法(获取属性)

      public class TestDcl{
          //提供私有的静态属性(存储对象的地址)
          //加入volatile防止其他线程可能访问一个为null的对象
          private volatile static TestDcl instance;
      
          //构造器私有化(避免外部new构造器)
          private TestDcl() {
      
          }
      
          public static TestDcl getInstance() {
              //double检测
              //如果已经有对象,防止再次创建
              if (null != instance) {
              	return instance;
              }
              //有两个线程A B,A进来发现无对象,创建对象
              //此时B也进来,发现无对象,也创建对象,这样就有两个对象
              synchronized(TestDcl.class) {
                  if (instance == null) {
                      //1.为对象分配内存空间    2.初始化对象    3.返回对象的引用
                      //但由于jvm编译器的优化产生的重排序缘故,步骤2、3可能会发生重排序
                      //利用volatile的特性即可阻止重排序和可见性
                      instance = new TestDcl();
                  }
              }
              return instance;
          }
      
          public static void main(String[] args) {
              new Thread(()->{
                  System.out.println(TestDcl.getInstance().toString());
              })start();
      
              System.out.println(TestDcl.getInstance());
      
          }
      }
      
    展开全文
  • Java实现单例模式

    2019-06-19 18:07:17
    Java实现单例模式单例模式懒汉式单例饿汉式单例登记式单例 单例模式 单例是一种常见的设计模式,在各大框架中经常见到,例如Spring中的SpringBean默认就是单例,单例模式需要保证整个系统中单例模式的类只能存在一个...

    单例模式

    单例是一种常见的设计模式,在各大框架中经常见到,例如Spring中的SpringBean默认就是单例,单例模式需要保证整个系统中单例模式的类只能存在一个实例。Java实现简单的单例模式可以大致有三种实现方式:饿汉式、懒汉式、登记式。

    懒汉式单例

    public class SingleTon {
        private static SingleTon singleTon = null;
        private SingleTon() {}
        public static SingleTon getInstance() {
            if (singleTon == null) {
                singleTon = new SingleTon();
            }
            return singleTon;
        }
    }
    

    这里构造方法使用了private修饰,防止被外部显式调用初始化(忽略反射这茬)。只有在getInstance()中可以获取单例对象singleton,单线程情况下没有问题,但是如果在多线程的情况下会出现线程不安全问题,导致创建了多个对象。

    • 添加锁。在getInstance()方法上添加内部锁,或者ReentrantLock,保证线程的安全,但是加锁开销大。
    //加内部锁的例子
    public class SingleTon {
        private static SingleTon singleTon = null;
        private SingleTon() {}
        public static synchronized SingleTon getInstance() {
            if (singleTon == null) {
                singleTon = new SingleTon();
            }
            return singleTon;
        }
    }
    
    • 双重检查锁定:
    public static Singleton getInstance() {
            if (singleton == null) {  
                synchronized (Singleton.class) {  
                   if (singleton == null) {  
                      singleton = new Singleton(); 
                   }  
                }  
            }  
            return singleton; 
        }
    

    这里需要注意为什么写了两个判断空的操作?如果只有一个外层的判空:

    public static Singleton getInstance() {
            if (singleton == null) {  
                synchronized (Singleton.class) {  
                      singleton = new Singleton(); 
                }  
            }  
            return singleton; 
        }
    

    那么在多线程情况下可能会有多个线程判断singleton == null,进入锁池等待获得同步锁,但是只要有一个线程执行完同步代码,单例对象就已经被创建了。后序争取到锁的线程继续执行同步代码块依然会创建新的对象,就违反了单例的原则。那么双重判断就好理解了,获取到锁后内部再进行一次判断,如果创建了就直接返回。

    • 静态内部类形式
    public class SingleTon {
        private SingleTon() {}
    
        public static SingleTon getInstance() {
            return InitSingleTon.singleTon;
        }
    
        private static class InitSingleTon{
            private final static SingleTon singleTon = new SingleTon();
        }
    }
    

    这里在单例类的内部创建了静态内部类,在静态内部类中创建了静态的单例类对象。使用静态内部类的方式可以保证多线程环境下获取单例对象的线程安全性。

    静态内部类的优点在于

    外部类加载时并不需要立即加载内部类,同理内部类没有加载那么就不会去初始化内部类中的静态成员变量,只有在第一次调用getInstance()方法时才会进行初始化,类似于懒加载。

    静态内部类是如何保证线程安全的呢?
    JVM会保证一个类的初始化过程在多线程中被正确的加锁同步,如果多个线程同时去初始化一个类,那么只有一个类会真正去执行初始化方法,其他线程需要阻塞等待。

    `静态内部类的缺点:`

    静态内部类由于使用的是内部类,那么如果在单例对象中有参数需要设置时使用静态内部类将无法传递。

    饿汉式单例

    public class SingleTon {
        private static final SingleTon singleTon = new SingleTon();
        private SingleTon() {}
        public static SingleTon getInstance() {
            return singleTon;
        } 
    }
    

    从代码中可见,当SingleTon 类初始化时,单例对象也已经被初始化了,所以不存在线程不安全问题。

    登记式单例

    在Spring中管理单例对象使用的就是登记式单例,一个Hash,key为类名,value为单例对象。

    //类似Spring里面的方法,将类名注册,下次从里面直接获取。
    public class Singleton {
        private static Map<String,Singleton> map = new HashMap<String,Singleton>();
        static{
            Singleton single = new Singleton();
            map.put(single.getClass().getName(), single);
        }
        
        protected Singleton(){}
        public static Singleton getInstance(String name) {
            if(name == null) {
                return null;
            }
            if(map.get(name) == null) {
                try {
                    map.put(name, (Singleton) Class.forName(name).newInstance());
                } catch (InstantiationException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            }
            return map.get(name);
        }
    }
    

    其实也很简单,内部是一个恶汉式的加载,只不过多了个根据name拿对象的过程。

    展开全文
  • Java单例模式

    千次阅读 2018-07-29 20:49:47
    最近在阅读《Effective Java 》这本书...单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。 在应用这个模式时,单例对象的类必...
  • 设计模式-Java实现单例模式单例模式是一种常见的设计模式,许多时候系统只需要一个全局的对象时可以运用单例模式,它确保在系统中某种类只能有一个实例它的特点有: 类最多只能拥有一个实例对象 类自己创建唯一实例...
  • Java-单例模式

    2017-07-26 11:50:09
    单例模式的概念: 单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例,而且自行实例化并向整个系统提供这个实例。这个类称为单例类。 单例模式的核心: 1.一个类只有一个实例  2....
  • 主要介绍了Java 单例模式线程安全问题的相关资料,希望通过本文大家能了解掌握单例模式中线程安全的使用方法,需要的朋友可以参考下
  • java单例模式

    2016-05-15 16:54:31
     单例模式java最基础,最常用的一种模式之一。单例模式使一个类在整个运用程序中仅有一个对象。单例模式主要分为:饿汉模式,懒汉模式。下面将用代码简单介绍一下这两种模式:  1、饿汉模式  饿汉模式是在类...
  • JAVA单例模式

    2018-03-05 11:13:21
    1.单例模式简介 单例模式Java中最简单的一种设计模式,它是一种对象创建型模式,该单例负责自主的创建自己的对象,同时确保系统内只有单个对象被创建了;单例模式主要分为饿汉式和懒汉式单例,饿汉式属于立即加载...
  • Java —— 单例模式

    2019-07-22 09:17:47
    单例模式Java最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时保证只有单个对象被创建。这个类提供了一种...
  • 使用静态内部类实现线程安全单例模式 多线程 单例模式 单例模式是一种常用的软件设计模式。 在它的核心结构中只包含一个被成为单例类的特殊类。通过单例模式可以保证系统中一个类职业一个实例而且该实例易于外界...
  • java单例模式

    2014-05-06 13:25:50
    1.什么是单例模式  单例模式java
  • JAVA枚举单例模式

    2015-10-17 22:45:51
    关于单例模式的实现有很多种,网上也分析了如今实现单利模式最好用枚举,好处不外乎三点:1.线程安全 2.不会因为序列化而产生新实例 3.防止反射攻击 关于第二点序列化问题,有一篇文章说枚举类自己实现了...
  • JAVA-单例模式

    千次阅读 2019-08-28 20:24:15
    单例模式 JAVA类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。 特点 - 单例模式类,只能有一个实例 - 单例类必须自己创建...
  • Java单例模式

    2015-07-04 17:15:11
    单例模式是算是java常见的23中设计模式中最常用、也是最简单的一种设计模式了;其核心思想是确保一个类的对象在内存中有且只有一个,这个对象的所有属性的值在内存中始终保持一致性,调用者只能获取这个实例修改里面...
  •  java中单例模式是一种常见的设计模式,单例模式的写法有好几种,这里主要介绍三种:懒汉式单例、饿汉式单例、登记式单例。  单例模式有以下特点: 1、单例类只能有一个实例。 2、单例类必须自己创建自己的唯一...
  • JAVA理解单例模式

    2015-11-10 23:01:14
    单例模式,英文名为:Singleton pattern。首先,我们先去理解字面意思。Singleton:一个,独身。pattern:模式,图案,样品。在字面上,可以理解为“一个样品”。哈哈。再来看看特点:  - 只能有一个实例 - ...
  • JAVA实现单例模式

    2018-04-04 21:03:23
    一个教室只有一块黑板,不管上Java课,还是Android课,或者项目管理课的老师都只使用这一块黑板问题:希望一个类只能有一个实例存在解决方案:单例模式、static单例模式有很多种写法第一种:这种方式是非线程安全的...
  • Java单例模式及双锁检测

    千次阅读 2018-07-17 19:53:41
    Java单例模式及双锁检测 作为开发的我们对单例模式肯定不会陌生,毕竟项目中用到它的地方相当多。 一般我们都知道单例模式有两种写法,延迟加载(又叫饿汉式),意思很好懂,只有用到的时候才创建(饿汉,只有饿...
  • Java实现单例模式总结

    2015-02-28 22:17:50
    单例模式(Singleton):是一种常用的设计模式。在Java应用中,单例对象能保证在一个JVM中,该对象只有一个实例存在。 1、懒汉式 线程不安全,当有多个线程并行调用 getInstance() 的时候,就会创建多个实例。 ...
  • java单例模式

    万次阅读 多人点赞 2018-05-25 14:59:26
    紧接着,我们给出了单例模式在单线程环境下的两种经典实现:饿汉式和懒汉式,但是饿汉式是线程安全的,而懒汉式是非线程安全的。在多线程环境下,我们特别介绍了五种方式来在多线程环境下创建线程安全的单例,即分别...
  • java 实现单例模式

    2014-03-21 15:36:20
    java中单例模式是一种常见的设计模式,单例模式分三种:懒汉式单例、饿汉式单例、登记式单例三种。  单例模式有一下特点:  1、单例类只能有一个实例。  2、单例类必须自己自己创建自己的唯一实例。  3、单例类...
  • 答案是:单例模式的static方法和非static方法是否是线程安全的,与单例模式无关。也就说,如果static方法或者非static方法不是线程安全的,那么不会因为这个类使用了单例模式,而变的安全。 闲话休说,看代码:...
  • java 单例模式 最经典的例子

    千次阅读 2018-06-07 15:33:43
    java中单例模式是一种常见的设计模式,单例模式分三种:懒汉式单例、饿汉式单例、登记式单例三种。  单例模式有一下特点:  1、单例类只能有一个实例。  2、单例类必须自己自己创建自己的唯一实例。  3、单例类...
  • java单例模式是一种常见的设计模式。 单例模式有以下特点: 单例类只能有一个实例; 单例类必须自己创建自己的唯一实例; 单例类必须给所有其他对象提供这一实例; 2. 优缺点 优点:由于单例模式只生成了一个实例...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 95,069
精华内容 38,027
关键字:

java安全单例模式

java 订阅