设计模式（1）-单例模式

懒汉式

/**
 * 懒汉
 * 以下实现中，私有静态变量 instance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 instance，从而节约资源。

 这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 if (instance == null) ，并且此时 instance 为 null，那么会有多个线程执行 instance = new Singleton(); 语句，这将导致实例化多次 instance。
 *
 */
public class Singleton1 {


    private static Singleton1 instance;

    private Singleton1() {
    }

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

        return instance;
    }
}

懒汉式加锁

/**
 * 懒汉 加锁
 * 只需要对 getInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 instance。

 但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，即使 instance 已经被实例化了。这会让线程阻塞时间过长，因此该方法有性能问题，不推荐使用。
 */
public class Singleton2 {
    private static Singleton2 instance;

    private  Singleton2(){

    }

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

        return instance;
    }
}

双重锁懒汉式DCL

/**
 * 双重锁懒汉模式(Double Check Lock)
 * DCL模式的优点就是，只有在对象需要被使用时才创建，第一次判断 INSTANCE == null为了避免非必要加锁，
 * 当第一次加载时才对实例进行加锁再实例化。这样既可以节约内存空间，又可以保证线程安全。
 * 但是，由于jvm存在乱序执行功能，DCL也会出现线程不安全的情况。
 * instance = new Singleton5();在JVM中的执行步骤
 * 1.在堆内存开辟内存空间。
 * 2.在堆内存中实例化SingleTon里面的各个参数。
 * 3.把对象指向堆内存空间。
 * <p>
 * 由于jvm存在乱序执行功能，所以可能在2还没执行时就先执行了3，如果此时再被切换到线程B上，由于执行了3，instance 已经非空了，会被直接拿出来用，这样的话，就会出现异常。这个就是著名的DCL失效问题。
 */
public class Singleton5 {

    private static Singleton5 instance;

    public Singleton5() {
    }

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

}

饿汉式

/**
 * 饿汉
 *
 线程不安全问题主要是由于 instance 被实例化多次，采取直接实例化 instance 的方式就不会产生线程不安全问题。

 但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。
 饿汉模式在类被初始化时就已经在内存中创建了对象，以空间换时间，故不存在线程安全问题。
 */
public class Singleton3 {
    private static final Singleton3 instance = new Singleton3();

    private Singleton3(){

    }

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

静态内部类

/**
 * 静态内部类
 * 当Singleton4类加载时，静态内部类SingletonHolder没有被加载进内存，只有当调用getInstance()方法时，
 * 才会触发SingletonHolder.INSTANCE，SingletonHolder才会被加载，此时初始化INSTANCE实例，并且JVM确保INSTANCE只被实例化一次
 * 这种方式不仅具有延迟初始化的好处，而且JVM提供了对线程安全的支持
 *
 *
 */
public class Singleton4 {
    private Singleton4(){}

    private static class SingletonHolder{
        private static final Singleton4 INSTANCE = new Singleton4();
    }

    public static Singleton4 getInstance(){
        return SingletonHolder.INSTANCE;
    }

}

参考android.util.Singleton 实现Singleton帮助器类

/**
 * Singleton helper class for lazily initialization.
 * 用于延迟初始化的Singleton帮助器类。
 * @param <T>
 */
public abstract class Singleton<T> {
    /**
     * 一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
     * 1.保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
     * 2.禁止进行指令重排序。
     */
    private volatile T mInstance;

    protected abstract T create();

    public final T get() {
        if (mInstance != null) {
            synchronized (this) {
                if (mInstance == null) {
                    mInstance = create();
                }
                return mInstance;
            }
        }
        return mInstance;
    }
}

/**
 * 使用Singleton帮助器类实现单例
 */
public class CommonUtil {

    private CommonUtil() {}

    private CommonUtil getInstance(){
        return instance.get();
    }

    private static final Singleton<CommonUtil> instance = new Singleton<CommonUtil>() {
        @Override
        protected CommonUtil create() {
            return new CommonUtil();
        }
    };
}

参考：
volatile关键字解析
静态内部类单例原理