单例模式记录-有一个android framework学来的可能你不知道

Singleton:
其他的线程不安全的不介绍。

1.常见的，不加锁，多线程安全，饥饿加载
口诀：默认直接new了它，get直接返回它。

public class Singleton {
    //类加载直接创建classloader对静态对象初始化保证了唯一性
    private static SingleTon instance = new Singleton(); 
    privte Singleton() {}

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

2.双检锁：性能也高。复杂。
记住口诀：默认我就是个null，check，同步，再check。

public class Singleton {
     //类加载并没有初始化
    private volatile static Singleton instance;
    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) { //第一次检测
            synchronized(Singleton.class) { //保证同步
                if (instance == null) { //第二次检测
                    instance =  new Single();
                }
            }
        }
        return instance;
    }
}

3.静态内部类实现。巧妙地实现了，懒加载和线程安全问题。

public class Singleton {
    private static class SingletonHolder{
        //没有调用getInstance()也不会主动加载内部类这里还没有new
        private static final Singleton instance = new Singleton();
    }
    private Singleton(){}
    public static final Singleton getInsatance(){
        //直到有调用才有用instance
        return SingletonHolder.instance;
    }
}

4.接下来看一个你没见过的。其实原理跟第3个差不多。从android framework学来。
首先有个抽象类，抽象方法的泛型类。

public abstract class Singleton<T> {
    private T mInstance;
    protected abstract T create();
    public T get() {
        if (mInstance == null) {
            synchornized(this){
                if (mInstance == null) {mInstance = create();}
            }
        }
        return mInstance;
    }
}

public class YourClass{ //自己的类
     //必须饥饿加载，来避免多次创建这个instance
     //但是虽然它是饥饿加载，只是加载了一个空壳。不会浪费太多资源。
     //如果你没有get(),则父类不会走create()也就不会把本类中大量的成员变量和对象创建出来
    private static final Singleton<YourClass> instance = new Singleton<YourCalss> {
        protected YourClass create() {
            return new YourClass(xxx);
        }
    }

    public static YourClass get() {
        return instance.get();
    }

}

有一个好处是，该类放在自己的utils包中，哪个类想变成单例，只需要在这个类中，new一个抽象类的对象出来，实现它的方法即可。