谁能告诉我懒汉式和饿汉式的区别。。。

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

懒汉式：对象是方法被调用时，才初始化，
叫对象的延时加载。线程不安全。

饿汉式：先初始化对象。 线程安全。

懒汉式：对象是方法被调用时，才初始化
饿汉式：类一进内存，就已经创建好了对象

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

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

补充：懒汉式没有加私有的构造函数
从实现方式来讲他们最大的区别就是懒汉式是延时加载,
他是在需要的时候才创建对象,而饿汉式在虚拟机启动的时候就会创建,
使用的场合根据具体环境和个人习惯吧.

  饿汉式 是刚开始 就建立了对象  懒汉式 就是等到你用的时候才建立了对象  楼上正解 建议饿汉式

饿汉式：类一进内存，就已经创建好了对象。线程是安全的
懒汉式：类进内存，对象还没有存在，只有方法被调用时，才建立对象，也叫对象的延时加载。如果在创建实例对象时不加上synchronized则会导致对对象的访问不是线程安全的，效率没饿汉式高
      

噢噢、原来是这样的！！

/*饿汉式
类一进内存，就已经创建好了对象。线程是安全的 */
class Single
{
        private  static final Single s = new Single();
        private Single()
        public static Single getInstance()
        {
                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;
       
               
                }

               
                }
        }
}