单例模式——唯一实例与中心化

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

看上去很美好，实则有一个很大的隐患，多线程调用 getInstance 方法会产生多实例。

简单分析一下，假设 A 线程和 B 线程同时调用

A 线程执行 instance = new Singleton(); ，语句还没结束， instance 还为 null
这时候 B 线程进入语句 if (instance == null) ，条件成立，也进入 instance = new Singleton();
两个线程均建立了实例

为了确保能够延迟初始化，并且做到线程安全，下面会开始介绍

2.2. 懒汉：方法直接加同步（不要用）

最简单粗暴的方式，获取实例的方法直接上锁：

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

确实线程安全了。

但是 synchronized 是互斥锁，悲观锁，getInstance 被调用频繁的情况下性能低下。

这样吧，我们把锁的粒度

2.3. 懒汉：双重检查锁定（推荐，记得 volatile）

双重检查锁定，本质是对锁的一个粒度优化。

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

只有判断实例为空，才会进入同步代码。实例存在的话就直接返回了。

所以只有在创建的那一刹那，并且有多线程并发，会有一个互斥等待的过程。

因为进入同步代码，有可能其他线程已经实例化完毕，所以还要再检查一下是否已经实例化（判空），这就是双重检查。

因为 JVM 的指令优化，指令重排序现象会导致对象延迟初始化，所以其他线程读到实例不为空的时候，可能还没初始化。

所以需要加个 volatile 关键字，禁止重排序优化。

2.4. 懒汉：静态内部类（非常推荐）

这是一个比较机智的做法，利用 JVM 类加载机制，来延迟初始化对象实例

public class Singleton {    
    private static class LazyHolder {    
       private static final Singleton INSTANCE = new Singleton();    
    }    
    private Singleton (){}    
    public static Singleton getInstance() {    
       return LazyHolder.INSTANCE;    
    }
}

什么时候会进行类加载？

这里的静态内部类，外部的 Singleton 加载的时候并不会引起它的加载。因为虽然是它的内部静态类，但编译成字节码文件后是两个单独的类。

在调用 getInstance 方法后，静态内部类被主动调用，触发类加载流程。

而类加载流程是天然同步的，我们可以从源码上看到：

 protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
 {
	synchronized (getClassLoadingLock(name)) {
		...
		return c;
	}
}

我们也就不需要再进行加锁了。

2.5. 饿汉：静态工厂方法

在单例类加载的时候，马上实例化单例对象。

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

始终是线程安全的。

缺点是，及时没有调用该单例，也会在类使用的时候一开始就创建好了，在一些对性能要求高的场景会消耗性能。（这个在客户端场景比较常见）

2.6. 枚举实现

public enum Singleton {
 	INSTANCE;
 	private Singleton() {
 	}
}

创建枚举默认是线程安全的

3. 应用

什么时候需要使用单例？

控制实例的访问，所有的访问必须在单一实例上进行。

控制资源的使用，和线程池、连接池等配合使用，资源型单例，避免创建多个池导致资源的浪费。

控制对象的创建，不需要重复创建的对象，和工厂模式配合，比如实现工厂实例的唯一。

在客户端环境，比如 Android 开发，因为对应用启动的性能要求高，不希望应用一加载马上进行单例实例化，所以对懒汉模式应用较多。

3.1. JDK：Runtime

Runtime 可以获取 JVM 运行环境的信息。

public class Runtime {
    private static Runtime currentRuntime = new Runtime();
    
    public static Runtime getRuntime() {
        return currentRuntime;
    }

    /** Don't let anyone else instantiate this class */
    private Runtime() {}
	
	...
}

4. 特点

4.1. 优势

中心化：控制所有的访问在唯一实例上进行
性能优化：避免频繁创建和销毁对象带来的性能损耗
内存优化：避免可共享资源的重复创建

4.2. 缺点

职责膨胀：如果承担的职责过多，违背单一职责原则

优化思路

把职责再重新剥离出去，或者与其他设计模式一起使用，单例仅作为入口
内存泄漏：如果成员变量引用了本来该释放的对象，引起泄漏，进而导致 OOM（内存溢出）

优化思路

第一，注意引用对象的生命周期

第二，如果确定要引用，需要有良好的内存释放机制。比如该成员变量为缓存池，考虑使用弱引用或者软引用，在虚拟机垃圾回收阶段或者内存紧张的时候进行对象的回收

4.3. 注意事项

不要滥用：实例和进程生命周期一致，长期不使用白白占用内存
不要反射：发射生成实例，会破坏单例的设计。（之前有遇到坑，继承的第三方服务反射一个单例类导致不唯一）
注意引用：成员变量尽量不去持有生命周期短的对象，非要持久需要注意释放机制
注意性能：根据业务来决定是否需要延迟初始化（用来抉择懒汉还是饿汉）
注意线程安全：使用懒汉模式，注意线程安全避免产生多个实例

DestinLee

发布了61 篇原创文章 · 获赞 43 · 访问量 6万+

私信关注