有必要普及一下关于单例模式的常识.

饿汉式:

 

package com.design.pattern.singleton.concrete;

   public class EagerSingleton {

         private static EagerSingleton instance = new EagerSingleton();

         private EagerSingleton(){};

         public static EagerSingleton getInstance(){
            return instance;
        }
}

 

详细可以参考JDK中的java.lang.Runtime.class.

懒汉式:

 

package com.design.pattern.singleton.concrete;

　public class LazySingleton {

　　　private static LazySingleton instance = null;

　　　private LazySingleton(){};

　　　public static synchronized LazySingleton getInstance(){

　　　if(instance==null){
　　　　　instance = new LazySingleton();
　　　　　}

　　　return instance;
　　}
}

 

双重检验锁:

 

package com.design.pattern.singleton.concrete;

　public class DoubleCheckLockSingleton {
　　　private static volatile DoubleCheckLockSingleton instance = null;

　　　private DoubleCheckLockSingleton(){};

　　　public  static DoubleCheckLockSingleton getInstance(){

　　　　if(instance == null){    // first check
　　　　　synchronized(DoubleCheckLockSingleton.class){  // add lock
　　　　　　if(instance == null){  //second check
　　　　　　　　　instance =new DoubleCheckLockSingleton();
　　　　　　　　　}
　　　　　　　}
　　　　　}
　　　return instance;
　　　}
}

 

 

单例模式嵌套类实现:

package com.design.pattern.singleton.concrete;

　public class InnerClassSingleton {

　　　private InnerClassSingleton(){};

　　　static class staticInnerSingle{
　　　　private static InnerClassSingleton instance = new InnerClassSingleton();
　　　　　}

　　　public static InnerClassSingleton getInstance(){
　　　　return staticInnerSingle.instance;
　　　　}
}

 

 

枚举单例模式

 

public enum Sington{
    
      INSTANCE;

     public void singletonOpr(){
      
      // some opertions 

     }

}

 

总之，五类：懒汉，饿汉，双重校验锁，静态内部类，枚举。

饿汉：因为加载类的时候就创建实例，所以线程安全(多个ClassLoader存在时例外)。缺点是不能延时加载。
懒汉：需要加锁才能实现多线程同步，但是效率会降低。优点是延时加载。
双重校验锁：麻烦，在当前Java内存模型中不一定都管用，某些平台和编译器甚至是错误的，因为instance = new　DoubleCheckLockSingleton ()这种代码在不同编译器上的行为和实现方式不可预知。详细请参考:http://www.ibm.com/developerworks/cn/java/j-dcl.html
静态内部类：延迟加载，减少内存开销。因为用到的时候才加载，避免了静态field在单例类加载时即进入到堆内存的permanent代而永远得不到回收 的缺点(大多数垃圾回收算法是这样)。
枚举：很好，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。但是失去了类的一些特性，没有延迟加载，用的人也太少了～～

 

 

多个虚拟机

当系统中的单例类被拷贝运行在多个虚拟机下的时候，在每一个虚拟机下都可以创建一个实例对象。在使用了EJB、JINI、RMI技术的分布式系统中，由于中间件屏蔽掉了分布式系统在物理上的差异，所以对你来说，想知道具体哪个虚拟机下运行着哪个单例对象是很困难的。
因此，在使用以上分布技术的系统中，应该避免使用存在状态的单例模式，因为一个有状态的单例类，在不同虚拟机上，各个单例对象保存的状态很可能是不一样的，问题也就随之产生。而且在EJB中不要使用单例模式来控制访问资源，因为这是由EJB容器来负责的。在其它的分布式系统中，当每一个虚拟机中的资源是不同的时候，可以考虑使用单例模式来进行管理。


多个类加载器

当存在多个类加载器加载类的时候，即使它们加载的是相同包名，相同类名甚至每个字节都完全相同的类，也会被区别对待的。因为不同的类加载器会使用不同的命名空间（namespace）来区分同一个类。因此，单例类在多加载器的环境下会产生多个单例对象。
也许你认为出现多个类加载器的情况并不是很多。其实多个类加载器存在的情况并不少见。在很多J2EE服务器上允许存在多个servlet引擎，而每个引擎是采用不同的类加载器的；浏览器中applet小程序通过网络加载类的时候，由于安全因素，采用的是特殊的类加载器，等等。
这种情况下，有状态的单例模式也会给系统带来隐患。因此除非系统由协调机制，在一般情况下不要使用存在状态的单例模式。

 

仅供参考.
如有误,请指正.

 

Singleton反序列化

 

import java.io.Serializable;
public class SerializableSingleton implements Serializable{

    private static final long serialVersionUID = -6099617126325157499L;

    static SerializableSingleton instance = new SerializableSingleton ();

    private SerializableSingleton (){}

    private Object readResolve(){
        return instance;
    }

}

 

代码注解：
如果单例类实现了Serializable接口，我们应当注意，默认情况下，每次反序列化（Deserialization）总会创建一个新的实例对象，这样一个系统会出现多个对象供使用，那么我们就需要在readResolve()方法里做文章，此方法在反序列化完成之前被执行，我们在此方法里替换掉反序列化出来的那个新的实例，让其指向内存中得那个单例对象即可。这样我们在内存中始终保持了一个唯一的单例对象。


这里我们谈论了在同一个JVM中，如何保证一个类只有一个单例；如果在分布式环境中如EJB，JINI，JMI等，我们可能需要考虑如何保证在整个应用（可能分布在不同的JVM上）只有一个实例。还有假如在同一个JVM中，如果用户自定义了类加载器，如何保证单例只有一个实例（由于不同类加载器的命名空间不同，所以不同加载器加载了singleton类后，保存了同名，但不同实例的类）

 

很厉害的样子

大哥，这排版。。。

LZ缺个枚举
双重加锁的使用条件也应该说下

不好意思,第一次发帖.不知道怎么排版,刚才整理了一下.谢谢支持!

一个单例激起千层浪呀！不过这样也好，技术论坛吗，有什么观点拿出来大家讨论下！

多个JVM的情况也讲解下啊

不错 受教育了

这个还是比较好的1