Android单例模式的使用

枚举的方法《极其不推荐》

这是网上很多人推荐的一种做法，但是貌似使用的不广泛，大家可以试试，还有就是enum在android 中是不常使用的；

[java]  view plain copy

1. /** 
2.  * @function:单例模式枚举实现 
3.  * @author xuzhaohu 
4.  *  
5.  */  
6. public enum SingletonEnum {  
7.     /** 
8.      * 1.从Java1.5开始支持; 
9.      * 2.无偿提供序列化机制; 
10.      * 3.绝对防止多次实例化，即使在面对复杂的序列化或者反射攻击的时候; 
11.      */  
12.   
13.     instance;  
14.   
15.     private String others;  
16.   
17.     SingletonEnum() {  
18.   
19.     }  
20.   
21.     public void method() {  
22.         System.out.println("SingletonEnum");  
23.     }  
24.   
25.     public String getOthers() {  
26.         return others;  
27.     }  
28.   
29.     public void setOthers(String others) {  
30.         this.others = others;  
31.     }  
32. }  

内部类的实现

内部类是一种好的实现方式，可以推荐使用一下：

[java]  view plain copy

1. public class SingletonInner {  
2.   
3.     /** 
4.      * 内部类实现单例模式 
5.      * 延迟加载，减少内存开销 
6.      *  
7.      * @author xiaoming
8.      *  
9.      */  
10.     private static class SingletonHolder {  
11.         private static SingletonInner instance = new SingletonInner();  
12.     }  
13.   
14.     /** 
15.      * 私有的构造函数 
16.      */  
17.     private SingletonInner() {  
18.   
19.     }  
20.   
21.     public static SingletonInner getInstance() {  
22.         return SingletonHolder.instance;  
23.     }  
24.   
25.     protected void method() {  
26.         System.out.println("SingletonInner");  
27.     }  
28. }  

调用：

[java]  view plain copy

1. SingletonInner.getInstance().method();  

优点：延迟加载，线程安全（java中class加载时互斥的），也减少了内存消耗

Double CheckLock(DCL)实现单例：

/**
 * Created by xiaoming on 2017/2/13
 */

public class Singleton {
    //私有的属性
    private static Singleton sInstance = null;

    //私有的构造方法
    private Singleton() {

    }

    //对外暴露的业务方法
    public void doSomething() {
        System.out.print("do.something");
    }


    /***
     * 对外暴露的创建实例的方法
     * 至于为什么两次判定，第一次主要是为了不必要的同步，第二次视为了在为null的时候创建出实例
     *
     * @return
     */
    public static Singleton getInstance() {
        if (sInstance == null) {
            synchronized (Singleton.class) {
                if (sInstance == null) {
                    sInstance = new Singleton();
                }
            }
        }
        return sInstance;
    }
}

DCL的优点：资源利用率高，第一次执行getInstance（）时单例对象才会被实例化，效率高。缺点：第一次加载的时候反应稍慢，也会由于java的内存模型的原因会偶尔失败。在高并发的情况下也有一定的缺陷，虽然发生的概率很小。DCL模式是使用最多的单例模式，它能够在需要时才实例化对象并且在绝大多数的情况下保证单例对象的唯一性。

极其推荐的单例模式：<静态内部类单例模式>

public class Singleton {
    //私有的构造方法
    private Singleton() {

    }

    public static Singleton getInstance() {
        return SingletonHolder.sInstance;
    }

    /***
     * 静态内部类
     */
    private static class SingletonHolder {
        private static final Singleton sInstance = new Singleton();
    }
}