单例设计模式代码

1、常见的单例设计模式有两种：

（1）懒汉式

　　何为懒？顾名思义，就是不做事，这里也是同义，懒汉式就是不在系统加载时就创建类的单例，而是在第一次使用实例的时候再创建。

例子

public class LHanDanli {
      //定义一个私有类变量来存放单例，私有的目的是指外部无法直接获取这个变量，而要使用提供的公共方法来获取
      private static LHanDanli dl = null;
      //定义私有构造器，表示只在类内部使用，亦指单例的实例只能在单例类内部创建
      private LHanDanli(){}
      //定义一个公共的公开的方法来返回该类的实例，由于是懒汉式，需要在第一次使用时生成实例，所以为了线程安全，使用synchronized关键字来确保只会生成单例
      public static synchronized LHanDanli getInstance(){
          if(dl == null){
              dl = new LHanDanli();
         }
         return dl;
     }
 }

（2）饿汉式

　　又何为饿？饿者，饥不择食；但凡有食，必急食之。此处同义：在加载类的时候就会创建类的单例，并保存在类中。

例子：

public class EHanDanli {
      //此处定义类变量实例并直接实例化，在类加载的时候就完成了实例化并保存在类中
      private static EHanDanli dl = new EHanDanli();
      //定义无参构造器，用于单例实例
      private EHanDanli(){}
      //定义公开方法，返回已创建的单例
      public static EHanDanli getInstance(){
         return dl;
      }
}

2、双重加锁机制

　　何为双重加锁机制？

　　在懒汉式实现单例模式的代码中，有使用synchronized关键字来同步获取实例，保证单例的唯一性，但是上面的代码在每一次执行时都要进行同步和判断，无疑会拖慢速度，使用双重加锁机制正好可以解决这个问题：

例子：

public class SLHanDanli {
      private static volatile SLHanDanli dl = null;
      private SLHanDanli(){}
      public static SLHanDanli getInstance(){
         if(dl == null){
              synchronized (SLHanDanli.class) {
                  if(dl == null){
                      dl = new SLHanDanli();
                  }
             }
         }
         return dl;
     }
 }

3、类级内部类方式

　　饿汉式会占用较多的空间，因为其在类加载时就会完成实例化，而懒汉式又存在执行速率慢的情况，双重加锁机制呢？又有执行效率差的毛病，有没有一种完美的方式可以规避这些毛病呢？

貌似有的，就是使用类级内部类结合多线程默认同步锁，同时实现延迟加载和线程安全。

public class ClassInnerClassDanli {
     public static class DanliHolder{
         private static ClassInnerClassDanli dl = new ClassInnerClassDanli();
     }
     private ClassInnerClassDanli(){}
     public static ClassInnerClassDanli getInstance(){
         return DanliHolder.dl;
     }
 }
​

本文内容转载自http://www.cnblogs.com/V1haoge/p/6510196.html