Android 单例设计模式汇总

1. 懒汉式单例，非线程安全

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

• 缺点：当两个线程同时运行到判断 instance 是否为空的 if 语句，并且 instance 确实没有创建好时，那么两个线程都会创建一个实例

2. 饿汉式单例，线程安全

但如果只是引用静态方法也会导致单例被创建，没有 lazy loading 的效果

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance(){
        return instance;
    }
}
// 变种
public class Singleton {  
    private Singleton instance = null;  
    static {  
        instance = new Singleton();  
    }  
    private Singleton () {}  
    public static Singleton getInstance() {  
        return this.instance;  
    }  
}

• 优点：无需额外同步锁，实现简单，依靠类加载确保单例唯一
• 缺点：类加载初始化后就会创建 instance 实例。如果我们在 Singleton 类里面写一个静态的方法不需要创建实例，它仍然会早早的创建一次实例，而降低内存的使用率。

3. 同步锁单例，线程安全

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

• 缺点：每次访问单例就加锁，多个线程访问存在锁竞争导致另一个线程等待，效率低

4. 双重判断同步锁单例，线程安全，推荐指数：三星

public class Singleton {
    //private static Singleton instance = null;
    private static volatile Singleton instance = null; // 最好加 volatile 关键字
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

5. 静态内部内单例，线程安全，推荐指数：四星

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

• 优点：第一次使用这个嵌套类时才创建单例实例，具有 lazy loading 效果

6. 枚举实现单例，线程安全，推荐指数：五星

public enum Singleton {
    INSTANCE;
    public void doSomething() {
        System.out.println("doSomething");
    }
}
Singleton.INSTANCE.doSomething();

• 优点：利用枚举的特性，让 JVM 来帮我们保证线程安全和单一实例的问题

7. 借助CAS（AtomicReference）实现单例模式，线程安全

public class Singleton {
    private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>();
    private Singleton() {}
    public static Singleton getInstance() {
        for (;;) {
            Singleton singleton = INSTANCE.get();
            if (null != singleton) {
                return singleton;
            }
            singleton = new Singleton();
            if (INSTANCE.compareAndSet(null, singleton)) {
                return singleton;
            }
        }
    }
}

• 优点：CAS 是一种基于忙等待的算法，用 CAS 的好处在于不需要使用传统的锁机制来保证线程安全，依赖底层硬件的实现，相对于锁它没有线程切换和阻塞的额外消耗，可以支持较大的并行度。
• 缺点：CAS 的一个重要缺点在于如果忙等待一直执行不成功(一直在死循环中)，会对 CPU 造成较大的执行开销。代码中，如果N个线程同时执行到singleton = new Singleton();的时候，会有大量对象被创建，可能导致内存溢出

8. 使用 ThreadLocal 实现单例模式，每个线程一个实例

public class Singleton {
    private static final ThreadLocal<Singleton> singleton = new ThreadLocal<Singleton>() {
        @Override
        protected Singleton initialValue() {
            return new Singleton();
        }
    };
    public static Singleton getInstance() {
    return singleton.get();
    }
    private Singleton() {}
}

如何破坏单例

1. 序列号与反序列化
2. 反射

静态内部类如何确保线程安全

1. 类加载的线程安全