单例的几种写法

饿汉模式（静态常量、静态代码块）（可以用）


public class RetrofitUtils {

    private RetrofitUtils() {

    }

    private final static RetrofitUtils INSTANCE = new RetrofitUtils();

    public RetrofitUtils getInstance() {
        return INSTANCE;
    }

}


public class RetrofitUtils {

    private RetrofitUtils() {

    }

   private static RetrofitUtils INSTANCE;
    static {
         INSTANCE = new RetrofitUtils();
    }


    public static RetrofitUtils getInstance() {
        return INSTANCE;
    }

}

优点：在类装载的时候就完成实例化。保证只有一个线程中进行实例化。
缺点：类装载时候实例化，没有延迟加载，有可能使用实例，造成浪费。

懒汉式1（不可用）

public class RetrofitUtils {

    private RetrofitUtils() {

    }

    private static RetrofitUtils retrofitUtils;

    public static RetrofitUtils getInstance() {

        if(retrofitUtils == null) {

            retrofitUtils = new RetrofitUtils();
        }
        return retrofitUtils;
    }

}

优点：获取对象时候可以延迟加载
缺点：但是只适合单线程中，多线程中会产生多个实

懒汉式2（不推荐使用）

public class RetrofitUtils {

    private RetrofitUtils() {

    }

    private static RetrofitUtils retrofitUtils;

    public static synchronized RetrofitUtils getInstance() {

        if(retrofitUtils == null) {

            retrofitUtils = new RetrofitUtils();
        }
        return retrofitUtils;
    }

}

优点：加一个synchronized同步方法，解决了多线程问题
缺点：同步效率低

懒汉式2（不可使用）

public class RetrofitUtils {

    private RetrofitUtils() {

    }

    private static RetrofitUtils retrofitUtils;

    public static RetrofitUtils getInstance() {

        if(retrofitUtils == null) {
            synchronized (RetrofitUtils.class){
                retrofitUtils = new RetrofitUtils();
            }
        }
        return retrofitUtils;
    }

    }

优点：去掉了同步方法，加再了同步创建实例上面，
缺点：不能避免多线程问题

双重检查，DCL，记得加volatile（推荐使用）


public class RetrofitUtils {

    private volatile static RetrofitUtils retrofitUtils;

    private RetrofitUtils(){

    }

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

优点：线程安全，延迟加载，效率高

静态内部类(推荐使用)


public class RetrofitUtils {

    private RetrofitUtils() {

    }
    
    private static class SinglieInstance {
        private static final RetrofitUtils INSTANCE = new RetrofitUtils();

    }

    public static RetrofitUtils getInstance() {
        return SinglieInstance.INSTANCE;
    }

}

优点：线程安全，延迟加载，效率高

推荐单例分析

DCL 实现单例：

public class Singleton{
    private static Singleton instance = null;
    private int value = 0;
    private Singleton(){
        value = 1024;
    }
    public static Singleton getInstance(){
        if (instance == null){
            synchronized (Singleton.class){
                if (instance == null){
                    instance = new Singleton();
                }
            }
        }
    }
}

问题：

关键在于
instance = new Singleton()
这行代码最终会编译成多条汇编指令，它大致做了3件事：

给Singleton 的实例分配内存。
调用Singleton() 的构造函数，并初始化成员字段。
将sInstance 对象指向分配的内存空间。（注意此时的instance ！= null）

但是，由于Java编译器允许处理器乱序执行，以及JDK 1.5 之前JMM （Java Memory Model，即Java内存模型）中Cache、寄存器到主内存会写顺序的规定，上面 2,3的顺序是无法保证的。也就是说会出现1-2-3或者是1-3-2，如果是后者，那么会出现以下情况：在A线程中调用了 getInstance() ，此时 instance = null，会进入1-3，注意此时instance ！= null ，但是instance只是指向了一块内存地址，这个地址并没有对应给Singleton实例，或者说此时Singleton的构造函数并没有调用。然后此时B线程也调用了getInstance()，instance ！= null，则直接返回instance（value = 0），抛出异常。

当然上述的异常很少见，毕竟是处理器的问题，从JDK1.5之后SUN的官方已经注意到上述问题，调整了JVM，具体化了volatile关键字，因此如果JDK是1.5版本，只需要将上述代码改成：

public class Singleton{
    private volatile static Singleton instance = null;
    ....
}

Java并发编程：volatile关键字解析作者：Matrix海子
即仅当A线程赋值完instance（1-2-3或1-3-2）后，B线程才会去调用主内存的instance，此时instance ！= null 且 value = 1024；

这样的话，保证了instance每次都是从主内存中读取，就可以避免上述的问题。当然volatile或多或少也会影响性能。

静态内部类单例模式【推荐】

在《Java并发编程实践》推荐使用如下代码：

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

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

第一次加载Singleton类的时候并不会初始化instance，只有第一次调用Singleton的getInstance() 才会导致instance初始化。因此，第一次调用getInstance（）方法会导致虚拟机加载SingletonHolder类，这种方式不仅能够保证线程安全，也能保证单例对象的唯一性，同事也延迟了单例的实例化。

参考《Android源码设计与实例》

单例模式的几种写法