黑马程序员技术交流社区

标题: java中用到的单例设计模式小问题！ [打印本页]

作者: 吴华二 时间: 2012-3-27 00:46
标题: java中用到的单例设计模式小问题！
在听了单例模式那一小节时，突然有一个小的想法，单例设计模式中懒汉式和饿汉式之间有什么不同？有必要区分这两形式吗？本人认为区分这两种形式没必要，都是不管调用多少次getInstance方法，返回的都是同一个实例对象。如果要区分，它们之间有什么好处呢？什么情况下用懒汉式？什么情况又用饿汉式呢？求解...

作者: 1002865186 时间: 2012-3-27 00:58
饿汉式:
  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则会导致对对象的访问不是线程安全的
  推荐使用第一种

作者: 贠(yun)靖 时间: 2012-3-27 05:03
懒汉式  是只要你不调用该类中的getInstance 方法  他就不会创建对象，只有在调用这个方法的时候才会创建该类对象
         还有就是懒汉是线程不安全需要加锁让其同步
  饿汉式  是不管你调用不调用getInstance方法  它都会创建该类对象，  而这个线程安全
虽然两个创建对象有所不同但是因为都是静态的  不管怎么样这个东西都会加载到内存的所以一般还是推荐使用饿汉式

作者: 胡元 时间: 2012-3-27 05:05
借用下一楼的代码：饿汉式:
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;
}
}
饿汉式就是在类加载的时候就创建一个对象，以后不再重复创建，并且线程安全。
懒汉式请看这里：
if(singleton==null){
singleton = new Singleton();
如果有两个线程，第一个运行if的时候满足条件但是需要休息一下，而第二个线程又进来了，执行if语句仍然满足，于是创建对象，第一个醒来后又创建了对象，就创建两个对象了，所以不安全，建议使用第一种！

作者: 许飞翔 时间: 2012-3-27 07:49
饿汉式是类加载后就创建一个对象，且线程是安全的；
懒汉式是在调用时才创建该类对象，由于在多线程访问时懒汉式可能会出现创建出多个实例，会出现安全问题，进而对其使用synchronized进行加锁，这样做降低程序的执行效率和降低程序的性能。
所以，建议使用饿汉式

作者: 魏明明 时间: 2012-3-27 23:04
。
饿汉式:
这个是先初始化对象,Single类一进内存，就已经创建好了对象。语句简单，线程安全。效率高
class Single
{
private Single(){}
private static Single s = new Single();
public static Single getInstance()
{
return s;
}
}

懒汉式：对象是方法呗调用时，才初始化。也叫做对象的延时加载。
Single类进内存，对象还没有存在，只有调用了getInstance方法是，才建立对象。线程不安全，得使用sychronized 线程安全，并进行双判断使效率提高

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;
}

}

综上所述：定义单例，建议使用饿汉式，懒汉式在面试的时候能说出来就可以了。

作者: 王思兰 时间: 2012-3-27 23:09
  单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点；

   1、只能有一个实例对象，所以构造函数要私有化，

   2、私有化后，外部不能新建对象，在内部新建一个本类对象，

   3、并且在本类里提供一个可供外部访问的静态方法getInstance()，一开始就要被加载。

   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)
                           s = new Single();
                     return s;
            }
   }这种被称为懒汉式，对象在方法调用时才初始化，也叫做对象的延迟加载，Single类进内存，对象没建立，只有调用了getInstance方法时，才建立对象，多线程用不安全，可以在getInstance加上synchronized同步，但是效率就低了，可以在if判断语句外部在加一个判断，这样就不用，每次都加锁，
            public static Single getInstance()
            {
                     if(s==null)
                     {

                           synchronized(Single.class)

                                                {

                                                                     if(s==null)
                                                s = new Single();

                                                }

                     }

                     return s;
            }

作者: 抓哇 时间: 2012-3-28 10:34
迷惑了都是说饿汉式好那懒汉式有哪里好整他出来做什么仅仅是延伸出延长加载的概念吗

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

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