黑马程序员技术交流社区

标题: 懒汉式和饿汉式在线程中的问题 [打印本页]

作者: 韩国军 时间: 2012-5-16 13:07
标题: 懒汉式和饿汉式在线程中的问题
懒汉式和饿汉式在多线程中有什么区别？具体的过程是怎么实现的？

作者: Zhang_qian 时间: 2012-5-16 13:53
(1)饿汉式开发用这种方式。
class Student
{
private Student(){}

private static Student s = new Student();

public static Student getInstance()
{
return s;
}
}
(2)懒汉式面试写这种方式。多线程的问题？
class Teacher
{
private Teacher(){}

private static Teacher t;

public static Teacher getInstance()
{
if(t==null)
{
t = new Teacher();
}
return t;
}
}

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

作者: 杨威 时间: 2012-5-16 14:03
懒汉式有安全隐患问题，

class Single
{
private static Single s = null;
private Single(){}
public static Single getInstance()
{
if (s==null)
s = new Single();
return s ;
}
}

复制代码

之所以称为懒汉式是Single类进内存对象还没有存在，只用调用了getInstance方法时，才创建对象。
而懒汉式是有安全问题的，因为s是共享数据，如果多个线程并发的访问getInstance方法，那就有可能共同在getInstance方法中操作，比如线程A在判断了s==null后挂起，而这时线程B在判断后也进入了，并一样的挂起。此时A醒了，new一个s对象，在这之后B线程也醒了，也new了一个对象，这就出现问题了，就违背了单例设计模式的初衷了。就要加入同步代码块来解决，麻烦。
饿汉式就不会出现这样的问题，看代码：

class Single
{
private static Single s = new Single();
private Single(){}
public static Single getInstance()
{
return s;
}
}

复制代码

Single类一进内存就已经创建好了对象，不会出现类似于懒汉的问题。我们使用单例就是因为要再内存中保证唯一对象，所以不建议使用懒汉式

作者: 韩慧阳 时间: 2012-5-16 15:16
懒汉式：
class Single

{

      private static Single s = null;

      private Single(){}

      public static Single getInstance()

      {

            if (s==null)

                     s = new Single();

            return s ;

      }

}
懒汉式在多线程中是不安全的，因为这个类的对象在内存中只有在调用getInstance()方法的时候才会被创建。而s又是static的，所以在多线程中有多个线程访问getInstance()
的时候，就需要同步代码块来保证安全问题。（为什么会不安全请看毕老师的那个售票系统的例子）。
class Single

{

      private static Single s = new Single();

      private Single(){}

      public static Single getInstance()

      {

            return s;

      }

}
饿汉式就不会出现这样的状况，因为它定义的static是它的类对象，也就是说它共享的是类对象，这样当有多个线程访问的时候多个线程操作的是同一个对象，那么每次调用方法就相当于一个对象在调用方法，这样就不会出现安全问题。
所以饿汉式是推荐使用的。懒汉式最好不在多线程中使用，会很麻烦。但是饿汉式也有它不好的地方，由于饿汉式在类加载时就完成了初始化，所以类加载较慢。不过相对获取对象的速度快。

使用中看需求吧，貌似饿汉式用的比懒汉式多很多。

作者: 潘东升 时间: 2012-5-16 16:02
   饿汗式和懒汉式在多线程中的区别
   饿汗式在多线程中，因为取得对象的getInstance方法体中只有一句返回对象语句，所以不会出现安全问题题。
      而懒汉式是延时加载的，就是被调用时实例才加载，问题就出现在这。如果多个线程同时调用，比如A,B两个线程同时调用，因为线程具有随机性，就有可能在实例没加载时，A通过if判断以后停住了，因为此时可能A没获取CPU执行权，而此时实例也还没被加载，也就是S==null，所以B获取CPU执行权有机会进来了，然后创建了对象，等到A获取执行权了以后，还会再创建一个新对象，这就是问题所在了，要解决这个问题，只能同步处理了，而同步处理有两种方式，同步函数和同步代码块，如果使用同步函数，在多线程调用时，每次都要同步判断，就会消耗资源，想要减少资源浪费，可以双重判断同步代码块，也就是下面这种形式。毕老师的day11-15讲的很清楚了，不懂再看看
//饿汗式
class Single
{
private static final Single s = new Single();
private  Single(){}
public static Single getInstance()
{
return s;
}

}
//懒汉式
class SingleLan
{
private static SingleLan s = null;
private  SingleLan(){}
public static SingleLan getInstance()
{
if (s==null)
{
return new SingleLan();
}
return s;
}
}
//以下方式解决懒汉式多线程安全问题
class SingleLan
{
private static SingleLan s = null;
private  SingleLan(){}
public static SingleLan getInstance()
{
if(s==null)
synchronized(SingleLan.class)
{
if (s==null)
{
return new SingleLan();
}
return new SingleLan();
}
return s;
}
}

作者: 黑马-王建雨 时间: 2012-5-16 16:34
1，饿汉式。先初始化对象。
class Single {
   Single s = new single();
   private Single(){}
   public static Single getInstance(){
   return s;
}
}

作者: 黑马-王建雨 时间: 2012-5-16 16:36
2，懒汉式（也称作延迟加载）。对象被调用时才初始化。
class Single{
   private static Single s = null;
   private Single(){}
   public static Single getInstance{
         if(s == null)
               s=new Single();
         return s;
   }
}
饿汉式特点：Single类一进内存，就已经创建好了对象。
懒汉式特点：Single类一进内存，对象还没有存在，只有调用getInstance方法时，才建立对象，这就称为延迟加载。
开发时：建议使用饿汉式。

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

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