Android中的设计模式-单例模式
单例模式算是比较常用的模式,在Java中如果想要一个JVM中只存在某个类的一个实例,就需要使用到单例模式,而只存在一个实例的需求一般是因为:
1,对象实例比较大和复杂,创建开销很大。
2,只需要一个实例来维护整个功能的流程与交互。
例如Android中的电话应用启动时,对于单卡单待的电话,只创建一个Phone对象,用来管理RIL,CallTracker,ServiceStateTracker等对象,手机中不存在第二个Phone对象去和RILC通信。
类图
单例的类图很简单,看起来也很简单,只需要一个类只能得到一个实例即可,但是我觉得单例比其他创建型的模式要复杂的多。
如果想要创建一个类Singleton。正常来讲只需要new Singleton()即可,但是如果想Singleton只存在一个实例,则不能采用这种方法来创建,因为每一次new都会产生一个新的实例:
1,为了不能使用new创建,就要把构造函数变成private的;
2, 为了只有一个实例,就需要Singleton本身去维护这个实例,于是类中需要定义一个Singleton instance,显然它应该是private的,因为它是类的实例,不是对象的实例,所以它还应该是静态的;
3,因为不能new,为了能够有方法得到Singleton的实例,就得通过一个静态方法返回实例,比如public static Singleton getInstance(),在内部如果instance是null的则新建,否则返回instance即可,
说了这么多其实需要注意的东西还是蛮多的,根据上面的分析,已经能够创建出一个最简单单例模式了。
普通饿汉单例模式
public class Singleton { private static Singleton instance = new Singleton(); private Singleton() { // Nothing } public static Singleton getInstance(){ return instance; } public void say(){ System.out.println("I am singleton"); } }
饿汉单例会在类装载时就实例化。好处就是由于classloder机制,保证当一个类被加载的时候,这个类的加载是线程互斥的,而饿汉单例的静态instance直接新建一个实例,在加载的时候就能线程安全的获得实例。从而避免了线程安全问题。
劣势就是实例在装载的时候就会浪费资源和时间去实例化。虽然大多数时候都是在调用getInstance时才会装载,不过也没法保证是否有其他方法会使用到instance而导致新建实例。
惰性加载单例模式
这个Singleton单例类在被加载的时候就会创建实例,为了让它在使用的时候才创建对象所以把它设为null。让它在getInstace的时候再新建实例,也就是惰性加载。这里也叫懒汉式单例。
public class lazySingleton { private static lazySingleton instance = null; private lazySingleton() { // TODO Auto-generated constructor stub } public static lazySingleton getInstace() { if (instance==null){ instance =new lazySingleton(); } return instance; } public void say(){ System.out.println("I am lazySingleton"); } }
加锁单例模式
前面的懒汉例子用在单线程中不会出现问题,但是如果用在单线程中就会出现问题。如果AB两个线程都通过getInstace去获取单例的实例,因为没法保证getInstace方法会在一个线程中一直执行完再执行另一个线程,如果两个线程都判定instance位null,则有可能都会进入new语句新建实例。
为了保证同一时刻只有一个线程能够执行getInstance,就需要对方法加锁,或者在方法内部使用对象锁,但是注意要把锁放在if(instance == null) 判断的外面,否则还是可能出现同时判定true的情况。
public class SyncSingleton { private static SyncSingleton instance = null; private SyncSingleton() { // TODO Auto-generated constructor stub } public static synchronized SyncSingleton getInstance(){ if (instance == null){ instance = new SyncSingleton(); } return instance; } }
或者
public class SyncSingleton { private static SyncSingleton instance = null; private static final Object classLock = SyncSingleton.class; private SyncSingleton(){} public SyncSingleton getInstance(){ synchronized(classLock){ if(instance == null) instance = new SyncSingleton(); return instance; } } }
双重检查加锁单例
上面的问题解决了多线程的问题,但是也会带来性能的问题,因为每次调用getInstance,都会进行同步,但实际上,如果instance实例已经建立,那直接返回instance实例就好,这里是不用加锁的,只有新建实例的情况才需要同步锁,但是前面也说到了,新建的时候要把锁放在if(instance == null) 判断的外面,否则还是可能出现同时判定true的情况。所以就有了下面的双重检查的单例模式
public class EffectiveSingleton { private volatile static EffectiveSingleton instance = null; private EffectiveSingleton() { // TODO Auto-generated constructor stub } public static EffectiveSingleton getInstance() { if (instance == null) { // 首先判断是否已经创建实例,如果已经创建,直接返回,效率高 synchronized (EffectiveSingleton.class) {// 如果没有创建,然后再同步,并在同步块内再初始化。注意要再次判断是否已实例化 if (instance == null) { instance = new EffectiveSingleton(); } } } return instance; } }
这样当实例初始化已经完成的情况,每次getInstance直接返回即可,不再需要同步锁。
当第一次调用getInstance时,则通过synchronized块包裹的代码部分保证不会多次调用新建实例。
第二个if (instance == null) 条件判断是为了第一个if (instance == null) 是给已经存在实例的情况用的,AB线程还是有可能都通过第一个条件判断的。这就需要在同步块内,一定要有一个条件判断。
双重检查加锁单例模式很好地解决了加锁单例的性能问题。
使用静态内部类的单例模式
静态内部类也叫嵌套类,用这个名字给他定义是更加形象的。意思是说内部类和外部类的关系只是层次嵌套关系,所以只是在创建类文件的时候类文件名是如下形式:outer$inner.java,在使用方面完全和两个普通类一样。
在饿汉单例的基础上,把instance = new Singleton()外用一个叫做SingletonHolder 的静态内部类包装一下。
这样即使在Singleton类加载的时候,也不会导致静态内部类SingletonHolder 的加载,只有在使用到SingletonHolder 的时候,才会加载。
同时由于类的加载的机制的互斥性,保证创建实例时候的线程安全性。
class Singleton { private static class SingletonHolder { private static final Singleton instance = new Singleton(); } private Singleton() { } public static final Singleton getInstance() { return SingletonHolder.instance; } }
Android中的单例
通过PhoneFactory创建Phone对象的例子,截取部分如下:
public class PhoneFactory { static private Phone sProxyPhone = null; ...... public static void makeDefaultPhone(Context context) { synchronized(Phone.class) { if (!sMadeDefaults) { ... sProxyPhone = new PhoneProxy(new GSMPhone(context, sCommandsInterface, sPhoneNotifier)); ... sMadeDefaults = true; } } }
可以看出这个例子符合上面的加锁单例模式,虽然不是采用的双重判断的方式来增加效率,但是因为PhoneFactory的makeDefaultPhone基本没有多线程使用情况,只有在Phone应用启动的情况下调用一起。
并且PhoneFactory通过makeDefaultPhone来创建实例,但是却使用getDefaultPhone来获取实例,也就不存在实例已经存在的情况下,还进入同步块进行判断的情况。