单例模式个人总结和优缺点分析

• 单例模式：
  • 单例模式又称单态模式或者单件模式
  • 定义：
    • 保证一个类仅有一个实例，并提供一个访问它的全局访问点
  • 目的：
    • 控制特定的类只产生一个对象，当然也允许在一定的情况下灵活的改变对象的个数
  • 实现方式：
    • 饿汉式：

public class Singleton{

private static Singleton instance=new Singleton();

private Singleton(){}

public static Singleton getInstance(){

return instance;

}

}

• • 懒汉式：

                                        public class Singleton{

                                                private static Singleton instance=null;

                                                private Singleton(){};

                                                public static sychronized Singleton getInstance(){

                                                        if(instance==null)

                                                                instance=new Singleton();

                                                        return instance;

                                                }

                                        }

• 方法比较：
  • 相同点：
    • 构造函数私有化(不能通过new来创建对象)
  • 不同点：
    • 懒汉式中，对静态工厂方法做了同步处理，原因很明显——为了防止多线程环境产生多个实例；而在第一种中不存在这种情况。
    • 懒汉式中将类对自己的实例化延迟到第一次被引用的时候。而在饿汉式中则是在类被加载时实例化，这样多次加载的话会造成多次实例化。但是懒汉式由于使用了同步处理，在反映速度上要比第一种慢一些。
• 在GOF中认为最好的一种实现方式是维护一张存有对象和对应名称的注册表（可以使用HashMap实现）：

                                    import java.util.HashMap;

                                    public class Singleton{

                                            //用于存放对应关系

                                            private static HashMap sinRegistry=new HashMap();

                                            private static Singleton s=new Singleton();

                                            //受保护的构造函数

                                            protected Singleton(){};

                                            public static Singleton getInstance(Stirng name){

                                                    if(name==null)name="Singleton";

                                                    try{

                                                            sinRegistry.put(name,Class.forName(name).newInstance());

                                                    }catch(Exception e){

                                                            e.printStackTrace();

                                                    }

                                                    return (Singleton)sinRegistry.get(name);

                                            }

                                            public void test(){

                                                    System.out.println("getClassSuccess！");

                                            }

                                    }

                                        

                                    public class SingletonChild1 extends Singleton{

                                            public SingletonChild1(){};

                                            public static SingletonChild1 getInstance(){

                                                    return (SingletonChild1)Singleton.getInstance("SingletonChild1");

                                            }

                                            public void test(){

                                                    System.out.println("getClassSuccess1!");

                                            }

                                    }

• 单例模式邪恶论：
  • 多个虚拟机
    • 当系统中的单例类被拷贝运行在多个虚拟机下的时候，在每一个虚拟机下都可以创建一个实例对象。在使用了EJB、JINI、RMI技术的分布式系统中，由于中间件屏蔽掉了分布式系统在物理上的差异，所以对你来说，想知道具体哪个虚拟机下运行着哪个单例对象是很困难的。因此，在使用以上分布技术的系统中，应该避免使用存在状态的单例模式，因为一个有状态的单例类，在不同虚拟机上，各个单例对象保存的状态很可能是不一样的，问题也就随之产生。而且在EJB中不要使用单例模式来控制访问资源，因为这是由EJB容器来负责的。在其它的分布式系统中，当每一个虚拟机中的资源是不同的时候，可以考虑使用单例模式来进行管理。
  • 多个类加载器
    • 当存在多个类加载器加载类的时候，即使它们加载的是相同包名，相同类名甚至每个字节都完全相同的类，也会被区别对待的。因为不同的类加载器会使用不同的命名空间（namespace）来区分同一个类。因此，单例类在多加载器的环境下会产生多个单例对象。也许你认为出现多个类加载器的情况并不是很多。其实多个类加载器存在的情况并不少见。在很多J2EE服务器上允许存在多个servlet引擎，而每个引擎是采用不同的类加载器的；浏览器中applet小程序通过网络加载类的时候，由于安全因素，采用的是特殊的类加载器，等等。这种情况下，由状态的单例模式也会给系统带来隐患。因此除非系统由协调机制，在一般情况下不要使用存在状态的单例模式。
  • 错误的同步处理
    • 在使用上面介绍的懒汉式单例模式时，同步处理的恰当与否也是至关重要的。不然可能会达不到得到单个对象的效果，还可能引发死锁等错误。因此在使用懒汉式单例模式时一定要对同步有所了解。不过使用饿汉式单例模式就可以避免这个问题。
  • 子类破坏了对象控制
    • 在上一节介绍最后一种扩展性较好的单例模式实现方式的时候，就提到，由于类构造函数变得不再私有，就有可能失去对对象的控制。这种情况只能通过良好的文档来规范。
  • 串行化（可序列化）
    • 为了使一个单例类变成可串行化的，仅仅在声明中添加“implements Serializable”是不够的。因为一个串行化的对象在每次返串行化的时候，都会创建一个新的对象，而不仅仅是一个对原有对象的引用。为了防止这种情况，可以在单例类中加入readResolve方法。关于这个方法的具体情况请参考《Effective Java》一书第57条建议。其实对象的串行化并不仅局限于上述方式，还存在基于XML格式的对象串行化方式。这种方式也存在上述的问题，所以在使用的时候要格外小心。 
• 题外话：
  • public static final Singleton INSTANCE = new Singleton();