黑马程序员技术交流社区

标题: 单例模式有什么好处？ [打印本页]

---

作者: 赵江锋    时间: 2011-9-24 21:49
标题: 单例模式有什么好处？
单例模式有什么好处？怎么用

---

作者: 丁朋伟    时间: 2011-9-24 22:08
单例模式主要作用是保证程序中，一个类Class只有一个实例存在，还可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收
他有三个特点
1、单例类确保自己只有一个实例。
2、单例类必须自己创建自己的实例。
3、单例类必须为其他对象提供唯一的实例。
单例的实现方式：饥汉模式和饿汉模式

/*饱汉模式创建单例
                private MyThreadScopeData(){}
                private static MyThreadScopeData instance = new MyThreadScopeData();
                public synchronized MyThreadScopeData getInstance(){
                        return instance;
                }
                */
               
                /* 饥汉模式创建单例
                private MyThreadScopeData(){}
                private static MyThreadScopeData instance = null;
                public synchronized MyThreadScopeData getInstance(){
                        if(instance == null){
                                instance = new MyThreadScopeData();
                        }
                        return instance;
                }
                */
这是我在学习张孝祥老师的线程视频是总结的
更详细内容请看我的转摘http://www.cnblogs.com/1350995917ding

---

作者: 匿名    时间: 2011-9-24 22:59
刚刚看完毕老师多线程中提到的 .这里卖弄一下啦..!

饿汉式:
  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则会导致对对象的访问不是线程安全的
  推荐使用第一种

---

作者: 匿名    时间: 2011-9-24 23:21
都不错！看的很认真！继续努力！

---

作者: 匿名    时间: 2011-9-25 10:23
最显而易见的好处是，节约开销，比如数据库链接单例的好处是，每次你只要去获取那个数据库的实例就好，不用每次去创建一个实例

---

作者: 匿名    时间: 2011-9-25 10:29
标题: 回复 楼主 的帖子
Java Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。 使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。

---

作者: 徐西宏    时间: 2011-9-25 14:41
单例模式顾名思义，及保证一个类只有一个实例
单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。
单例模式特点：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

一、懒汉式单例

在类被加载的时候，唯一实例已经被创建。
/**

<> 单例模式-懒汉式单例

*/

public class LazySingleton {

     /**

      * 私有静态对象,加载时候不做初始化

      */

     private static LazySingleton m_intance=null;

     /**

      * 私有构造方法,避免外部创建实例

      */

     private LazySingleton(){

     }

     /**

      * 静态工厂方法,返回此类的唯一实例.  

      * 当发现实例没有初始化的时候,才初始化.

      * @return LazySingleton

      */

     synchronized public static LazySingleton getInstance(){

         if(m_intance==null){

             m_intance=new LazySingleton();

         }

         return m_intance;

     }

}

二、饿汉式单例

在类加载的时候不创建单例实例。只有在第一次请求实例的时候的时候创建，并且只在第一次创建后，以后不再创建该类的实例。

/**

* <> 单例模式-饿汉式单例

*/

public class EagerSingleton {

     /**

      * 私有的(private)唯一(static final)实例成员,在类加载的时候就创建好了单例对象

      */

     private static final EagerSingleton m_instance = new EagerSingleton();

     /**

      * 私有构造方法,避免外部创建实例

      */

     private EagerSingleton() {

     }

     /**

      * 静态工厂方法,返回此类的唯一实例.

      * @return EagerSingleton

      */

     public static EagerSingleton getInstance() {

         return m_instance;

     }

}

三、登记式单例

这个单例实际上维护的是一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从工厂直接返回，对于没有登记的，则先登记，而后返回。

/**

* <> 单例模式- 登记式单例

*/

public class RegSingleton {

     /**

      * 登记薄,用来存放所有登记的实例

      */

     private static Map m_registry = new HashMap();

     //在类加载的时候添加一个实例到登记薄

     static {

         RegSingleton x = new RegSingleton();

         m_registry.put(x.getClass().getName(), x);

     }

     /**

      * 受保护的默认构造方法

      */

     protected RegSingleton() {

     }

     /**

      * 静态工厂方法,返回指定登记对象的唯一实例;

      * 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回

      * @param name

      * @return RegSingleton

      */

     public static RegSingleton getInstance(String name) {

         if (name == null) {

             name = "RegSingleton";

         }

         if (m_registry.get(name) == null) {

             try {

                 m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());

             } catch (InstantiationException e) {

                 e.printStackTrace();

             } catch (IllegalAccessException e) {

                 e.printStackTrace();

             } catch (ClassNotFoundException e) {

                 e.printStackTrace();

             }

         }

         return m_registry.get(name);

     }


     public String about() {

         return "Hello,I am RegSingleton!";

     }
}
代码出自设计模式一书，楼主可以去网上下载看看
[ 本帖最后由 徐西宏 于 2011-09-25  14:46 编辑 ]

---

作者: 匿名    时间: 2011-9-27 18:46
单例设计模式就是为了让一个类只能产生一个对象，这样就可以让多个对象的引用都指向一个对象，这就达到了资源共享的效果。单例设计模式分为懒汉式和饿汉式两种：
/**

* <> 单例模式- 登记式单例

*/

public class RegSingleton {

     /**

      * 登记薄,用来存放所有登记的实例

      */

     private static Map m_registry = new HashMap();

     //在类加载的时候添加一个实例到登记薄

     static {

         RegSingleton x = new RegSingleton();

         m_registry.put(x.getClass().getName(), x);

     }

     /**

      * 受保护的默认构造方法

      */

     protected RegSingleton() {

     }

     /**

      * 静态工厂方法,返回指定登记对象的唯一实例;

      * 对于已登记的直接取出返回,对于还未登记的,先登记,然后取出返回

      * @param name

      * @return RegSingleton

      */

     public static RegSingleton getInstance(String name) {

         if (name == null) {

             name = "RegSingleton";

         }

         if (m_registry.get(name) == null) {

             try {

                 m_registry.put(name, (RegSingleton) Class.forName(name).newInstance());

             } catch (InstantiationException e) {

                 e.printStackTrace();

             } catch (IllegalAccessException e) {

                 e.printStackTrace();

             } catch (ClassNotFoundException e) {

                 e.printStackTrace();

             }

         }

         return m_registry.get(name);

     }


     public String about() {

         return "Hello,I am RegSingleton!";

     }
}

---

作者: 匿名    时间: 2011-9-27 19:55
标题: 单例模式
个人认为一个模式好不好  只有你自己用过了才知道  特别是遇到了一些不能解决的问题 突然想到了某个模式  这样你理解的更深

单例就是让一个类的实例只有一个 它的构造函数是私有的  当我们new多个对象时 对象对内存消耗很多  因为每创建一个对象 都要在堆内存为其分配空间 ，所以单例比较节省内存 但java比C好点的是 java有垃圾回收机制  而且还是自动回收  当我们的程序够大时还是要注意内存 ！
我们在学习枚举的时候  单例就起到了作用 它是通过外界调用它的方法而得到了其自定义的几个枚举的子类

单例在面试中  特别是 笔试中经常考到！

---

作者: 匿名    时间: 2011-9-29 13:10
单列模式是一种思想，是为了满足、简单而且可以重用的解决方案的需要。单列模式在实际应用中，就是限制的生成对象只有一个。
要实现单列模式，可以用下面的方式完成。
创建一个类，满足：
（1）构造器私有：
（2）用一个私有变量、静态变量引用实例
（3）提供一个方法，可以获取到该对象
class Single{
   private Single()
｛

  ｝
  private static String name;
    private static  Single s=new Single();
   public static getS()
   {
      rerurn s;
   }

}

---

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

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