一，单例概念

单例模式是一种对象创建模式，它用于产生对象的具体实例，并且确保在系统中这个类只能产生一个实例。

好处
(1)对于频繁使用的对象，可以省略创建对象花费的时间，对于一些重量级的对象，是一笔可观的系统开销
(2)由于new的操作减少，对系统内存的使用频率也会减少，减少GC压力，压缩GC停顿时间。

二，单例的写法

饿汉模式

public class EagerSingleton {

    private static EagerSingleton eagerSingleton = new EagerSingleton();

    private EagerSingleton() {
    }

    public static EagerSingleton getEagerSingleton() {
        return eagerSingleton;
    }
}

优点：类装载的时候就完成类实例化，避免了线程同步问题
缺点：没实现延迟加载，如果不使用这个类会造成内存浪费

懒汉模式(对于饿汉模式的没有懒加载的方式的一种优化)- 不建议使用

public class LazyModeSingleton {
   private static LazyModeSingleton lazyModeSingleton;

   private LazyModeSingleton() {
   }

   public static LazyModeSingleton getInstance() {
       if (lazyModeSingleton == null) {
           lazyModeSingleton = new LazyModeSingleton();
       }
       return lazyModeSingleton;
   }
}

缺点：线程非安全

懒汉线程安全

public class LazyModeSingletonSafe {
    private static LazyModeSingletonSafe lazyModeSingletonSafe;

    private LazyModeSingletonSafe() {
    }

    public static synchronized LazyModeSingletonSafe getInstance() {
        if (lazyModeSingletonSafe == null) {
            lazyModeSingletonSafe = new LazyModeSingletonSafe();
        }
        return lazyModeSingletonSafe;
    }

//    public static LazyModeSingletonSafe getInstance() {
//        synchronized (LazyModeSingleton.class) {
//            if (lazyModeSingletonSafe == null) {
//                lazyModeSingletonSafe = new LazyModeSingletonSafe();
//            }
//        }
//        return lazyModeSingletonSafe;
//    }
}

优点：线程安全
缺点：性能差

DCL(双重检查锁机制)

public class DCLSingleton {
    private static volatile DCLSingleton dclSingleton;//禁止指令jvm重排序

    private DCLSingleton() {

    }

    private DCLSingleton getInstance() {
        if (dclSingleton == null) {
            synchronized (DCLSingleton.class) {
                if (dclSingleton == null) {
                    //JVM的及时编译器中存在指令重排序优化会导致线程不安全，解决办法 关键字valatile
                    dclSingleton = new DCLSingleton();}
            }
        }
        return dclSingleton;
    }
}

静态内部类(建议使用)

public class StaticInneClassesSingleton {
    private StaticInneClassesSingleton() {
    }

    public static StaticInneClassesSingleton getInstance() {
        return StaticInneClassesSingletonHolder.staticInneClassesSingleton;
    }

    private static class StaticInneClassesSingletonHolder {
        private final static StaticInneClassesSingleton staticInneClassesSingleton = new StaticInneClassesSingleton();
    }
}

优点：具有延迟加载，线程安全，性能优越
原因：使用了static final关键字

枚举

public class EnumSingleton {
    INSTANCE;
    public void  doSomeTing(){

    }
}

借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

总结：

饿汉模式：无法实现延迟加载
懒汉模式：非线程安全
懒汉模式(线程安全):使用synchronized导致性能缺陷
DCL：JVM及时编译器指令的重排序问题，通过关键字volatile 可以解决，但是也具有一定性能问题
静态内部类/枚举:延迟加载，线程安全，性能好建议使用

三，android中的单例

Application

public class MyApplication extends Application {
    private static MyApplication myApplication;

    public static MyApplication getIntstance() {
        return myApplication;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        myApplication = this;
    }
}

单例模式引起的内存泄漏
如果一个对象已经不需要使用了，而单例对象还持有该对象的引用，那么这个对象将不能被正常回收，这就导致了内存泄漏。

public class Singletonleak {
    private static Context mContext;

    public static Singletonleak getInstance(Context context) {
//        mContext=context;//错误写法
        mContext = context.getApplicationContext();//正确写法
        return SingletonLeakHolder.singletonleak;
    }

    private static class SingletonLeakHolder {
        private static final Singletonleak singletonleak = new Singletonleak();
    }

    public void show() {
        Toast.makeText(mContext, "zjy", Toast.LENGTH_SHORT).show();
    }
}