单例模式又分为：饿汉式与懒汉式；

饿汉式：先初始化对象，
                一进内存，就已经创建好了对象
class Single{
        private Single(){};
        private static Single s=new Single();
        public static Single getInstance(){
        return s;
       }
}
懒汉式：对象是方法被调用时，才初始化，也叫对象的延迟加载
                类进内存时，对象还没有存在，只有调用了相应的方法，才建立对象
class Single{
        private Single(){};
        private static Single s=null;
        public static Single getInstance(){
                if(s==null){
                           s=new Single();
                }
                return s;
      }
}

如果用懒汉式的话，会遇到多线程并发的问题，多线程同时访问的话，会出问题，还得给 代码加锁，
   public static Single getInstance(){
                if(s==null){
                          synchronized(Single.class){
                                  if(s==null)
                                      s=new Single();
                          }           
                }
                return s;
      }
就会显的代码有点多，
所以建议大家用饿汉式，不会出现安全问题，

单例模式又分为：饿汉式与懒汉式；

饿汉式：先初始化对象，
                一进内存，就已经创建好了对象
class Single{
        private Single(){};
        private static Single s=new Single();
        public static Single getInstance(){
        return s;
       }
}
懒汉式：对象是方法被调用时，才初始化，也叫对象的延迟加载
                类进内存时，对象还没有存在，只有调用了相应的方法，才建立对象
class Single{
        private Single(){};
        private static Single s=null;
        public static Single getInstance(){
                if(s==null){
                           s=new Single();
                }
                return s;
      }
}

如果用懒汉式的话，会遇到多线程并发的问题，多线程同时访问的话，会出问题，还得给 代码加锁，
   public static Single getInstance(){
                if(s==null){
                          synchronized(Single.class){
                                  if(s==null)
                                      s=new Single();
                          }           
                }
                return s;
      }
就会显的代码有点多，
所以建议大家用饿汉式，不会出现安全问题，