单例设计模式的饿汉式和懒汉式有什么区别？用代码举例详细说明他们之间的区别表现在哪里？

饿汉式:
  public class Singleton{
      private static Singleton singleton = new Singleton ();
      private Singleton (){}
      public static Singleton getInstance(){
           return singletion;
      }
  }

  懒汉式:
  public class Singleton{
      private static Singleton singleton = null;
      private Singleton (){}
      public static synchronized getInstance(){
          if(singleton==null){
              singleton = new Singleton();
          }
          return singleton;
      }
  }

  比较:
  饿汉式是线程安全的,在类创建的同时就已经创建好一个静态的对象供系统使用,以后不在改变。
  懒汉式是延时加载,他是在需要的时候才创建对象，懒汉式如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的。
  推荐使用第一种  

们从辛辣面的BLOG里取它的例子来说明一下.
public class Singleton {
        private Singleton(){}
        private static Singleton instance = new Singleton();
        public static Singleton getInstance() {
    　　　　return instance;
        }
    }
这个就是一个很常用的饿汉式单例模式,非常容易理解,也就是说只要客户端调用方法:Singleton.getInstance() 就可以使用这个实例,而且是唯一实例.这种使用方式丝毫没有什么限制,任何客户端只要使用该语句就必然可以创建实例.从JAVA语言来说这种方式是最能表现单例模式的了.
同样我们说明懒汉式单例模式仍然使用辛辣面的一个例子:
public class Singleton {
        private Singleton(){}
        private static Singleton instance = null;
        public static synchronized Singleton getInstance() {
    　　　　if (instance == null) {
    　　　　    instance = new Singleton();
    　　　　}
    　　　　return instance;
        }
    }
这也是一个单例模式,但是他和饿汉式有区别,它在创建时使用了线程标示synchronized ,而且在创建时进行了if (instance == null) {
    　　　　    instance = new Singleton();
}

public class Single {
private static Single s=null;
private Single (){
       
}
public  static Single getInstence (){
        if(s==null){
                synchronized(Single.class){
                        if(s==null){
                                 s=new Single();
                        }
                }
        }
        return s;
}
}
单例延迟加载的实例是懒汉式，但多线程时会产生异常，直接加锁又会多次判断，降低效率，这时可以使用双层判断来减少判断次数