liuwei063608的专栏

刘伟的随笔

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

饿汉式:

 

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类后,保存了同名,但不同实例的类)

 

 

阅读更多
个人分类: java
上一篇序列化serialVersionUID
下一篇Java编程中“为了性能”尽量要做到的一些地方
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭