单例模式的几种实现

单例模式的几种实现

在开发中，我们总是会遇到使用单例模式的情况，今天就来总结一下几种实现单例模式的方法。
1.饿汉式

public class SingletonDemo1 {
    //类初始化时，立即加载该对象（没有延时加载的优势）！由于加载类时，天然的线程安全！
    private static SingletonDemo1 instance = new SingletonDemo1();
    //私有构造器
    private SingletonDemo1(){}
    //方法没有同步，调用效率高
    public static SingletonDemo1 getInstance(){
        return instance;
    }
}

不管是否使用到该类，都先初始化该类，有可能会造成资源浪费！
2.懒汉式， 有两种实现方式，
a).方式一

public class Singleton {
    private  static Singleton singleton;
    public Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

这种写法只能在单线程下使用。如果是多线程，可能发生一个线程通过并进入了 if (singleton == null) 判断语句块，但还未来得及创建新的实例时，另一个线程也通过了这个判断语句，两个线程最终都进行了创建，导致多个实例的产生。所以在多线程环境下必须摒弃此方式。
这种写法线程不安全。
b).加入同步锁

public class SingletonDemo2 {
    // 类初始化时，不初始化这个对象（延时加载，懒加载）
    private static SingletonDemo2 instance;
    // 私有构造器
    private SingletonDemo2() {
    }
    // 方法同步，调用效率低
    public static synchronized SingletonDemo2 getInstance() {
        if (instance == null) {
            instance = new SingletonDemo2();
        }
        return instance;
    }
}

通过为 getInstence() 方法增加 synchronized 关键字，迫使每个线程在进入这个方法前，要先等候别的线程离开该方法，即不会有两个线程可以同时进入此方法执行 new SingletonDemo2()，从而保证了单例的有效。但它的致命缺陷是效率太低了，每个线程每次执行 getInstance() 方法获取类的实例时，都会进行同步。而事实上实例创建完成后，同步就变为不必要的开销了，这样做在高并发下必然会拖垮性能。所以此方法虽然可行但也不推荐。
网上这样的代码更多，可以很好的工作，但是缺点是效率低。
3. 双重检查锁式。
实际上，早在JDK1.5就引入volatile关键字，所以又有了一种更好的双重校验锁写法。

public class Singleton {
    private volatile static Singleton singleton;
    public Singleton() {
    }

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

DCL体现在进行了两次 if (singleton == null) 的检查，这样既同步代码块保证了线程安全，同时实例化的代码也只会执行一次，实例化后同步操作不会再被执行，从而效率提升很多。
双重检查锁定（DCL）方式也是延迟加载的，它唯一的问题是，由于 Java 编译器允许处理器乱序执行，在 JDK 版本小于 1.5 时会有 DCL 失效的问题。当然，现在大家使用的 JDK 普遍都已超过 1.4，只要在定义单例时加上 1.5 及以上版本具体化了的 volatile 关键字，即可保证执行的顺序，从而使单例起效。
Android 中鼎鼎大名的 Universal Image Loader 和 EventBus 都是采用了这种方式的单例
4).静态内部类式

public class SingletonDemo3 {
    //静态内部类
    private static class SingletonClassGetInstance {
        public static final SingletonDemo3 instance = new SingletonDemo3();
    }
    // 私有构造器
    private SingletonDemo3() {
    }
    public static  SingletonDemo3 getInstance() {
        return SingletonClassGetInstance.instance;
    }
}

这种方式是SingletonDemo3 类被装载了，instance不一定被初始化。因为SingletonClassGetInstance 类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonClassGetInstance 类，从而实例化instance。
5). 枚举式模式

public enum SingletonDemo4 {
    //这个枚举对象本身就是单例对象
    INSTANCE;
    //添加自己需要的操作
    public void operation(){
    }
}

这种模式下，线程安全，调用效率高，但是不能延时加载！实际工作中，少有人使用这种方式！难道是因为太高级了！O(∩_∩)O~
小结
a. 单例模式有五种实现方式
1).饿汉式
线程安全，调用效率高，但是不能延时加载
2).懒汉式
线程安全，调用效率不高，并且可以延时加载
3).双重检查锁式
由于JVM底层内部模型原因，偶尔会出问题，不建议使用
4).静态内部类式
线程安全，调用效率高，并且可以延时加载。推荐使用
5).枚举式
线程安全，调用效率高，不能延时加载，但是可以天然的防止反射和反序列化漏洞
我们在编码中，有关单例模式的具体实现方式，需要根据实际情况来选择！

b. 单例模式中的存在的问题
如果单例类实现了java.io.Serializable接口，那么这个类可能会被反序列化，并且反序列化多次同一对象时，会得到多个单例类的实例。这样就不是单例了！
解决办法，需要在单例类中添加如下方法，

    // 反序列化时，如果定义了readResovle() 则直接返回此方法指定的对象，而不需要单独再创建新对象！
    private Object readResovle() throws ObjectStreamException {
        // TODO Auto-generated method stub
        return instance;
    }

PS:在Android中使用单例模式可能会内存泄露。
当调用getInstance时，如果传入的context是Activity的context。只要这个单例没有被释放，那么这个Activity也不会被释放一直到进程退出才会释放。

public class CommUtils {

    private volatile static CommUtils mCommUtils;

    private Context mContext;
    public CommUtils(Context context) {
        mContext=context;
    }

    public static  CommUtils getInstance(Context context) {
        if (mCommUtils == null) {
            synchronized (CommUtils.class) {
                if (mCommUtils == null) {
                    mCommUtils = new CommUtils(context);
                }
            }
        }
        return mCommUtils;
    }
}

解决办法
能使用Application的Context就不要使用Activity的Content，Application的生命周期伴随着整个进程的周期