[关闭]
@coder-pig 2021-01-14T08:09:53.000000Z 字数 9312 阅读 202

重学设计模式 | 单例模式

设计模式


0x1、定义

0x2、单例写法的演进

① 饿汉式(没有懒加载,线程安全,常用)

  1. public class Singleton () {
  2. private static Singleton instance = new Singleton()
  3. private Singleton(){ }
  4. public static Singleton getInstance() {
  5. return instance;
  6. }
  7. }

② 懒汉式(懒加载,线程不安全,不推荐使用)

就是在饿汉式的基础上加了一个判空,调用getInstance()方法才初始化实例:

  1. public class Singleton {
  2. private static Singleton instance = null;
  3. private Singleton() { }
  4. private static Singleton getInstance() {
  5. if(instance == null) {
  6. instance = new Singleton();
  7. }
  8. return instance;
  9. }
  10. }

虽然实现了懒加载,却存在线程安全问题,比如两个线程,都刚好走到判空,实例为空初始化,结果可能导致实例化了两个Singleton对象,破坏了单例,一种升级版的解决方式是加锁。

③ 升级版懒汉式(线程安全,但效率低,不推荐使用)

  1. public class Singleton {
  2. private Singleton instance = null;
  3. private Singleton() { }
  4. public static synchronized Singleton getInstance() {
  5. if(instance == null) {
  6. instance = new Singleton();
  7. }
  8. return instance;
  9. }
  10. }

给getInstance()函数加锁,保证了线程安全,但也导致了函数的并发度很低,相当于串行操作,频繁调用此函数,会频繁地加锁、释放锁、效率太低。

而且,其实只需要在new的时候考虑线程同步就行了,所以改进后的DCL单例来了~

④ 懒汉式双重校验锁(DCL,线程安全,推荐使用)

  1. public class Singleton {
  2. private static Singleton instance = null;
  3. private Singleton() { }
  4. public static Singleton getInstance() {
  5. if(instance == null) {
  6. synchronized(Singleton.class) {
  7. if(instance == null) {
  8. instance = new Singleton();
  9. }
  10. }
  11. }
  12. return instance;
  13. }
  14. }

代码看似完美,但还存在最后一个问题:指令重排序

JVM在保证最终结果正确的情况下,可以不按照编码的顺序执行语句,尽可能地提高程序的性能。

创建一个对象,在JVM中会经过这三步:

  • 1、为instance分配内存空间;
  • 2、初始化instance对象;
  • 3、将instance指向分配好的内存空间;

在这三步中,第2、3步有可能发生指令重排现象,导致对象的创建顺序变成了:1-3-2,多个线程在获取对象时,有可能获取到为初始化的instance对象对象,引起NPE异常。示例流程图如下所示:

而使用volatile关键字修饰变量,可以防止指令重排序(原理是内存屏障),使得指令执行顺序与程序指明顺序一致。

修改后的代码如下:

  1. public class Singleton {
  2. private static volatile Singleton instance = null;
  3. private Singleton() { }
  4. public static Singleton getInstance() {
  5. if(instance == null) {
  6. synchronized(Singleton.class) {
  7. if(instance == null) {
  8. instance = new Singleton();
  9. }
  10. }
  11. }
  12. return instance;
  13. }
  14. }

上面这个防止指令重排序又称有序性,接着说说可见性,即 每一时刻线程读取该变量的值都是内存中最新的值

也可以这样理解:

volatile修饰的变量,在线程对其进行写入操作时,不会把值缓存到工作内存中,而是直接将修改后的值重新刷回主内存。而当处理器监控(嗅探)到其他线程中该变量在主内存中的内存地址发生变化时,会让这些线程重新到主内存中拷贝这个变量的最新值到工作内存中,而不是继续使用工作内存中的旧缓存。

未加volatile的简单代码示例如下:

  1. public class JavaTest {
  2. public static void main(String[] args) {
  3. Test test = new Test();
  4. test.start();
  5. while (true){
  6. if (test.isFlag()) {
  7. System.out.println("flag为true");
  8. break;
  9. }
  10. }
  11. }
  12. }
  13. class Test extends Thread {
  14. private boolean flag = false;
  15. public boolean isFlag() {
  16. return flag;
  17. }
  18. @Override
  19. public void run() {
  20. try {
  21. Thread.sleep(1000);
  22. } catch (InterruptedException e) {
  23. e.printStackTrace();
  24. }
  25. flag = true;
  26. System.out.println("flag = " + flag);
  27. }
  28. }

运行后,程序只输出了一个flag = true,然后就死循环卡住了,不会输出:flag为true!原因是:

我们在子线程中修改了flag的值,但是主线程并不知道这个更改,使用的依旧是之前的旧值,所以会一直死循环。

而只要我们为flag添加volatile修饰,程序就能正常结束了:

除此之外为if(test.ifFlag())加上synchronized锁也可以解决可见性问题~

线程在进入synchronized代码块前后,会获得锁,清空工作内存,从主内存拷贝共享变量最新的值到工作内存称为副本,执行代码,将修改后的副本的值刷回主内存中,最后线程释放锁。

最后一点,volatile无法保证原子性(一次操作,要么完全成功,要么完全失败),比如下面的代码示例:

  1. public class VolatileTest {
  2. public static volatile int count = 0;
  3. public static void increase() {
  4. count++;
  5. }
  6. public static void main(String[] args) {
  7. Thread[] threads = new Thread[20];
  8. for(int i = 0; i < threads.length; i++) {
  9. threads[i] = new Thread(() -> {
  10. for(int j = 0; j < 1000; j++) {
  11. increase();
  12. }
  13. });
  14. threads[i].start();
  15. }
  16. // 等待所有累加线程结束,此处>2的原因是idea执行用户代码时会创建一个监控线程Monitor
  17. // 可以调用 Thread.currentThread().getThreadGroup().list() 查看一番~
  18. while (Thread.activeCount() > 2) {
  19. Thread.yield();
  20. }
  21. System.out.println(count);
  22. }
  23. }

创建了20个线程,每个线程对变量count进行1000此自增,并发结果正常应该是20000,但实际运行过程中结果很多时候都不够20000,原因是count++这个自增操作不是院子操作。解决方法也很简单,要么加锁,要么使用原子类,如:AtomicInteger。

总结下就是:

volatile是JVM提供的一种最轻量级的同步机制,可看做轻量版的synchronized,但不保证原子性,如果是对共享变量进行多个线程的赋值而没有其他操作,那么可以用volatile来代替synchronized。

⑤ 静态内部类(懒加载,线程安全,非常推荐)

  1. public class Singleton {
  2. private Singleton() { }
  3. public static Singleton getInstance() {
  4. return SingletonHolder.INSTANCE;
  5. }
  6. private static class SingletonHolder {
  7. private static final Singleton INSTANCE = new Singleton();
  8. }
  9. }

与饿汉式类似,两者都是通过类加载机制来保证初始化instance时只有一个线程,从而避免线程安全问题。

不同之处是Singleton类被加载时,不会立即初始化,只有调用getInstance()函数时,才会装载SingletonHolder类,从而实例化instance,间接实现了懒加载。

0x3、单例的其他安全问题

上述的单例写法都是围绕着 线程安全问题 进行的,即限制了new创建对象,而Java中除了这种创建对象的方式外,还有三种 克隆、反射和序列化,下面演示下如何通过这三种方式破坏单例。

① 克隆破坏单例

clone()是Object自带函数,每个对象都有,直接调用下clone函数,就能创建一个新对象了,那不就把单例破坏了吗?

答:想太多,被克隆类要实现 Cloneable 接口,然后重写clone()函数,才能完成对象克隆,而一般我们的单例是不会实现这个接口的,所以不存在此问题。

② 反射破坏单例

以静态内部类实现的单例为例,我们通过下述代码构建了两个对象,以此破坏单例:

  1. public class ReflectTest {
  2. public static void main(String[] args) {
  3. try {
  4. Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
  5. constructor.setAccessible(true); // 禁用访问安全检查
  6. Singleton s1 = constructor.newInstance();
  7. Singleton s2 = constructor.newInstance();
  8. System.out.println(s1.equals(s2)); // 输出结果:false
  9. } catch (NoSuchMethodException | IllegalAccessException |
  10. InstantiationException | InvocationTargetException e) {
  11. e.printStackTrace();
  12. }
  13. }
  14. }

一个最简单的解决方式就是添加一个标志位,当二次调用构造函数时抛出异常,示例如下:

  1. public class Singleton {
  2. private static boolean flag = true;
  3. private Singleton() {
  4. if (flag) {
  5. flag = !flag;
  6. } else {
  7. throw new RuntimeException("有不法之徒想创建第二个实例");
  8. }
  9. }
  10. public static Singleton getInstance() {
  11. return SingletonHolder.INSTANCE;
  12. }
  13. private static class SingletonHolder {
  14. private static final Singleton INSTANCE = new Singleton();
  15. }
  16. }

此时再运行反射代码:

Tips:当然先通过反射修改你的flag,在反射调构造方法依旧是可以破坏的~

③ 序列化破坏单例

同样以静态内部类实现的单例为例,先序列化到文件,然后在反序列化恢复为Java对象:

  1. public class SingletonTest {
  2. public static void main(String[] args) {
  3. Singleton singleton1 = Singleton.getInstance();
  4. Singleton singleton2 = null;
  5. // 序列化
  6. try {
  7. ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file"));
  8. oos.writeObject(singleton1);
  9. } catch (IOException e) {
  10. e.printStackTrace();
  11. }
  12. // 反序列化
  13. try {
  14. ObjectInputStream ois = new ObjectInputStream(new FileInputStream("singleton_file"));
  15. try {
  16. singleton2 = (Singleton) ois.readObject();
  17. } catch (ClassNotFoundException e) {
  18. e.printStackTrace();
  19. }
  20. } catch (IOException e) {
  21. e.printStackTrace();
  22. }
  23. System.out.println(singleton1 == singleton2); // 输出:false
  24. }
  25. }

输出false,单例再次被破坏,接着我们来看下这个新对象是怎么创建出来的,从 readObject 跟到 readOrdinaryObject,定位到下述代码:

这就是反序列化破坏单例的原理,接着说下怎么规避,在创建新对象的代码处往下走一些:

修改后的单例类代码:

  1. import java.io.Serializable;
  2. public class Singleton implements Serializable {
  3. private Singleton() { }
  4. public static Singleton getInstance() {
  5. return SingletonHolder.INSTANCE;
  6. }
  7. private static class SingletonHolder {
  8. private static final Singleton INSTANCE = new Singleton();
  9. }
  10. private Object readResolve() {
  11. return getInstance();
  12. }
  13. }

此时再运行反序列单例时的代码,会输出:true,即同一个对象。

0x4、枚举单例(安全简单,没有懒加载,最佳实践)

上面讲解了除线程安全问题外,三种破坏单例的方式及解决方式,其实用枚举实现单例就能规避这些问题。一个简单的枚举单例代码示例如下:

  1. public enum SingletonEnum {
  2. INSTANCE;
  3. private final AtomicLong id = new AtomicLong(0);
  4. public long getId() {
  5. return id.incrementAndGet();
  6. }
  7. }
  8. // 调用
  9. SingletonEnum.INSTANCE.getId()

得益于jdk的enum语法糖,这么简单的代码就能预防这四种问题,接下来一一看下原理。

① 如何保证线程安全

直接在idea上打开生成的SingletonEnum.class文件:

好吧,没看到有用的信息,再用JDK自带反编译工具javap编译下:

可以看到继承自 Enum类,但是代码不够全,再用jad工具反编译下:

反编译后的代码如下:

  1. import java.util.concurrent.atomic.AtomicLong;
  2. public final class SingletonEnum extends Enum {
  3. public static SingletonEnum[] values() {
  4. return (SingletonEnum[]) $VALUES.clone();
  5. }
  6. public static SingletonEnum valueOf(String name) {
  7. return (SingletonEnum) Enum.valueOf(SingletonEnum, name);
  8. }
  9. private SingletonEnum(String s, int i) {
  10. super(s, i);
  11. }
  12. public long getId() {
  13. return id.incrementAndGet();
  14. }
  15. public static final SingletonEnum INSTANCE;
  16. private final AtomicLong id = new AtomicLong(0L);
  17. private static final SingletonEnum $VALUES[];
  18. static {
  19. INSTANCE = new SingletonEnum("INSTANCE", 0);
  20. $VALUES = (new SingletonEnum[]{
  21. INSTANCE
  22. });
  23. }
  24. }

可以看到INSTANCE的初始化发生在static静态代码块中,即在类加载阶段执行,保证了线程安全,但跟饿汉式一样,没有懒加载。

② 如何保证克隆安全

而防克隆则是要来到父类Enum中,直接实现了clone()函数:

调用此函数直接返回 CloneNotSupportedException 异常。

③ 如何保证反射安全

将反射部分代码中的Singleton改成SingletonEnum,接着运行下,抛出下述异常

在获取构造函数时抛出的异常,没有此构造方法,呕吼,看回jad反编译的代码:

这里使用的不是无参构造方法,而是有两个参数,改下反射代码,往getDeclaredConstructor()传入这个两个参数:

再次运行,还是报异常:

定位到 Constructor类newInstance()

反射通过newInstance()创建对象时,会检查该类是否ENUM修饰,是则抛出异常,反射失败。

④ 如何保证序列化安全

Java规范中规定:每一个枚举类型及其定义的枚举变量在JVM中都是唯一的

因此在枚举类型的序列化和反序列化上,Java做了特殊的规定:

定位到Enum类的valueOf()方法:

调用enumType(Class对象的引用)的enumConstantDirectory获取一个Map集合,集合中存放的键值对:

枚举name : 枚举示例变量

根据name即可拿到枚举实例,所以枚举单例序列化并不会重新创建新实例!

0x5、Kotlin中的单例

说完Java的单例,顺带提提Kotlin中的单例,使用一行代码即可创建安全单例:

  1. object KotlinSingleton

就是这么简短,依次点击 ToolsKotlinShow Kotlin BytecodeDecompile 反编译下:

呕吼,static静态代码块,饿汉式变种,线程安全,Android项目不考虑其他三个问题的话,可以大胆放心使用。

0x6、如何实现一个多例

单例 指的是:一个类只能创建一个对象,对应的 多例 则是:

一个类可以创建多个对象,但个数是有限的,比如只能创建5个对象。

实现方式也比较简单,通过一个Map来存储对象类型及对象间的对应关系,来控制对象的个数。示例如下:

  1. import java.util.HashMap;
  2. import java.util.Map;
  3. import java.util.Random;
  4. public class BikeServer {
  5. private final long bikeNo; // 共享单车编号
  6. private final String address; // 共享单车地址
  7. private static final int BIKE_COUNT = 5; // 单车数量
  8. private static final Map<Long, BikeServer> bikeInstances = new HashMap<>(); // 单车实例集合
  9. // 私有化构造方法
  10. private BikeServer(long bikeNo, String address) {
  11. this.bikeNo = bikeNo;
  12. this.address = address;
  13. }
  14. // 静态代码块中初始化实例
  15. static {
  16. bikeInstances.put(1L, new BikeServer(1L, "罗湖区"));
  17. bikeInstances.put(2L, new BikeServer(2L, "南山区"));
  18. bikeInstances.put(3L, new BikeServer(3L, "福田区"));
  19. bikeInstances.put(4L, new BikeServer(4L, "宝安区"));
  20. bikeInstances.put(5L, new BikeServer(5L, "龙华区"));
  21. }
  22. // 根据编号获取单车实例
  23. public static BikeServer getInstance(long bikeNo) {
  24. return bikeInstances.get(bikeNo);
  25. }
  26. // 随机获取单车实例
  27. public static BikeServer getRandomInstance() {
  28. Random r = new Random();
  29. return bikeInstances.get(r.nextInt(BIKE_COUNT) + 1L);
  30. }
  31. @Override
  32. public String toString() {
  33. return "BikeServer{" +
  34. "bikeNo=" + bikeNo +
  35. ", address='" + address + '\'' +
  36. '}';
  37. }
  38. }

调用下:

  1. public class BikeTest {
  2. public static void main(String[] args) {
  3. System.out.println(BikeServer.getInstance(2L).toString());
  4. System.out.println(BikeServer.getRandomInstance().toString());
  5. }
  6. }
  7. // 输出结果:
  8. BikeServer{bikeNo=2, address='南山区'}
  9. BikeServer{bikeNo=5, address='龙华区'}

注:本节讨论的单例都是进程内唯一,进程间不唯一,即不适用于多进程(集群)单例。

参考文献:

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注