单例的几种写法
饿汉模式（静态常量、静态代码块）（可以用）
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源码设计与实例》
