设计模式拙见--单例模式

一、前言

单例模式已经是一个非常常见的设计模式，在我们日常开发中也是非常容易遇到，但是你是不是真的掌握了呢？我们一起来探讨一下。

二、单例模式实现方式

作为一名程序员，我们经常在面试的时候被面试官问到，你会写几种单例模式？请你讲下饿汉模式和饱汉模式的区别？饥汉模式和懒汉模式的区别？双重校验锁的两个判空作用分别是什么？哪些实现是线程安全？诸如此类的问题，如果你对单例模式掌握得不够深，你一定会手忙脚乱，但是如果你掌握了，那么这一切对你来说都是小菜一碟。

1.懒汉（饱汉）模式和饿汉（饥汉）模式

区别：

• 懒汉（饱汉）模式：实例在开始时为空，等到第一次加载时才会实例化。
• 饿汉（饥汉）模式：在类加载前就已经实例化。

懒汉（饱汉）模式

/**
 * 懒汉（饱汉）模式
 * 懒加载：是
 * 线程安全：是
 * 描述：既实现了懒加载，也是线程安全，但是效率低，99%的情况下都不需要同步
 * 优点：第一次调用才初始化，避免了内存浪费
 * 缺点：必须加锁synchronized才能保证同步，但加锁会影响效率
 */
class LazyDogSingleInstance {
	private static LazyDogSingleInstance sInstance; 
	
	public static synchronized LazyDogSingleInstance getInstance() {
		
		if (sInstance == null) {
			sInstance = new LazyDogSingleInstance();
		}
		return sInstance;
	}
}

饿汉（饥汉）模式

/**
 * 饿汉（饥汉）模式
 * 懒加载：否
 * 线程安全：是
 * 描述：比较常用，但是容易产生垃圾对象
 * 优点：没有加锁，执行效率会提高
 * 缺点：类加载时就初始化，浪费内存
 *
 */
class HungryDogSingleInstance {
	private static HungryDogSingleInstance sInstance = new HungryDogSingleInstance();
	
	private HungryDogSingleInstance() {}
	private static HungryDogSingleInstance getInstance() {
		return sInstance;
	}
}

2.实现双重校验锁模式

双重判空的意义分别是什么：第一个判空是判断当前对象是否为空，判断是否需要实例化，第二个判空是因为加了锁，有可能在等待锁的时候这个对象已经被实例化，所以获取锁的时候需要重新判断一次这个对象是否为空。

/**
 * 双重校验锁模式
 * 懒加载：是
 * 线程安全：是
 * 描述：使用了双重校验锁，安全且在多线程下能保持高性能
 *
 */
class DoubleCheckSingleInstance {
	private static DoubleCheckSingleInstance sInstance;
	private DoubleCheckSingleInstance() {
	}
	private static DoubleCheckSingleInstance getInstance() {
		if (sInstance == null) {
			synchronized (DoubleCheckSingleInstance.class) {
				if (sInstance == null) {
					sInstance = new DoubleCheckSingleInstance();
				}
			}
		}
		return sInstance;
	}
}

3.实现静态内部类

/**
 * 静态内部类模式
 * 懒加载：是
 * 线程安全：是
 * 描述：利用了类加载机制保证初始化INSTANCE时只有一个线程，在初始化StaticInnerSingleInstance没有实例化INSTANCE，而是在调用getInstance时才实例化
 *
 */
class StaticInnerSingleInstance {
	private static class Holder {
		private static final  StaticInnerSingleInstance INSTANCE = new StaticInnerSingleInstance();
	}
	private StaticInnerSingleInstance() {}
	
	public static final StaticInnerSingleInstance getInstance() {
		return Holder.INSTANCE;
	}
}

三、单例模式优缺点

• 全局只有一个对象，对单例类的所有实例化得到都是同一个对象，这样就可以防止其它对象对自己的实例化，确保所有的对象都访问一个实例。
• 单例模式具有一定的伸缩性，类自己来控制实例化进程，类就在改变实例化进程上有相应的伸缩性。
• 提供了对唯一实例的受控访问。
• 由于在系统内存中只存在一个对象，因此可以节约系统资源，当需要频繁创建和销毁对象时，单例模式无疑可以提高系统的性能。
• 允许可变数目的实例。
• 避免对共享资源的多重占用。

缺点：

• 不适用于变化的对象，如果同一类型的对象总是要在不同的用例场景发生变化，单例就会引起数据的错误，不能保存彼此的状态。
• 由于单例模式中没有抽象层，因此单例类的扩展有很大的困难。
• 单例类的职责过重，在一定程度上违背了“单一职责原则”。
• 滥用单例将带来一些负面问题，如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。

四、Android中单例模式应用场景

1.AccessibilityManager

public final class AccessibilityManager {
    private static AccessibilityManager sInstance = new AccessibilityManager(null, null, 0);
    public static AccessibilityManager getInstance(Context context) {
        return sInstance;
    }
}

2.LayoutInflater

public class ContextThemeWrapper extends ContextWrapper {
    private LayoutInflater mInflater;

    @Override
    public Object getSystemService(String name) {
        if (LAYOUT_INFLATER_SERVICE.equals(name)) {
            if (mInflater == null) {
                mInflater = LayoutInflater.from(getBaseContext()).cloneInContext(this);
            }
            return mInflater;
        }
        return getBaseContext().getSystemService(name);
    }
}