Android 几种经常使用的设计模式之单例

一：单例模式

第一种（懒汉，线程不安全）：

public class Singleton {  

             private static Singleton instance;  

             private Singleton (){}  

            public static Singleton getInstance() {  

            if (instance == null) {  

            instance = new Singleton();  

             }  

             return instance;  

         }  

}  

 这种写法lazy loading很明显，可是致命的是在多线程不能正常工做。

 

第二种（懒汉，线程安全）：

public class Singleton {  

    private static Singleton instance;  

    private Singleton (){}  

    public static synchronized Singleton getInstance() {  

    if (instance == null) {  

     instance = new Singleton();  

    }  

    return instance;  

 }  

}  

这种写法可以在多线程中很好的工做，并且看起来它也具有很好的lazy loading，可是，遗憾的是，效率很低，99%状况下不须要同步。

 

第三种（饿汉）：

public class Singleton {  

    private static Singleton instance = new Singleton();  

    private Singleton (){}  

     public static Singleton getInstance() {  

    return instance;  

    }  

}  

这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然致使类装载的缘由有不少种，在单例模式中大多数都是调用getInstance方法， 可是也不能肯定有其余的方式（或者其余的静态方法）致使类装载，这时候初始化instance显然没有达到lazy loading的效果。

 

第四种（饿汉，变种）：

public class Singleton {  

    private Singleton instance = null;  

    static {  

        instance = new Singleton();  

    }  

    private Singleton (){}  

    public static Singleton getInstance() {  

    return this.instance;  

    }  

}  

 表面上看起来差异挺大，其实跟第三种方式差很少，都是在类初始化即实例化instance。

 

第五种（静态内部类）：

public class Singleton {  

    private static class SingletonHolder {  

    private static final Singleton INSTANCE = new Singleton();  

    }  

     private Singleton (){}  

    public static final Singleton getInstance() {  

        return SingletonHolder.INSTANCE;  

     }  

}   

第六种（枚举）：

public enum Singleton {  

    INSTANCE;  

    public void whateverMethod() {  

     }  

}  

 这种方式是Effective Java做者Josh Bloch 提倡的方式，它不只能避免多线程同步问题，并且还能防止反序列化从新建立新的对象，可谓是很坚强的壁垒啊，不过，我的认为因为1.5中才加入enum特性，用这种方式写难免让人感受生疏，在实际工做中，我也不多看见有人这么写过。

第七种（双重校验锁）：

public class Singleton {  

    private volatile static Singleton singleton;  

    private Singleton (){}  

    public static Singleton getSingleton() {  

         if (singleton == null) {  

             synchronized (Singleton.class) {  

                    if (singleton == null) {  

                    singleton = new Singleton();  

                     }  

                }  

        }  

     return singleton;  

    }  

}  

 这个是第二种方式的升级版，俗称双重检查锁定，详细介绍请查

这种方式一样利用了classloder的机制来保证初始化instance时只有一个线程，它跟第三种和第四种方式不一样的是（很细微的差异）：第三种和第四种方式是只要Singleton类被装载了，那么instance就会被实例化（没有达到lazy loading效果），而这种方式是Singleton类被装载了，instance不必定被初始化。由于SingletonHolder类没有被主动使用，只有显示经过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，若是实例化instance很消耗资源，我想让他延迟加载，另一方面，我不但愿在Singleton类加载时就实例化，由于我不能确保Singleton类还可能在其余的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式相比第三和第四种方式就显得很合理。