上一篇博客已经介绍了设计模式及其设计原则, 在这篇博客中笔者会介绍一下单例模式, 也是最简单的一种设计模式
单例模式
单例模式属于创建型模式. 它涉及到一个单一的类, 该类负责创建自己的对象, 同时确保只有单个对象被创建, 这个类提供了一种访问其唯一对象的方式, 可以直接访问, 不需要实例化这个类的对象
单例模式结构
- 单例类. 只能创建一个实例的类
- 访问类. 使用单例类
单例模式实现
- 饿汉式单例
特点: 在类加载时就创建实例, 线程安全, 但是可能会导致资源浪费
public class Singleton {
// 在类加载时就创建实例instance
private static final Singleton instance = new Singleton();
// 私有的构造函数, 避免从外部构造新实例
private Singleton() {}
// 提供一个全局访问的接口, 可以获取已经创建好的单个实例instance
public static Singleton getInstance() {
return instance;
}
}
- 懒汉式单例
特点: 延迟创建实例, 但是线程不安全
public class Singleton {
// 单个的实例
private static Singleton instance;
// 私有的构造函数, 避免从外部构造新实例
private Singleton() {}
// 提供一个全局访问的接口, 可以获取已经创建好的单个实例instance
public static Singleton getInstance() {
// 假如这时instance还没有被创建, 那么就创建一个新的实例instance
if (instace == null) {
instance = new Singleton();
}
return instance;
}
}
懒汉式单例模式在多线程环境下容易导致线程不安全, 这是因为多个线程可能会同时访问 getInstance() 方法并且同时进入 if (instance == null) 代码块, 这样就会创建多个实例, 违背了单例模式的原则.
- 线程安全的懒汉式单例
特点: 延迟创建实例, 使用同步方法保证线程安全, 但是会有性能开销
public class Singleton {
// 单个的实例
private static Singleton instance;
// 私有的构造函数, 避免从外部构造新实例
private Singleton() {}
// 提供一个全局访问的接口, 可以获取已经创建好的单个实例instance, 使用同步方法保证线程安全
public static synchronized Singleton getInstance() {
// 假如这时instance还没有被创建, 那么就创建一个新的实例instance
if (instace == null) {
instance = new Singleton();
}
return instance;
}
}
- 双重检查锁
特点: 提高性能, 减少同步开销, 线程安全
public class Singleton {
// 单个的实例
private static Singleton instance;
// 私有的构造函数, 避免从外部构造新实例
private Singleton() {}
// 提供一个全局访问的接口, 可以获取已经创建好的单个实例instance
public static Singleton getInstance() {
// 第一次判断实例是否为null, 如果不为null就直接返回实例, 不进入抢锁阶段
if (instance == null) {
synchronized (Singleton.class) {
// 抢到锁了再判断一次是否为null
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
双重检查锁模式可能会出现空指针问题, 出现问题的原因是JVM在实例对象时会进行优化和指令重排序操作
为了解决空指针异常问题, 可以使用 volatile 关键字, volatile 关键字可以保证可见性和有序性
public class Singleton {
// 单个的实例, 使用volatile关键字保证其可见性和有序性
private static volatile Singleton instance;
// 私有的构造函数, 避免从外部构造新实例
private Singleton() {}
// 提供一个全局访问的接口, 可以获取已经创建好的单个实例instance
public static Singleton getInstance() {
// 第一次判断实例是否为null, 如果不为null就直接返回实例, 不进入抢锁阶段
if (instance == null) {
synchronized (Singleton.class) {
// 抢到锁了再判断一次是否为null
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
笔者写到这一段的时候突然想到, 如果把上面双重检查锁的代码略改一下, 改成下面这样, 是否可行?
// Double-Checked Locking version 1
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
//======================================
// Double-Checked Locking version 2
public static Singleton getInstance() {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
return instance;
}
上面的两种改法, 分别是把synchronized同步块内和同步块外的判断语句 if (instance == null) 删掉之后得到的新代码.
上面这两种改法是否可行呢? 其实都不好. 对于版本1, 假设有线程1和线程2, 进行了如下操作
---------------------------------------------------------
Thread 1 Thread 2
| |
| |
| |
| |
走到synchronized代码块处 |
拿到锁之后发生了一次线程切换 |
| |
| 走到synchronized代码块处, 拿不到锁, 被阻塞
| 线程切换
| |
Thread 1创建了一个新实例 |
Thread 1离开了synchronized代码块 |
锁被释放 |
线程切换 |
| |
| |
| Thread 2拿到锁
| Thread 2创建了新实例 (这里违背了单例模式原则)
| Thread 2离开了synchronized代码块
| Thread 2返回了创建的实例
| 线程切换
| |
Thread 1返回创建的实例 |
---------------------------------------------------------
这就和线程不安全的懒汉单例模式一样了
对于版本2, 其实和使用同步代码块的懒汉单例模式也是一样的, 线程是安全的, 但是性能开销依然存在
- 静态内部类
特点: 利用类加载机制实现懒加载, 线程安全
public class Singleton {
// 私有的构造函数, 避免从外部构造新实例
private Singleton() {}
// 静态内部类, 延迟加载
private static class SingletonHelper {
private static final Singleton INSTANCE = new Singleton();
}
// 提供一个全局访问的接口, 可以获取已经创建好的单个实例instance
public static Singleton getInstance() {
return SingletonHelper.INSTANCE;
}
}
- 枚举单例
特点: 简单, 线程安全, 防止反序列化导致创建新的实例
public enum Singleton {
INSTANCE;
// 其他方法
public void someMethod() {
// do something
}
}
单例模式被破坏的情况
除了枚举单例模式之外, 其他单例模式都可以被破坏. 破坏单例模式的方法有两种, 分别为 序列化 和 反射
- 序列化破坏单例模式
因为在序列化和反序列化过程中, 会创建一个新的实例, 即使单例类在内存中有一个唯一的实例, 通过反序列化也能创建多个实例, 这样就破坏了单例模式的初衷
假设有一个单例类如下:
import java.io.Serializable
public class Singleton implements Serializable {
private static final long serialVersionUID = 1L;
private static final Singleton instance = new instance();
private Singleton();
public Singleton getInstance() {
return instance;
}
// other methods...
}
破坏单例模式的场景
import java.io.*;
public class SingletonDemo {
public static void main(String[] args) {
try {
Singleton instance1 = Singleton.getInstance();
// 序列化
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("singleton.ser"));
out.writeObject(instance1);
out.close();
// 反序列化
ObjectInputStream in = new ObjectInputStream(new FileInputStream("singleton.ser"));
Singleton instance2 = (Singleton) in.readObject();
in.close;
System.out.println("Instance 1 hash code: " + instance1.hashCode());
System.out.println("Instance 2 hash code: " + instance2.hashCode());
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行 SingletonDemo, 发现 instance1 和 instance2 的哈希码并不相同, 说明它们是不同的实例, 这就破坏了单例模式
为了防止序列化破坏单例模式, 可以在单例类中定义 readResolve 方法, 这个方法在反序列化时会被调用, 返回当前的单例实例, 从而确保反序列化得到的始终是唯一的单例实例
改进之后的单例类
import java.io.Serializable
public class Singleton implements Serializable {
private static final long serialVersionUID = 1L;
private static final Singleton instance = new instance();
private Singleton();
public Singleton getInstance() {
return instance;
}
// 添加readResolve方法
protected Object readResolve() {
return getInstance();
}
// other methods...
}
再次运行 SingletonDemo , 发现 instance1 和 instance2 的哈希码是相同的, 因此它们是同一个实例, 单例模式没有被破坏.
- 反射破坏单例模式
因为反射允许我们访问私有构造方法, 从而构建多个对象, 这就违背了单例模式的初衷
假设有一个单例类如下:
public class Singleton {
private static final Singleton instance = new Singleton();
private Singleton() {}
public static Singleton getInstance() {
return instance;
}
}
破坏单例模式的场景
import java.lang.reflect.Constructor;
public class SingletonDemo {
public static void main(String[] args) {
try {
Singleton instance1 = Singleton.getInstance();
// 通过反射创建新的实例
Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
Singleton instance2 = constructor.newInstance();
// 检查两个实例是否相同
System.out.println("Instance 1 hash code: " + instance1.hashCode());
System.out.println("Instance 2 hash code: " + instance2.hashCode());
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行 SingletonDemo, 发现 instance1 和 instance2 的哈希码并不相同. 说明它们是不同的实例, 单例模式被破坏
为了防止反射破坏单例模式, 可以在构造方法中添加防御措施, 例如在构造方法中检测实例是否存在, 如果存在就抛出异常
改进之后的单例类
public class Singleton {
private static final Singleton instance = new Singleton();
private Singleton() {
// 防止反射创建新的实例
if (instance != null) {
throw new RuntimeException("Use getInstance() method to get the single instance of this class.");
}
}
public static Singleton getInstance() {
return instance;
}
}
再次运行 SingletonDemo, 发现反射创建实例的步骤会抛出异常, 阻止了反射破坏单例模式
最近在学设计模式, 可能会高强度更新设计模式相关的技术博客. 对设计模式感兴趣的读者可以关注我的 CSDN Channel, 掘金 Channel, 我的个人博客网站 或 网站的镜像站点
扫一扫
595
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
