单例模式 | 苏富仕的博客

单例模式简介

单例模式是应用最广的模式之一。在应用这个模式时，单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个全局变量，这样有利于我们协调系统整体的行为。

定义

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。
使用场景

确保某个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或者某种类型的对象只应该有且只有一个。例如，创建一个对象需要消耗的资源很多，如要访问IO和数据可等资源，这时就要考虑使用单例模式。
UML类图

Client：高层客户端

Singleton：单例类

实现单例模式主要有如下几个关键点：

①构造函数不对外开放，一般为private。

②通过一个静态方法或者枚举返回单例类对象。

③确保单例类的对象有且只有一个，尤其是在多线程环境下。

④确保单例类对象在反序列化时不会重新构建对象。

通过将单例类的构造函数私有化，使得客户端代码不能通过new的形式手动构建单例类的对象。单例类会暴露一个公有静态方法，客户端需要调用这个静态方法获取到单例类的唯一对象，在获取这个单例类对象的过程中需要确保线程安全，即在多线程环境下构造单例类的对象也是有且只有一个，这也是单例模式实现中比较困难的地方。

单例模式的实现

饿汉模式

饿汉模式是在声明对象时就已经进行初始化。

public class Singleton {
    private static Singleton sInstance = new Singleton();
  
  	private Singleton() {
        
    }
  
  	public static Singleton getInstance() {
        return sInstance;
    }
}

懒汉模式

懒汉模式是声明一个静态对象，并且在用户第一次调用getInstance时进行初始化。

public class Singleton {
    private static Singleton sInstance;
  
  	private Singleton() {
        
    }
  
  	public static synchronized Singleton getInstance() {
      	if (sInstance == null) {
            sInstance = new Singleton();
        }
        return sInstance;
    }
}

Double Check Lock（DCL）方式

DCL方式实现单例模式的优点是既能够在需要时才初始化单例，又能够保证线程安全，且单例对象初始化后调用getInstcnce不进行同步锁。

public class Singleton {
    private static Singleton sInstance = null;
  
  	private Singleton() {
        
    }
  
  	public static Singleton getInstance() {
      	if (sInstance == null) {
            synchronized (Singleton.class) {
              	if (sInstance == null) {
                    sInstance = new Singleton();                 
                }
            }
        }
        return sInstance;
    }
}

可以看到，getInstance()方法对sInstance进行了两次判空：第一层判断是为了避免不必要的同步，第二层的判断是为了在null的情况下创建实例。

静态内部类单例模式

DCL虽然在一定程度上解决了资源消耗、多余的同步、线程安全等问题，但是，它还是在某些情况下出现失效的问题。这个问题被称为双重检查锁定失效。所以，建议使用如下的代码替代。

public class Singleton {
    private Singelton() {
        
    }
  	
  	public static Singleton getInstance() {
        return SingletonHolder.sInstance;
    }
  
  	private static class SingletonHolder {
        private static final Singleton sInstance = new Singleton();
    }
}

当第一次加载Singleton类时并不会初始化sInstance，只有在第一次调用Singleton的getInstance方法时才会导致sInstance被初始化。因此，第一次调用getInstance方法会导致虚拟机加载SingletonHolder类，这种方式不仅能够保证线程安全，也能够保证单例对象的唯一性，同时也延迟了单例模式的实例化，所以这是推荐的单例模式实现方式。

枚举单例

写法简单是枚举单例最大的优点，枚举在Java中与普通的类是一样的，不仅能够有字段，还能够有自己的方法。最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。

public enum SingletonEnum {
    INSTANCE;
    public void doSometing() {
        ...
    }
}

使用容器实现单例模式

在程序的初始，将多种实例类型注入到一个统一的管理类中，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

public class SingletonManager {
    private static Map<String, Object> objMap = new HashMap<>();
  
  	private SingletonManager() {
        
    }
  
  	public static void registerService(String key, Object instance) {
        if (! objMap.containKey(key)) {
            objMap.put(key, instance);
        }
    }
  
  	public static Object getService(String key) {
        return objMap.get(key);
    }
}

不管是以哪种形式实现单例模式，它们的核心原理都是将构造函数私有化，并且通过静态方法获取一个唯一的单例，在这个获取的过程中必须保证线程安全、防止反序列化导致重新生成实例对象等问题。选择哪种实现方式取决于项目本身，如是否是负责的并发环境、JDK版本是否过低、单例对象的资源消耗等。

android源码中得到单例模式

在android系统中，我们经常会通过Context获取系统级别的服务，如WindowManagerService、ActivityManagerService等，更常用的是一个LayoutInflater的类，这些服务会在合适的时候以单例的形式注册在系统中，在我们需要的时候就通过Context的getSystemService(String name)获取。我们以LayoutInflater为例来说明，平时我们使用LayoutInflater较为常见的地方是在ListView的适配器的getView()方法中。

Override
public View getView(int position, View convertView, ViewGroup container) {
	if (convertView == null) {
		convertView = LayoutInflater.from(mContext).inflate(R.layout.list_item, container, false);
		...
	} else {
      	...
	}
	...
	return convertView;
}

通常我们使用LayoutInflater.from(Context)来获取LayoutInflater服务，下面看看其实现。

public static LayoutInflater from(Context context) {
    LayoutInflater LayoutInflater =
            (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
    if (LayoutInflater == null) {
        throw new AssertionError("LayoutInflater not found.");
    }
    return LayoutInflater;
}

我们知道Context的实现类是ContextImpl，继续看ContextImpl的实现。

class ContextImpl extends Context {
  	final Object[] mServiceCache = SystemServiceRegistry.createServiceCache();
    @Override
    public Object getSystemService(String name) {
        return SystemServiceRegistry.getSystemService(this, name);
    }
}

ContextImpl类把服务注册和获取交给SystemServiceRegistry处理。

final class SystemServiceRegistry {
  	private static final HashMap<String, ServiceFetcher<?>> SYSTEM_SERVICE_FETCHERS =
            new HashMap<String, ServiceFetcher<?>>();
  	
  	static {
        ...
        registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
            new CachedServiceFetcher<LayoutInflater>() {
            	@Override
            	public LayoutInflater createService(ContextImpl ctx) {
                	return new PhoneLayoutInflater(ctx.getOuterContext());
        }});
      	...
    }
  
	public static Object getSystemService(ContextImpl ctx, String name) {
        ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
        return fetcher != null ? fetcher.getService(ctx) : null;
    }    
  
  	private static <T> void registerService(String serviceName, Class<T> serviceClass,
            ServiceFetcher<T> serviceFetcher) {
        SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);
        SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);
    }
  
  	static abstract interface ServiceFetcher<T> {
        T getService(ContextImpl ctx);
    }
  
  	static abstract class CachedServiceFetcher<T> implements ServiceFetcher<T> {
        private final int mCacheIndex;
        public CachedServiceFetcher() {
            mCacheIndex = sServiceCacheSize++;
        }
        @Override
        @SuppressWarnings("unchecked")
        public final T getService(ContextImpl ctx) {
            final Object[] cache = ctx.mServiceCache;
            synchronized (cache) {
                // Fetch or create the service.
                Object service = cache[mCacheIndex];
                if (service == null) {
                    service = createService(ctx);
                    cache[mCacheIndex] = service;
                }
                return (T)service;
            }
        }
        public abstract T createService(ContextImpl ctx);
    }
}

从SystemServiceRegistry类的部分代码可以看出，在虚拟机第一次加载该类时会注册各种ServiceFercher，其中包含了LayoutInflater Service。将这些服务以键值对的形式存储在一个HashMap中，用户使用时只需要根据key来获取对应地ServiceFetcher，然后通过ServiceFetcher对象的getService函数来获取具体的服务对象。当第一次获取时，会调用ServiceFetcher的createService函数创建服务对象，然后将该对象缓存到一个列表中，下次再取时从缓存中获取，避免重新创建对象，从而达到单例的效果。这种模式就是前面所说的通过容器的单例模式实现方式，系统核心服务以单例形式存在，减少了单例资源消耗。

总结

单例模式是运用频率最高的模式，但是，由于在客户端通常没有高并发的情况，因此，选择哪种实现方式并不会有太大的影响。单例模式的优缺点如下。

优点

由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。
由于单例模式只生成一个实例，所以，减少了系统的性能开销，当一个对象的生产需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决。
单例模式可以避免对资源的多重占用，例如一个写文件操作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
单例模式可以在系统设置全局的访问点，优化和共享戏院访问，例如，可以设计一格单例类，负责所有数据表的映射处理。

缺点

单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途经可以实现。
单例对象如果持有Context，那么很容易引发内存泄漏，此时需要注意传递给单例对象的Context最好是Application Context。