java基础系列-单例详解

单例模式

单例模式是我们平时经常遇到的设计模式之一,它是一种对象创建模式,用于产生对象实例,确保一个类只实例化一次。这带来的好处是显而易见的,频繁的new操作,会带来新建对象造成的系统开销,尤其是一些重量级对象更是如此。
下面是单例模式的基本结构图:


20160604141946767.png

单例模式常用的几种实现方式如下:

  • 基于synchronized实现
  • 基于DCL实现
  • 基于静态块的实现
  • 基于静态内部类实现
  • 基于枚举的实现

方法一:基于synchronized实现

public class SynchronizedSingleton { 

  private SynchronizedSingleton(){}  
  private static SynchronizedSingleton instance;

  public synchronized static SynchronizedSingleton getInstance(){            
             if(instance == null){ 
                          instance = new SynchronizedSingleton();
              }
              return instance; 
  }
}

这是一种最容易理解的解决方案,通过对getInstance方法加锁的方式,确保多线程环境下instance实例的唯一性,不过加锁带来的性能问题也是最大的缺陷。

方法二:基于DCL+volatile实现

public class DCLSingleton { 
/** * 私有的构造函数 */ 
    private DCLSingleton(){ System.out.println("instance is created!"); } 
 
     private static DCLSingleton instance;  

    public static DCLSingleton getInstance(){
       if(instance == null){ 
            synchronized(DCLSingleton.class){
               if(instance == null){
                  instance = new DCLSingleton();
               }
            }
       } 
       return instance;
   }
}

其中** 构造函数必须是private访问级别的 **,防止单例类不会被其他代码通过构造函数实例化。其次instance成员变量和getInstance方法必须是static的。通过双检查机制可以满足单例对象的构造了,但是这种方法并不是完全正确的。主要问题出在下面这句代码上:

instance = new DCLSingleton();

这句话的执行过程一般分为这么几步:

  1. 在堆内存中为即将实例化的对象分配内存空间。
  2. 对象实例化操作
  3. 将内存地址值赋给instance

这在JVM中可能出现指令重排的过程,因为分配过内存后地址的值就确定了,jvm认为步骤2和3前后调整对最终结果并不会产生影响,所以指令重排可能出现1->3->2顺序的情况,当instance被赋值了但对象实例化工作并没有完成的时候,此时如果别的线程调用getInstance方法,由于instance!=null就会返回instance变量。这里返回的虽然是同一个对象,但是这个对象的状态是不一致的(可能初始化还未完成)。所以** 这种方式获得的对象并不是严格意义上的单例对象(同一状态的同一个对象)。为了避免指令重排现象的发生,可以通过volatile来修饰instance变量定义如下

private static volatile DCLSingleton instance;

方法三:基于静态成员变量的实现方案

public class StaticSingleton { 
      private StaticSingleton(){ System.out.println("instance is created!"); } 

      /** * instance实例化是在类加载阶段进行的,天生线程友好,保证对象唯一性。 */ 
      private static StaticSingleton instance = new StaticSingleton();  
      public static StaticSingleton getInstance(){ 
             return instance; 
      }
}

静态成员变量的实现方案主要利用了静态成员变量的初始化时机是在类的加载阶段这一特性。我们都知道类的加载阶段包括(加载-连接-初始化),这里重点说下初始化阶段jvm做的工作,初始化阶段会执行所有类变量(静态成员变量)的赋值动作和静态语句块中的内容。上面例子中也可以改用静态语句块实现,如下:

      private static StaticSingleton instance;       
      static{ 
              instance = new StaticSingleton();
      }

这种实现方案可以满足单例模式的基本需求,但是如果我们某些情况调用了单例类的其他的静态方法,则类的实例化操作同样会被触发,如下所示:

public class StaticSingleton { 
        private StaticSingleton(){ System.out.println("instance is created!"); }
        private static StaticSingleton instance = new StaticSingleton();  

        public static StaticSingleton getInstance(){ return instance; } 

        public static String otherMethod(){ return "msg"; }}

        //outside code 
        public static void main(String args[]){ 
            //call otherMethod 
            StaticSingleton.otherMethod(); 
    }
}
输出:instance is created!

我们希望获得一种延迟加载机制,即我什么时候调用getInstance方法,单例对象的实例化才被触发。此时可以使用静态内部类来实现LazyInit这一特性。

方法四:基于静态内部类实现

public class StaticSingleton {  

       private StaticHolderSingleton(){ System.out.println("instance is created!"); }  

       private static StaticSingleton instance ;  

       /** * 使用静态内部类实现单例 *  */ 
       private static class SingletonHolder{ 
            private static StaticSingleton instance = new  StaticSingleton(); 
      } 
      public static StaticSingleton getInstance(){ 
              return SingletonHolder.instance; 
       }
}

在这种实现方案中,如果调用getInstance之外的方法,instance变量并不会初始化。这就达到了lazy init的目的。

方法五:基于枚举类型的实现

public class EnumSingleton{
/** * 枚举类型实现 */ 
  enum SingletonHoler{ 
          holder; 

          private SingletonDemo instance;  
          
          SingletonHoler(){ instance = new SingletonDemo();  } 
           
          public SingletonDemo getInstance(){ return instance; } 
   } 

    public static SingletonDemo getInstance(){ 
          return SingletonHoler.holder.getInstance(); 
    }
}

总结:方法一使用synchronized加锁,保证了getInstance()方法调用的串行化,从而保证了实例的唯一性。最简单,但高并发情况下由于锁的竞争效率较低。
方法二:通过双检查锁机制,也保证了实例的唯一性。这里要注意的是用volatile修饰成员变量。
方法三和方法四原理一致,利用了静态成员和静态块在类初始化的时候就执行这一特性。保证程序运行时获取的对象唯一性。
方法五和方法三四类似,使用枚举类型时,构造方法会被自动调用,用这个特性实现单例模式。

以上方法都可以在正常情况下实现单例,但是一些极端情况下还是会出现问题。具体情况如下:

通过反射调用私有构造函数来实例化一个对象。

/** * 利用反射生成对象 */ 
@Test public void ReflectSingletionTest() throws Exception{ 
     //通过getInstance方法获取对象instance1 

      DCLSingleton instance1 = DCLSingleton.getInstance(); 
      
      Class cls = Class.forName("edu.ouc.pattern.singleton.DCLSingleton"); 

      Constructor c = cls.getDeclaredConstructor(); c.setAccessible(true); 

      //通过反射获取对象
       instance2 DCLSingleton instance2 = (DCLSingleton) c.newInstance(); 
      
       Assert.assertEquals(instance1, instance2); }

结果:
java.lang.AssertionError: expected:edu.ouc.pattern.singleton.DCLSingleton@4eaa3152but was:edu.ouc.pattern.singleton.DCLSingleton@4586793e

结果显示两次获取的对象并不是同一个对象,这显然不是我们想要的。为了避免这一情况,可以强制构造函数的调用次数仅为一次,否则抛出相应的异常。实现代码片段如下:

   //新增isSingle变量,初始为false
   private volatile static Boolean isSingle = false; 
   /** * 私有的构造函数 */ 
   private DCLSingleton(){ 
         synchronized(isSingle){ 
              if(!isSingle){ 
                  isSingle = true; 
              }else{
                      try {  throw new Exception("duplicate instance exception : " + DCLSingleton.class.getName());  
                      } catch (Exception e) {  e.printStackTrace();  } 
               }
          }
 }

此时再运行ReflectSingletionTest()方法,结果如下:

java.lang.Exception: duplicate instance exception :
edu.ouc.pattern.singleton.DCLSingleton> at
edu.ouc.pattern.singleton.DCLSingleton.<init>(DCLSingleton.java:14)

推荐阅读更多精彩内容