黑马程序员技术交流社区

标题: 饿汉式，懒汉式具体的区别是怎么样的？？ [打印本页]

作者: 荣天 时间: 2012-5-15 16:41
标题: 饿汉式，懒汉式具体的区别是怎么样的？？
饿汉式，懒汉式具体的区别是怎么样的？？
单例模式的基本三步：

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

复制代码

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

作者: 荣天 时间: 2012-5-15 16:42
04 行的代码 private static Single s=new Single();

作者: It's_Zero 时间: 2012-5-15 16:51

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

复制代码

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

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

复制代码

作者: 刘克方 时间: 2012-5-15 16:55
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());
}
}
其主要区别就是创建的时机不同

作者: 荣天 时间: 2012-5-15 17:10

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

谢 :)谢:)

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

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

作者: ^.^晴天 时间: 2012-5-15 22:57
就用途而言：饿汉式开发时用的多，懒汉式面试是经常考，所以都重要，不用区别它的作用，都掌握就是，没坏处

作者: ^.^晴天 时间: 2012-5-15 23:07
就本身而言：饿汉式：类一加载，对象就存在，说的通俗点就是一上来就开吃，而懒汉式是，类加载时，没有对象，只有调用了getInstance方法时，才会创建对象，属于延迟加载

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

作者: 何周舟 时间: 2012-5-16 02:42
饿汉式延迟加载多线程中不加锁会有安全隐患为提高效率可以在锁外加一个对象是否为null判断提高些许效率不用每次都判断锁

作者: 荣天 时间: 2012-5-16 08:14
谢谢大家

作者: 邓杰 时间: 2012-5-16 09:30
/*
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!");
}
}

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2