饿汉式，懒汉式具体的区别是怎么样的？？
单例模式的基本三步：

1. private Single(){//如果私有  其他就不能创建对象
   
2.                
   
3.         }
   
4.        [b] [color=Red]private static Single s=new Single(); [/color]  [/b] //饿，懒汉式除了s=null  ，ss=new Single();  还有什么区别？ 用法上的不同呢？
   
5.         public static Single getInstance(){ //static方便类名的调用
   
6.                 return s;  
   
7.         }

复制代码

private static Single s=new Single();    //饿，懒汉式除了s=null  ，ss=new Single();  还有什么区别？ 用法上的不同呢？       看到这里有点模糊    麻烦大家      谢谢:)

04  行的代码    private static Single s=new Single();

1. private Single(){//如果私有  其他就不能创建对象
   
2.                
   
3.         }
   
4.        [b] [color=Red]private static Single s=new Single(); [/color]  [/b] //饿，懒汉式除了s=null  ，ss=new Single();  还有什么区别？ 用法上的不同呢？
   
5.         public static Single getInstance(){ //static方便类名的调用
   
6.                 return s;  
   
7.         }

复制代码

饿汉式和懒汉式除了在创建的时刻不同外,其他都是一样的,都是只创建了 一个对象

1. public static Single getInstance(){ //static方便类名的调用  并不只有这个原因,  你想如果不能创建对象,又怎么引用对象里的方法呢？所以采用静态修饰获取对象
   
2.                 return s;  
   
3.         }

复制代码

public class Singleton {  
    /*
     *
     * 懒汉式单例:只有在第一次请求实例的时候创建,并且只在第一次创建后,以后不再创建该类的实例
     */  
      
    // 1.一个私有的指向自己的静态变量  
    private static Singleton instance;  
      
    // 2.私有的构造方法,保证不能从外部创建对象  
    private Singleton(){}  
      
    // 3.公开的静态工厂方法,返回该类的唯一实例(当发现没有实例没有初始化的时候才初始化)  
    public static Singleton getInstance(){  
        if(instance == null){  
            instance = new Singleton();  
            System.out.println("创建Singleton类的实例");  
        }else {  
            System.out.println("实例已经创建,不能再创建");  
        }  
        return instance;  
    }  
      
}  
  
  
  
  
//　测试类  
class Test{  
    public static void main(String[] args) {  
        Singleton s = Singleton.getInstance();  
        System.out.println(Singleton.getInstance());  
        System.out.println(Singleton.getInstance());  
        System.out.println(Singleton.getInstance());  
    }  
}  

饿汉式：
Java代码  
public class Singleton2 {  
    /*
     * 恶汉单例模式:在类加载的时候就创建一个单例模式.
     */  
      
    // 1.私有的构造函数,确保不能在类的外部访问该类的构造函数  
    private Singleton2(){  
        System.out.println("构造函数执行了");  
    }  
      
    // 2.私有的唯一的静态实例变量,在类加载的时候就创建好单例对象  
    private final static Singleton2 instance = new Singleton2();  
      
    // 3.公开的静态工厂返回此类的唯一实例  
    public static Singleton2 getInstance(){  
        return instance;  
    }  
}  
  
// 测试类  
class Test2{  
    public static void main(String[] args) {  
        Singleton2 s = Singleton2.getInstance();  
        System.out.println(s);  
        Singleton2 s2 = Singleton2.getInstance();  
        System.out.println(s2);  
        System.out.println(Singleton2.getInstance());  
        System.out.println(Singleton2.getInstance());  
    }  
}  
其主要区别就是创建的时机不同

It's_Zero 发表于 2012-5-15 16:51
饿汉式和懒汉式除了在创建的时刻不同外,其他都是一样的,都是只创建了 一个对象 ...

谢 :)谢:)

饿汉式是线程安全的 , 在类创建的同时就已经创建好一个静态的对象供系统使用 , 以后不在改变
懒汉式如果在创建实例对象时不加上synchronized 则会导致对对象的访问不是线程安全的
懒汉式没有加私有的构造函数
从实现方式来讲他们最大的区别就是懒汉式是延时加载,
他是在需要的时候才创建对象,而饿汉式在虚拟机启动的时候就会创建。

基本的区别就是一个是在刚加载类时就创建对象，一个是调用该类的构造时才创建对象，
还有一个区别是：赖汉式的单例，如果是多线程操作会有线程的安全问题，赖汉式如果要多线程来操作的话要加同步代码块。

就用途而言：饿汉式开发时用的多，懒汉式面试是经常考，所以都重要，不用区别它的作用，都掌握就是，没坏处

就本身而言：饿汉式：类一加载，对象就存在，说的通俗点就是一上来就开吃，而懒汉式是，类加载时，没有对象，只有调用了getInstance方法时，才会创建对象，属于延迟加载

饿汉---很饿，所以上来就吃，先new 一下，一般开发都是用这个。
懒汉---比较懒，别人催他，打他，才会很不情愿的new个对象，懒汉，在多线程的时候容易出错，主要用来做延迟加载，

饿汉式 延迟加载 多线程中不加锁 会有安全隐患 为提高效率 可以在 锁外加一个对象是否为null判断提高些许效率 不用每次都判断锁

谢谢 大家  

/*
Single类一进内存，就已经创建好了对象。
class Single
{
        private static 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;
        }
}
//对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。
//Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象.

//定义单例，建议使用饿汉式。懒汉式有安全隐患；要用到同步锁才能解除隐患；比较复杂；

class  
{
        public static void main(String[] args)
        {
                System.out.println("Hello World!");
        }
}