1. class Singleton{
   
2.       private Singleton(){}
   
3.      
   
4.       private static class SingletonContainer{
   
5.             private static Singleton si = new Singleton();
   
6.      }
   
7.      
   
8.       public static Singleton getSingleton(){
   
9.             return SingletonContainer. si;
   
10.      }
    
11. }
    

复制代码

1.上面这个单例类会不会有多线程的问题？到底是懒汉式还是饿汉式？解释下
2.用多线程的方式解决了懒汉式的问题，我想问能不能用代码写出来，我说的是能运行的代码？

private static GlobalConfig instance = null;  
    private Vector properties = null;  
    private GlobalConfig() {  
      //Load configuration information from DB or file  
      //Set values for properties  
    }  
    private static synchronized void syncInit() {  
      if (instance == null) {  
        instance = new GlobalConfig();  
      }  
    }  
    public static GlobalConfig getInstance() {  
      if (instance == null) {  
        syncInit();  
      }  
      return instance;  
    }  
    public Vector getProperties() {  
      return properties;  
    }  
同时更新某些属性的实例

1.你这个是饿汉式。懒汉式：对象在方法被调用时才初始化，也叫对象的延时加载
饿汉式：类进存，对象还没有存在，只能调用其对外的方法才能创建对象。
开发是一般都用饿汉式
2.多线程解决懒汉式的问题
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;
        }
}
这样就行了

懒汉式的特点在于实例的延时加载，如果多线程时会出现安全问题。如何解决，加同步
用双重判断的方式，但会有效率问题，加同步的时候使用的锁是哪个，该类在内存中的
字节码