最近学习设计模式想着把学到的东西记录一下。同时也想翻一下Android源码,试图在Android源码里面翻出所有的设计模式。今天开始第一个模式--单例模式。
单例模式:保证一个类仅有一个实例,并提供一个访问它的全局访问点。
单例模式主要解决一个全局使用的类频繁地创建和销毁。当需要控制类的实例数量,节省系统资源时,应该考虑使用单例模式。
优点:在内存中只有一个实例,减少了内存的开销,尤其是频繁的创建和销毁实例。避免对资源的多重占用。
缺点:没有接口,不能继承,与单一职责原则冲突,一个类应该只关心内部逻辑,而不关心外面怎么样来实例话。
单例模式使用代码示例:
public class Main{
public static void main(String[] args){
SingleObject object = SingleObject.getInstance();//唯一获得实例的方式
}
}
class SingleObject{
private static SingleObject instance = new SingleObject();
private SingleObject(){}//构造函数私有化,不让外部通过new创建对象
public static SingleObject getInstance(){
return instance;
}
}
单例模式的实现方式:
1、懒汉式,线程不安全
懒汉式的“懒”,是指懒加载,那懒加载是啥呢?我们知道,程序在运行时,当需要用到哪个Java文件的时候,JVM就会加载哪个文件,并且完成静态变量,静态代码块的执行。那么这里的懒加载值得就是在JVM加载这个单例模式类的时候,创建的这个单例类对象没有一开始就new出来,而是在getInstance方法中初始化。这种方式是最基本的实现方式,它最大的问题是不支持多线程。因为没有加锁synchronized,所以严格意义上不算单例模式。这种方式懒加载很明显,不要求线程安全,在多线程不能正常工作。
public class Singleton{
private static Singleton instance = null;
private Singleton(){}//私有构造函数
public static Singleton getInstance(){
if(instance == null){
instance = new Singleton();//为null时赋值
}
return instance;
}
}
2、懒汉式,线程安全。
这种方式具备很好的懒加载,能够在多线程中很好的工作,但是,效率很低,99%情况下不需要同步。优点:第一次调用初始化,避免内存浪费。缺点,必须加锁synchronized才能保证单例,加锁会影响效率。
public Singleton{
private static Singleton instance = null;
private Singleton(){}//构造函数私有
public static synchronized Singleton getInstance(){//加了锁
if(instance == null){
instance = new Singleton();
}
return instance;
}
}
3、饿汉式
这种方式与懒加载相比,它在JVM加载Java文件的时候给静态成员instance进行了初始化,可以形象的比喻成一个饿久了的汉子迫不及待的要吃到东西,所以一开始就赋值。所以它不是懒加载,同时它是线程安全的,因为instance是类的静态成员,不管何时何地,这个类都只保存一个instance对象。它的优点是:没有加锁,执行效率会提高。缺点:类加载时就初始化,浪费内存。
public class Singleton{
private static Singleton instance = new Singleton();//类加载时就初始化
private Singleton(){}//构造函数私有化
public static Singleton getInstance(){
return instance;
}
}
4、双重校验锁
这种方式采用双锁机制,安全且在多线程情况下能保持高性能。同时这种方式可以达到懒加载的效果。
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;
}
}
5、登记室/静态内部类
这种方式对于我来说是一种全新的方式,以前没见过。先看代码。
public class Singleton{
private static class SingletonHolder{//私有内部类
public static final Singleton INSTANCE = new Singleton();
}
private Singleton(){}//构造函数私有化
public static Singleton getInstance(){
return SingletonHolder.INSTANCE;
}
}
通过上述代码,可以看出,这种方式实现比较简单,它也能在多线程情况下保持高性能。这种方式适用于静态域延迟初始化。双捡锁方式可在实例域需要延迟初始化时使用。这种方式也是利用类加载机制来保证初始化instance时只有一个线程,它跟双捡锁方式的不同之处在于,双捡锁在类加载的时候就进行instance的初始化。而在这种方式下,Singleton类被加载的时候,内部类(没有被主动使用)不一定在这个时候加载,instance不一定被初始化。如果实例话instance很消耗资源,想让它延迟加载,又不希望在Singleton类加载时就实例化。这时候使用静态内部类方式是很合理的。
6、枚举
这种方式我也没遇到过。据说是没有广泛采用,但它是单例模式最佳方法。它更简洁,自动支持序列化机制,绝对防止多次实例化。它是线程安全的,但不是懒加载。
public enum Singleton{
INSTANCE;
public void whateverMethod();
}
单例模式的创建方式就是以上六种。
经验之谈:一般情况下,不建议使用第 1 种和第 2 种懒汉方式,建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时,
才会使用第 5 种登记方式。如果涉及到反序列化创建对象时,可以尝试使用第 6 种枚举方式。如果有其他特殊的需求,可以考虑使用
第 4 种双检锁方式。
在Android中,也有一个类转门生成单例,源代码如下:
public abstract class Singleton<T> {
private T mInstance;
protected abstract T create();
public final T get() {
synchronized (this) {
if (mInstance == null) {
mInstance = create();
}
return mInstance;
}
}
}
它有点像第二种方式。懒汉式线程安全~
文章编写总结自单例模式 和《大话设计模式》