Singleton实现

单例模式的实现大致有以下几种方式：

饿汉式：

/**
  * @desc: 饿汉式，类加载时即创建实例
  * @desc: feature:可以通过反射机制攻击；线程安全(多个类加载器除外)
  * @author: houkh
  * @date： Dec 2, 2014
  */
public class HungrySingletonOfBasic {
       public static final HungrySingletonOfBasicinstance = new HungrySingletonOfBasic();

       private HungrySingletonOfBasic() {

      }
}

饿汉式变种1：

/**
  * @desc：饿汉式变种
  * @author: houkh
  * @date： Dec 2, 2014
  */
public class HungrySingletonTwo {
       private static HungrySingletonTwo instance =  new HungrySingletonTwo();

       public static HungrySingletonTwo getInstance() {
             return instance ;
      }

       private HungrySingletonTwo() {

      }
}

饿汉式变种2：

/**
  * @desc: 饿汉式变种2，类加载时实例化
  * @deprecated something may be wrong
  * @author: houkh
  * @date： Dec 2, 2014
  */
public class HungrySingletonThree {
       private static HungrySingletonThree instance  = null;

       static {
             instance = new HungrySingletonThree();
      }

       private HungrySingletonThree() {

      }

       public static HungrySingletonThreegetInstance() {
             return instance ;
      }
}

懒汉式：

/**
  * @desc: 懒汉式，基本类型
  * @desc: feature:延时加载；线程不安全，多线程下不能正常工作；需要额外的serializable/transient/readResolve来实现序列化
  * @author: houkh
  * @date： Dec 2, 2014
  */
public class LazySingletonOfBasic {
       private static LazySingletonOfBasic instance = null ;

       private LazySingletonOfBasic() {
      }

       public static LazySingletonOfBasic getInstance() {
             if (instance == null) {
                   instance = newLazySingletonOfBasic();
            }
             return instance ;
      }
}

懒汉式变种：

/**
  * @desc: 线程安全，效率较低
  * @author: houkh
  * @date： Dec 2, 2014
  */
public class LazySingletonTwo {
       private static LazySingletonTwo instance =null ;

       private LazySingletonTwo() {

      }

       public static synchronized LazySingletonTwo getInstance() {
             if (instance == null) {
                   instance = newLazySingletonTwo();
            }
             return instance ;
      }
}

静态内部类：

/**
  * @desc: 静态内部类：线程安全，延迟加载
  * @author: houkh
  * @date： Dec 2, 2014
  */
public class InnerStaticSingleton {
       private static class SingletonHolder {
             private static final InnerStaticSingleton instance = newInnerStaticSingleton();
      }

       public static final InnerStaticSingletongetInstance() {
             return SingletonHolder. instance;
      }

       private InnerStaticSingleton() {

      }
}

双重校验锁：

/**
  * @desc：双重校验
  * @author: houkh
  * @date： Dec 2, 2014
  */
public class DoubleCheckSingleton {
       private volatile static DoubleCheckSingleton  instance;

       private DoubleCheckSingleton() {

      }

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

枚举类型：

/**
  * @desc: 提供序列化机制，绝对防止多次实例化，即使在面对复杂序列化或反射攻击的时候
  * @author: houkh
  * @date： Dec 2, 2014
  */
public enum EnumSingleton {
       instance ;
}