[设计模式] 单例模式

饿汉式

public class Singleton {
    private final static Singleton instance = new Singleton();
    private Singleton() {}

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

饿汉式在类加载时直接创建了对象，这种实现方式是线程安全的。但是因为在加载时直接创建了对象，即使这个对象可以在整个系统中不会使用到；另外如果这个对象的创建成本比较高，那么在启动时创建会降低启动速度。不太推荐使用。

懒汉式（线程不安全）

public class Singleton {
    private static Singleton instance = null;
    private Singleton() {}

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

这种方式虽然避免了饿汉式的问题，但也引入了另外一个问题，就是线程不安全，如果两个线程同时使用getInstance()方法，在系统中可能会存在多个实例，违背了单例这原则。

懒汉式（线程安全）

public class Singleton {
    private static Singleton instance = null;
    private Singleton() {}

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

加入了内置锁虽能保证线程安全，解决了多实例问题；但是每次使用getInstance()方法都加了锁，加锁本身就有一定的消耗，降低的执行效率。

双检锁

public class Singleton {
    private volatile static Singleton instance = null;//必须使用volatile修饰
    private Singleton() {}

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

用volatile修饰的原因是避免重排序，一个对象的创建过程并不是原子操作，而是一个复合操做，步骤如下：

1. 为对象分配空间
2. 执行构造方法初始化
3. 将instance指向分配的空间（也就是执行完这一步，instance才不为null）

因为JVM优化的机制，执行步骤可能为1-3-2，而此时对象已经不是null但却没有初始化，导致报错；故必须使用volatile修饰禁用重排序。

但是：双检锁还存在着一个问题，就是在Java 1.5之前内存模型是有缺陷的，即使使用了volatile修饰，也不能完全避免重排序。故此法只能在Java 1.5及之后使用。

静态内部类

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }
    private Singleton() {}

    public Singleton getInstance() {
        return SingletonHolder.instance;
    }
}

这种只有在调用getInstance()方法时才会创建对象，且因为在JVM加载机制中静态变量的的初始化时是线程安全，此法是线程安全的，同时还不依赖JDK的版本，推荐使用。

枚举法

public enum  Singleton {
    INSTANCE;
}

两行代码解决问题系列，因为枚举的特点，你只会有一个实例，同时保证了线程安全，推荐使用。

反编译一下（”javap -c Singleton.class“），其实枚举本质还是一个Singleton类，INSTANCE属性就是一个公开的静态不可改变的Singleton对象。且这个类在JVM中被添加了一段的静态代码块，里面创建了一个Singleton对象，这就是枚举实现单例的原因。

public final class Singleton extends java.lang.Enum<Singleton> {
  public static final Singleton INSTANCE;

  public static Singleton[] values();
    Code:
       0: getstatic     #1                  // Field $VALUES:[LSingleton;
       3: invokevirtual #2                  // Method "[LSingleton;".clone:()Ljava/lang/Object;
       6: checkcast     #3                  // class "[LSingleton;"
       9: areturn

  public static Singleton valueOf(java.lang.String);
    Code:
       0: ldc           #4                  // class Singleton
       2: aload_0
       3: invokestatic  #5                  // Method java/lang/Enum.valueOf:(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;
       6: checkcast     #4                  // class Singleton
       9: areturn

  static {};
    Code:
       0: new           #4                  // class Singleton 
       3: dup
       4: ldc           #7                  // String INSTANCE
       6: iconst_0
       7: invokespecial #8                  // Method "<init>":(Ljava/lang/String;I)V
      10: putstatic     #9                  // Field INSTANCE:LSingleton;
      13: iconst_1
      14: anewarray     #4                  // class Singleton
      17: dup
      18: iconst_0
      19: getstatic     #9                  // Field INSTANCE:LSingleton;
      22: aastore
      23: putstatic     #1                  // Field $VALUES:[LSingleton;
      26: return
}

小结

上面给出几种方法，因为枚举是Java 1.5后才新增的，个人最推荐的是：静态内部类。其它的都存在着一定的不足，或者版本上有要求。