（四）共享模型之内存

本章内容

上一章讲解的 Monitor 主要关注的是访问共享变量时，保证临界区代码的原子性
这一章我们进一步深入学习共享变量在多线程间的【可见性】问题与多条指令执行时的【有序性】问题

Java 内存模型

JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。
JMM 体现在以下几个方面：

  • 原子性：保证指令不会受到线程上下文切换的影响
  • 可见性：保证指令不会受 CPU 缓存的影响
  • 有序性：保证指令不会受 CPU 指令并行优化的影响

可见性

退不出的循环

先来看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止：

public class Test26 {static boolean run = false;public static void main(String[] args) throws InterruptedException {new Thread(() -> {while(run) {}}, "t").start();Thread.sleep(1000);run = false; // 线程t不会如预想的停下来}
}

为什么呢？分析一下：

  1. 初始状态，t 线程刚开始从主内存读取了 run 的值到工作内存

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  1. 因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  1. 1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 线程是从自己工作内存中的高速缓存中读取这个变量的值，结果永远是旧值

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

解决方法

volatile（易变关键字）
它可以用来修饰成员变量和静态成员变量，可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存

可见性 vs 原子性

前面的例子体现的实际就是可见性，它保证的是在多个线程之间，一个线程对 volatile 变量的修改对另一个线程可见，不能保证原子性，仅用在一个写线程，多个读线程的情况：上例从字节码理解是这样的：

getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
putstatic run // 线程 main 修改 run 为 false， 仅此一次
getstatic run // 线程 t 获取 run false

比较一下之前我们讲线程安全时举的例子：两个线程一个 i++ 一个 i–，只能保证看到最新值，不能解决指令交错

// 假设i的初始值为0 
getstatic i // 线程2-获取静态变量i的值 线程内i=0 getstatic i // 线程1-获取静态变量i的值 线程内i=0 
iconst_1 // 线程1-准备常量1 
iadd // 线程1-自增 线程内i=1 
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1 iconst_1 // 线程2-准备常量1 
isub // 线程2-自减 线程内i=-1 
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1

注意 synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是
synchronized 是属于重量级操作，性能相对更低

两阶段终止模式

利用停止标记

// 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
// 我们的例子中，即主线程把它修改为 true 对 t1 线程可见
@Slf4j(topic = "c.TPTVolatile")
class TPTVolatile {private Thread monitorThread;private volatile boolean stop = false;public void start() {monitorThread = new Thread(() -> {while(true) {if(stop) {log.debug("料理后事");break;}try {Thread.sleep(1000);log.debug("执行监控记录");} catch (InterruptedException e) {}}}, "monitor");monitorThread.start();}public void stop() {stop = true;monitorThread.interrupt();}
}

调用

@Slf4j(topic = "c.TestTwoPhaseTermination")
public class TestTwoPhaseTermination {public static void main(String[] args) throws InterruptedException {TPTVolatile tpt = new TPTVolatile();tpt.start();Thread.sleep(3500);log.debug("停止监控");tpt.stop();}
}

执行结果
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

同步模式之 Balking

定义

Balking（犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做了，直接结束返回

实现

例如：在两阶段终止模式中，如果在主线程中多次调用 tpt.start() 方法，就会产生多个线程去做监控操作，但实际上只需要一个监控线程操作即可，此时就可以使用 Balking 模式来进行修改。

@Slf4j(topic = "c.TPTVolatile")
class TPTVolatile {private Thread monitorThread;private volatile boolean stop = false;// 判断是否执行过 start 方法private volatile boolean starting = false;public void start() {synchronized (this) { // 有多个线程同时读和写 starting，因此需要保证 starting 的原子性if(starting) { return;}starting = true;}monitorThread = new Thread(() -> {while(true) {if(stop) {log.debug("料理后事");break;}try {Thread.sleep(1000);log.debug("执行监控记录");} catch (InterruptedException e) {}}}, "monitor");monitorThread.start();}public void stop() {stop = true;monitorThread.interrupt();}
}

测试代码：

@Slf4j(topic = "c.TestTwoPhaseTermination")
public class TestTwoPhaseTermination {public static void main(String[] args) throws InterruptedException {TPTVolatile tpt = new TPTVolatile();tpt.start();tpt.start();tpt.start();Thread.sleep(3500);log.debug("停止监控");tpt.stop();}
}

测试结果：
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
它还经常用来实现线程安全的单例

public final class Singleton {private Singleton() {}private static Singleton INSTANCE = null;public static synchronized Singleton getInstance() {if (INSTANCE != null) { // Balking模式，如果 INSTANCE 已经创建，直接返回 INSTANCEreturn INSTANCE;}INSTANCE = new Singleton();return INSTANCE;}
}

对比一下保护性暂停模式：保护性暂停模式用在一个线程等待另一个线程的执行结果，当条件不满足时线程等待。

有序性

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码

static int i;
static int j;
// 在某个线程内执行如下赋值操作
i = ...; 
j = ...;

可以看到，至于是先执行 i 还是 先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行时，既可以是

i = ...; 
j = ...;

也可以是：

j = ...;
i = ...;

这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性。为什么要有重排指令这项优化呢？从 CPU 执行指令的原理来理解一下吧

指令级并行原理

名词

**Clock Cycle Time **
主频的概念大家接触的比较多，而 CPU 的 Clock Cycle Time（时钟周期时间），等于主频的倒数，意思是 CPU 能 够识别的最小时间单位，比如说 4G 主频的 CPU 的 Clock Cycle Time 就是 0.25 ns，作为对比，我们墙上挂钟的。
Cycle Time 是 1s。
例如，运行一条加法指令一般需要一个时钟周期时间
**CPI **
有的指令需要更多的时钟周期时间，所以引出了 CPI （Cycles Per Instruction）指令平均时钟周期数
**IPC **
IPC（Instruction Per Clock Cycle） 即 CPI 的倒数，表示每个时钟周期能够运行的指令数
**CPU 执行时间 **
程序的 CPU 执行时间，即我们前面提到的 user + system 时间，可以用下面的公式来表示
:::warning
程序 CPU 执行时间 = 指令数 * CPI * Clock Cycle Time
:::

鱼罐头的故事

加工一条鱼需要 50 分钟，只能一条鱼、一条鱼顺序加工…
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
可以将每个鱼罐头的加工流程细分为 5 个步骤：

  • 去鳞清洗 10分钟
  • 蒸煮沥水 10分钟
  • 加注汤料 10分钟
  • 杀菌出锅 10分钟
  • 真空封罐 10分钟

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
即使只有一个工人，最理想的情况是：他能够在 10 分钟内同时做好这 5 件事，因为对第一条鱼的真空装罐，不会影响对第二条鱼的杀菌出锅…

指令重排序优化

事实上，现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令。为什么这么做呢？可以想到指令还可以再划分成一个个更小的阶段，例如，每条指令都可以分为：取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 这 5 个阶段
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
:::info
术语参考： **
instruction fetch (IF)
instruction decode (ID)
execute (EX)
memory access (MEM)
register write back (WB)
:::
在不改变程序结果的前提下，这些指令的各个阶段可以通过重排序和组合来实现指令级并行**，这一技术在 80’s 中叶到 90’s 中叶占据了计算架构的重要地位。
:::info
**提示： **
分阶段，分工是提升效率的关键！
:::
指令重排的前提是，重排指令不能影响结果，例如

// 可以重排的例子
int a = 10; // 指令1
int b = 20; // 指令2
System.out.println( a + b );
// 不能重排的例子
int a = 10; // 指令1
int b = a - 5; // 指令2

Version:0.9 StartHTML:0000000105 EndHTML:0000004364 StartFragment:0000000141 EndFragment:0000004324

支持流水线的处理器

现代 CPU 支持多级指令流水线，例如支持同时执行取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回的处理器，就可以称之为五级指令流水线。这时 CPU 可以在一个时钟周期内，同时运行五条指令的不同阶段（相当于一条执行时间最长的复杂指令），IPC = 1，本质上，流水线技术并不能缩短单条指令的执行时间，但它变相地提高了指令地吞吐率。
:::info
**提示： **
奔腾四（Pentium 4）支持高达 35 级流水线，但由于功耗太高被废弃
:::
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

SuperScalar 处理器

大多数处理器包含多个执行单元，并不是所有计算功能都集中在一起，可以再细分为整数运算单元、浮点数运算单元等，这样可以把多条指令也可以做到并行获取、译码等，CPU 可以在一个时钟周期内，执行多于一条指令，IPC > 1
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

诡异的结果

int num = 0;
boolean ready = false;// 线程1 执行此方法
public void actor1(I_Result r) {if(ready) {r.r1 = num + num;} else {r.r1 = 1;}
}
// 线程2 执行此方法
public void actor2(I_Result r) { num = 2;ready = true; 
}

I_Result 是一个对象，有一个属性 r1 用来保存结果，问，可能的结果有几种？
有同学这么分析
情况1：线程1 先执行，这时 ready = false，所以进入 else 分支结果为 1
情况2：线程2 先执行 num = 2，但没来得及执行 ready = true，线程1 执行，还是进入 else 分支，结果为1
情况3：线程2 执行到 ready = true，线程1 执行，这回进入 if 分支，结果为 4（因为 num 已经执行过了）
但我告诉你，结果还有可能是 0 😁😁😁，信不信吧！
这种情况下是：线程2 执行 ready = true，切换到线程1，进入 if 分支，相加为 0，再切回线程2 执行 num = 2
相信很多人已经晕了 😵😵😵
这种现象叫做指令重排，是 JIT 编译器在运行时的一些优化，这个现象需要通过大量测试才能复现：
借助 java 并发压测工具 jcstress https://wiki.openjdk.java.net/display/CodeTools/jcstress

mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jcstress -
DarchetypeArtifactId=jcstress-java-test-archetype -DarchetypeVersion=0.5 -DgroupId=cn.itcast -
DartifactId=ordering -Dversion=1.0

创建 maven 项目，提供如下测试类

@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {int num = 0;boolean ready = false;@Actorpublic void actor1(I_Result r) {if(ready) {r.r1 = num + num;} else {r.r1 = 1;}}@Actorpublic void actor2(I_Result r) {num = 2;ready = true;}
}

执行

mvn clean install 
java -jar target/jcstress.jar

会输出我们感兴趣的结果，摘录其中一次结果：
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
可以看到，出现结果为 0 的情况有 638 次，虽然次数相对很少，但毕竟是出现了。

解决方法

volatile 修饰的变量，可以禁用指令重排

@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {int num = 0;volatile boolean ready = false;@Actorpublic void actor1(I_Result r) {if(ready) {r.r1 = num + num;} else {r.r1 = 1;}}@Actorpublic void actor2(I_Result r) {num = 2;ready = true;}
}

结果为：
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

volatile 原理

内存屏障

Memory Barrier（Memory Fence）

  • 可见性
    • 写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中
    • 而读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据
  • 有序性
    • 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
    • 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

原理

volatile 的底层实现原理是内存屏障，Memory Barrier（Memory Fence）

  • 对 volatile 变量的写指令后会加入写屏障
  • 对 volatile 变量的读指令前会加入读屏障

如何保证可见性

  • 写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中。
public void actor2(I_Result r) {num = 2;ready = true; // ready 是 volatile 赋值带写屏障// 写屏障（在对 ready 写之后加入写屏障）
}
  • 而读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据
public void actor1(I_Result r) {// 读屏障// ready 是 volatile 读取值带读屏障if(ready) { // 在读取 ready 之前增加读屏障r.r1 = num + num;} else {r.r1 = 1;}
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

如何保证有序性

  • 写屏障会确保指令重排序时，不会讲写屏障之前的代码排在写屏障之后
public void actor2(I_Result r) {num = 2;ready = true; // ready 是 volatile 赋值带写屏障// 写屏障（在对 ready 写之后加入写屏障）
}
  • 读屏障会确保指令重排序时，不会讲读屏障之后的代码排在读屏障之前
public void actor1(I_Result r) {// 读屏障// ready 是 volatile 读取值带读屏障if(ready) { // 在读取 ready 之前增加读屏障r.r1 = num + num;} else {r.r1 = 1;}
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
还是那句话，不能解决指令交错：

  • 写屏障仅仅是保证之后的读能够读到最新的结果，但不能保证读跑到它前面去
  • 而有序性的保证也只是保证了本线程内相关代码不被重排序

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

double-checked locking 问题

以著名的 double-checked locking 单例模式为例

public final class Singleton {private Singleton() { }private static Singleton INSTANCE = null;public static Singleton getInstance() { if(INSTANCE == null) { // t2// 首次访问会同步，而之后的使用没有 synchronizedsynchronized(Singleton.class) {if (INSTANCE == null) { // t1INSTANCE = new Singleton();}	 }}return INSTANCE;}
}

以上的实现特点是：

  • 懒惰实例化
  • 首次使用 getInstance() 才使用 synchronized 加锁，后续使用时无需加锁
  • 有隐含的，很关键的一点：第一个 if 使用了 INSTANCE 变量，是在同步块之外

但在多线程环境下，上面的代码是有问题的，getInstance 方法对应的字节码为：

0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
6: ldc #3 // class cn/itcast/n5/Singleton
8: dup
9: astore_0
10: monitorenter
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27
17: new #3 // class cn/itcast/n5/Singleton
20: dup
21: invokespecial #4 // Method "<init>":()V
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
27: aload_0
28: monitorexit
29: goto 37
32: astore_1
33: aload_0
34: monitorexit
35: aload_1
36: athrow
37: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
40: areturn

其中：

  • 17 表示创建对象，讲对象引用入栈 // new Singleton()
  • 20 表示复制一份对象引用 // 引用地址
  • 21 表示利用一个对象引用，调用构造方法
  • 24 表示利用一个对象引用，赋值给 static INSTANCE

也许 JVM 会优化为：先执行 24，再执行 21（即先将引用赋值给 INSTANCE，再完成对象的初始化）。如果两个线程 t1、t2 按如下时间序列执行：
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
即线程 t1 的执行步骤为 new-dup-putstatic-invokespecial，但是在执行完putstatic（赋值给 static INSTANCE)，线程 t1 的时间片用完，此时线程 t2 开始执行，首先去getstatic，发现 INSTANCE 不为空，于是直接返回，但是此时 t1 还未执行invokespecial命令，即 INSTANCE 尚未完成初始化。

关键在于 0：getstatic 这行代码在 monitor 控制之外，它就像之前举例中不守规则的人，可以越过 monitor 读取 INSTANCE 变量的值。这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的将是一个未初始化完毕的单例。
对 INSTANCE 使用 volatile 修饰即可禁用指令重排，但要注意在 JDK1.5 以上的版本 volatile 才会真正有效。

double-checked locking 解决

public final class Singleton {private Singleton() { }private volatile static Singleton INSTANCE = null;public static Singleton getInstance() { // 实例没创建，才会进入内部的 synchronized代码块if(INSTANCE == null) { // t2// 首次访问会同步，而之后的使用没有 synchronizedsynchronized(Singleton.class) {if (INSTANCE == null) { // t1INSTANCE = new Singleton();}	 }}return INSTANCE;}
}

字节码上看不出来 volatile 指令的效果

// -------------------------------------> 加入对 INSTANCE 变量的读屏障
0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
6: ldc #3 // class cn/itcast/n5/Singleton
8: dup
9: astore_0
10: monitorenter -----------------------> 保证原子性、可见性
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27
17: new #3 // class cn/itcast/n5/Singleton
20: dup
21: invokespecial #4 // Method "<init>":()V
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
// -------------------------------------> 加入对 INSTANCE 变量的写屏障
27: aload_0
28: monitorexit ------------------------> 保证原子性、可见性
29: goto 37
32: astore_1
33: aload_0
34: monitorexit
35: aload_1
36: athrow
37: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
40: areturn

如上面的注释内容所示，读写 volatile 变量时会加入内存屏障（Memory Barrier（Memory Fence）），保证下面两点：

  • 可见性
    • 写屏障（sfence）保证在该屏障之前的 t1 对共享变量的改动，都同步到主存当中
    • 而读屏障（lfence）保证在该屏障之后 t2 对共享变量的读取，加载的是主存中最新数据
  • 有序性
    • 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
    • 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前
  • 更底层是读写变量时使用 lock 指令来多核 CPU 之间的可见性与有序性

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

happens-before

happens-before 规定了对共享变量的写操作对其他线程的读操作可见，它是可见性与有序性的一套规则总结，抛开以下 happens-before 规则，JMM 并不能保证一个线程对共享变量的写，对于其他线程对该共享变量的读可见。

  • 线程解锁 m 之前对变量的写，对于接下来对 m 加锁的其他线程对该变量的读可见
static int x;
static Object m = new Object();new Thread(()->{synchronized(m) {x = 10;}
},"t1").start();new Thread(()->{synchronized(m) {System.out.println(x);}
},"t2").start();
  • 线程对 volatile 变量的写，对接下来其他线程对该变量的读可见
volatile static int x;new Thread(() -> {x = 10;
}, "t1").start();new Thread(() -> {System.out.println(x);
}, "t2").start();
  • 线程 start 前对变量的写，对该线程开始后对该变量的读可见
static int x;x = 10;new Thread(()->{System.out.println(x);
},"t2").start();
  • 线程结束前对变量的写，对其它线程得知它结束后的读可见（比如其它线程调用 t1.isAlive() 或 t1.join()等待它结束）
static int x; Thread t1 = new Thread(()->{ x = 10; 
},"t1"); 
t1.start();t1.join();  // 等待 t1 线程执行结束
System.out.println(x);
  • 线程 t1 打断 t2（interrupt）前对变量的写，对于其他线程得知 t2 被打断后对变量的读可见（通过t2.interrupted 或 t2.isInterrupted）
static int x;public static void main(String[] args) {Thread t2 = new Thread(()->{while(true) {if(Thread.currentThread().isInterrupted()) {System.out.println(x);break;}}},"t2");t2.start();new Thread(()->{sleep(1);x = 10;t2.interrupt();},"t1").start();while(!t2.isInterrupted()) {Thread.yield();}System.out.println(x);
}
  • 对变量默认值（0，false，null）的写，对其它线程对该变量的读可见
  • 具有传递性，如果 x hb-> y 并且 y hb-> z 那么有 x hb-> z ，配合 volatile 的防指令重排，有下面的例子
volatile static int x;
static int y;new Thread(()->{ y = 10;x = 20;
},"t1").start();new Thread(()->{// x=20 对 t2 可见, 同时 y=10 也对 t2 可见System.out.println(x); 
},"t2").start();

线程安全单例

单例模式有很多实现方法，饿汉、懒汉、静态内部类、枚举类，试分析每种实现下获取单例对象（即调用
getInstance）时的线程安全，并思考注释中的问题

  • 饿汉式：类加载就会导致该单实例对象被创建
  • 懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

实现1

// 问题1：为什么加 final
// 问题2：如果实现了序列化接口, 还要做什么来防止反序列化破坏单例
public final class Singleton implements Serializable {// 问题3：为什么设置为私有? 是否能防止反射创建新的实例?private Singleton() {}// 问题4：这样初始化是否能保证单例对象创建时的线程安全?private static final Singleton INSTANCE = new Singleton();// 问题5：为什么提供静态方法而不是直接将 INSTANCE 设置为 public, 说出你知道的理由public static Singleton getInstance() {return INSTANCE;}public Object readResolve() {return INSTANCE;}
}

问题1：为什么加 final？
final 修饰的类是不允许有子类继承的，这样就可以避免父类中的单例被子类所破坏
问题2：如果实现了序列化接口, 还要做什么来防止反序列化破坏单例
如果实现了序列化接口，那么在进行反序列化的过程中就会生成新的对象，新生成的对象与单例所维护的对象并不是同一个对象，这就相当于破坏了单例。解决方法就是类中添加一个返回值类型为 Object 的方法，其方法名固定为 readResolve，并在该方法中直接返回单例对象即可。
问题3：为什么设置为私有? 是否能防止反射创建新的实例?
如果设置为其他类型的访问权限，那么就可以无限的创建该类的实例对象了，破坏了单例。
设置为私有并不能防止反射创建新的实例。通过反射，可以得到该类的 constructor 构造器对象，然后可以设置构造器对象的 setAccessible 属性为 true，这样就可以暴力反射去调用构造方法来创建新的实例。
问题4：这样初始化是否能保证单例对象创建时的线程安全?
可以保证线程安全。静态成员变量的初始化操作是在类加载阶段完成的，类加载阶段是由 JVM 来保证这些 代码的线程安全性的。因此，类加载阶段的静态成员变量的赋值操作都是线程安全的。
问题5：为什么提供静态方法而不是直接将 INSTANCE 设置为 public, 说出你知道的理由

  • 使用方法可以提供更好的封装性，可以在内部实现一些懒惰的初始化。
  • 还可以对创建的单例对象有更多的控制，可以提供一些泛型的支持。

实现2

// 问题1：枚举单例是如何限制实例个数的
// 问题2：枚举单例在创建时是否有并发问题
// 问题3：枚举单例能否被反射破坏单例
// 问题4：枚举单例能否被反序列化破坏单例
// 问题5：枚举单例属于懒汉式还是饿汉式
// 问题6：枚举单例如果希望加入一些单例创建时的初始化逻辑该如何做
enum Singleton { INSTANCE; 
}

问题1：枚举单例是如何限制实例个数的
枚举里定义的枚举对象，在定义时有几个，那么将来就会生成几个对象。枚举对象相当于是枚举类的静态成员变量，是单实例的
问题2：枚举单例在创建时是否有并发问题
没有，因为枚举单例相当于是枚举类的静态成员变量，它的线程安全性也是在类加载阶段完成的，在类加载阶段是不会有多线程的并发问题
问题3：枚举单例能否被反射破坏单例
不能
问题4：枚举单例能否被反序列化破坏单例
枚举类都是默认实现了序列化接口的，但是枚举类在实现的时候，考虑到了反序列化会破坏枚举类的单例问题，所以枚举类可以避免反序列化破坏单例
问题5：枚举单例属于懒汉式还是饿汉式
饿汉式。静态成员变量在类加载的时候就完成了初始化，即枚举单例在类加载的时候就被创建了，所以是饿汉式。
问题6：枚举单例如果希望加入一些单例创建时的初始化逻辑该如何做
直接在枚举类中添加构造方法即可。枚举类中也可以写构造方法、普通方法、成员方法等，所以可以在枚举类中写一些构造方法，将一些初始化逻辑添加在构造方法中。

实现3

public final class Singleton {private Singleton() { }private static Singleton INSTANCE = null;// 分析这里的线程安全, 并说明有什么缺点public static synchronized Singleton getInstance() {if( INSTANCE != null ){return INSTANCE;} INSTANCE = new Singleton();return INSTANCE;}
}

分析这里的线程安全, 并说明有什么缺点？
锁的范围有些大。第一次调用时会加锁，但当对象创建好后，其他线程的再次调用依然要加锁。每次调用都要加锁，就导致性能比较低。

DCL

public final class Singleton {private Singleton() { }// 问题1：解释为什么要加 volatile ?private static volatile Singleton INSTANCE = null;// 问题2：对比实现3, 说出这样做的意义 public static Singleton getInstance() {if (INSTANCE != null) { return INSTANCE;}synchronized (Singleton.class) { // 问题3：为什么还要在这里加为空判断, 之前不是判断过了吗if (INSTANCE != null) { // t2 return INSTANCE;}INSTANCE = new Singleton(); return INSTANCE;} }
}

问题1：解释为什么要加 volatile ?
synchronized 代码块中的逻辑是会发生指令重排序的，即构造方法的指令与赋值指令有可能会被重排序。例如，第二个线程如果在进入 synchronized 代码块之前去获取对象的引用，有可能是这样做的：线程 1 在执行 synchronized 代码块中的 INSTANCE = new Singleton(); 时，先完成了对象引用的赋值操作，再去调构造方法 。那么在 synchronized 代码块之外的第二个线程，拿到的就是尚未执行构造方法的对象引用，导致线程 2 拿到一个不完整的对象。因此要保证指令不发生指令重排序。
问题2：对比实现3, 说出这样做的意义
减小了锁的范围。第一次调用 getInstance 时，由于 INSTANCE 为 null，就会执行 synchronized 代码块，完成实例的创建，当第二次、第三次去调用 getInstance，由于此时 INSTANCE 已经创建，就会直接返回，不再执行synchronized 代码块，性能上会比 3 优越些。
问题3：为什么还要在这里加为空判断, 之前不是判断过了吗
为了防止首次创建单例时，多个线程发生并发问题。假设线程 1 执行 getInstance 方法时，发现 INSTANCE 为 null，此时线程 1 获得锁，就会去执行 synchronized 代码块中的逻辑。假设当线程 1 执行到 synchronized 代码块中的if (INSTANCE != null)逻辑时，线程 2 也调用了 getInstance 方法，也判断 if (INSTANCE != null)成立，尝试获取锁，但此时锁由线程 1 持有，于是线程 2 阻塞。线程 1 则会继续执行创建实例的逻辑。线程 1 创建完成后，将锁释放，线程 2 获得锁，执行synchronized 代码块中的if (INSTANCE != null)逻辑时，发现不成立，便会直接返回。

实现5

public final class Singleton {private Singleton() { }// 问题1：属于懒汉式还是饿汉式private static class LazyHolder {static final Singleton INSTANCE = new Singleton();}// 问题2：在创建时是否有并发问题public static Singleton getInstance() {return LazyHolder.INSTANCE;}
}

问题1：属于懒汉式还是饿汉式
懒汉式。类的加载是懒惰的，只有在第一次用到的时候，才会触发某个类的加载操作。如果我们只是使用外部的 Singleton 类，没有调用 getInstance 方法的话，并不会触发静态内部类 LazyHolder 的加载 ，既然类没有被加载，那么其内部的静态变量也就没有进行初始化操作。
问题2：在创建时是否有并发问题
不会。静态变量的初始化发生在类加载阶段，在类加载阶段是不会有多线程的并发问题

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/pingmian/41073.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

firewalld(3)zone配置

firewalld(3)zone配置

简介 前面文章我们已经介绍了firewalld的安装&#xff0c;配置文件介绍、简单的规则查询&#xff0c;本篇文章主要介绍zone的配置。前面我们介绍了firewalld默认的zone和不同zone的功能&#xff0c;下面我们就直接进入zone的具体配置使用。 配置zone的方式 图形配置工具…
阅读更多...
浅析基于量子成像的下一代甚高灵敏度图像传感器技术

浅析基于量子成像的下一代甚高灵敏度图像传感器技术

高灵敏度探测成像是空间遥感应用中的一个重要技术领域&#xff0c;如全天时对地观测、空间暗弱目标跟踪识别等应用&#xff0c;对于甚高灵敏度图像传感器的需求日益强烈。随着固态图像传感器技术水平的不断提高&#xff0c;尤其背照式及埋沟道等工艺的突破&#xff0c;使得固态…
阅读更多...
马拉松报名小程序的设计

马拉松报名小程序的设计

管理员账户功能包括&#xff1a;系统首页&#xff0c;个人中心&#xff0c;用户管理&#xff0c;赛事信息管理&#xff0c;赛事报名管理&#xff0c;活动商城管理&#xff0c;留言板管理&#xff0c;系统管理 微信端账号功能包括&#xff1a;系统首页&#xff0c;赛事信息&…
阅读更多...
手动访问mongo和ES插入和查询

手动访问mongo和ES插入和查询

1、手动访问mongo 1.1、mongo连接数据库 1.2、mongo插入和查询 db.hmf_test.insert( { "aoeId": "1", "aoeAes": "吴秀梅", "aoeSm4": "北京xx网络技术有限公司.", "aoeSm4_a": "…
阅读更多...
2pc 3pc

2pc 3pc

2pc&3pc问题 本质&#xff1a; 2pcTM超时机制 3pc加入事务询问机制RM超时机制 事务询问机制&#xff1a;减少阻塞 RM超时机制&#xff1a;避免死锁 2pc 3pc 参考&#xff1a; https://juejin.im/post/5aa3c7736fb9a028bb189bca#heading-1 https://blog.csdn.net/xj1…
阅读更多...
Spring Boot 文件上传和下载指南：从基础到进阶

Spring Boot 文件上传和下载指南：从基础到进阶

文章目录 引言1. 环境配置2. 文件上传2.1 配置文件上传路径2.2 创建上传服务2.3 创建上传控制器 3. 文件下载3.1 创建下载服务3.2 创建下载控制器 4. 前端页面4.1 文件上传页面4.2 文件下载页面 5. 技术分析结论 &#x1f389;欢迎来到SpringBoot框架学习专栏~ ☆* o(≧▽≦)o …
阅读更多...
iOS多target时怎么对InfoPlist进行国际化

iOS多target时怎么对InfoPlist进行国际化

由于不同target要显示不同的App名称、不同的权限提示语&#xff0c;国际化InfoPlist文件必须创建名称为InfoPlist.strings的文件&#xff0c;那么多个target时怎么进行国际化呢&#xff1f;步骤如下&#xff1a; 一、首先我们在项目根目录创建不同的文件夹对应多个不同的targe…
阅读更多...
1-2 什么是自然语言处理

1-2 什么是自然语言处理

1-2 什么是自然语言处理 主目录点这里 自然语言处理是计算机学科、人工智能与语言学领域的一个交叉学科&#xff0c;主要研究如何让计算机能够理解、处理、生成和模拟人类语言的能力&#xff0c;从而实现与人类进行自然语言对话的能力。 如上图&#xff0c;你好通过自然语言处…
阅读更多...
笔记：SpringBoot+Vue全栈开发

笔记：SpringBoot+Vue全栈开发

笔记&#xff1a;SpringBootVue全栈开发 1. 开发环境热部署2. SpringBoot RestController的使用3. SpringBoot实现文件上传4. 配置拦截器5. Restful服务Swagger6. 使用MyBatis-Plus进行数据库操作7. 多表查询、条件查询及分页查询 1. 开发环境热部署 使用spring-boot-devtools…
阅读更多...
opencv第一课-cnblog

opencv第一课-cnblog

opencv第一课 创建窗口 import timeimport cv2 #创建窗口 cv2.namedWindow(window,cv2.WINDOW_NORMAL)#cv2.WINDOW_AUTOSIZE自动大小&#xff0c;不允许修改窗口大小#更改窗口的大小 cv2.resizeWindow(window,800,600)#展示名字为window的窗口 cv2.imshow(window,0)key cv2.w…
阅读更多...
vue中如何使用echarts和echarts-gl实现三维折线图和三维柱状图

vue中如何使用echarts和echarts-gl实现三维折线图和三维柱状图

一、vue中使用三维折线图 效果图&#xff1a; 二、使用步骤 1.引入库 安装echarts 在package.json文件中添加 "dependencies": {"echarts": "^5.1.2""echarts-gl": "^1.1.1",// "echarts-gl": "^2.0.8…
阅读更多...
『古籍自有答案』古风H5案例赏析

『古籍自有答案』古风H5案例赏析

「古籍自有答案」&#xff0c;一部由新京报与字节跳动公益联合打造的古风H5&#xff0c;以诗意盎然的开篇引领用户穿梭于千年文脉。 part1. 创意定位 "人生有惑问先贤&#xff0c;先贤答案存古籍"&#xff0c;在这里&#xff0c;每一个灵魂的探问&#xff0c;都能在…
阅读更多...
拥抱 AGI：PieDataCS 引领云原生数据计算系统新范式

拥抱 AGI：PieDataCS 引领云原生数据计算系统新范式

自2023年后&#xff0c;人工智能技术进入了一个更为成熟和广泛应用的阶段&#xff0c;人工通用智能&#xff08;AGI&#xff09;这一概念也成为了科技界和产业界热议的焦点。本文将结合 AGI 时代背景&#xff0c;从架构设计到落地实践&#xff0c;详细介绍拓数派云原生数据计算…
阅读更多...
中职院校专业群的生成机制研究

中职院校专业群的生成机制研究

摘要&#xff1a; 随着国内产业升级转型步伐的加快和职业教育质量提升的要求&#xff0c;中等职业院校&#xff08;中职院校&#xff09;的专业群建设成为促进教育与产业深度融合、实现内涵式发展的关键。本文采用案例分析法&#xff0c;探讨中职院校专业群生成机制&#xff0c…
阅读更多...
Linux手动安装JDK1.8

Linux手动安装JDK1.8

1、下载要安装的jdk安装包文件 官网下载地址&#xff1a;https://www.oracle.com/cn/java/technologies/downloads/ 2、上传jdk安装包至要安装服务器 3、在要安装jdk位置使用命令解压安装包 安装路径: /usr/local/java 解压安装包&#xff0c;解压命令 tar -zxvf /install…
阅读更多...
前端面试项目细节重难点（十）（已工作|做分享）

前端面试项目细节重难点（十）（已工作|做分享）

面试官&#xff1a;现场出需求&#xff1a;我想让一个左侧盒子可以进行拉伸、缩小、展示或隐藏这些功能&#xff0c;你会如何实现&#xff1f; 答&#xff1a;&#xff08;1&#xff09;分析问题&#xff1a;其实&#xff0c;我听到这个问题后&#xff1a; 我的第一种想法&am…
阅读更多...
Linux关于文件的高级命令

Linux关于文件的高级命令

tree命令 tree命令用于以树状图的形式显示目录结构。它可以帮助用户快速了解目录和文件的层次关系&#xff0c;非常适合用于浏览和理解大型文件系统的结构。 基础用法 显示当前目录的树状结构&#xff1a;tree 显示指定目录的树状结构&#xff1a;tree 指定目录路径 tree命…
阅读更多...
基于FreeRTOS+STM32CubeMX+LCD1602+AD5621（SPI接口）的DAC控制输出Proteus仿真

基于FreeRTOS+STM32CubeMX+LCD1602+AD5621（SPI接口）的DAC控制输出Proteus仿真

一、仿真原理图： 二、运行效果： 三、STM32CubeMX配置： 1）、GPIO配置： 2）、freertos配置： 四、软件部分： 1）、main主函数： /* USER CODE BEGIN Header */ /** ****************************************************************************** * @file …
阅读更多...
模拟5亿年自然进化史，全新蛋白质大模型ESM3诞生！前Meta老将力作LeCun转赞

模拟5亿年自然进化史，全新蛋白质大模型ESM3诞生！前Meta老将力作LeCun转赞

模拟5亿年自然进化史&#xff0c;全新蛋白质大模型ESM3诞生&#xff01;前Meta老将力作LeCun转赞。 能抗衡AlphaFold 3的生命科学大模型终于出现了。初创公司Evolutionary Scale AI发布了他们最新的98B参数蛋白质语言模型ESM3。不仅支持序列、结构、功能的all-to-all推理&#…
阅读更多...
【动态规划】动态规划一

【动态规划】动态规划一

动态规划一 1.第 N 个泰波那契数2.面试题 08.01. 三步问题3.使用最小花费爬楼梯4.解码方法 点赞&#x1f44d;&#x1f44d;收藏&#x1f31f;&#x1f31f;关注&#x1f496;&#x1f496; 你的支持是对我最大的鼓励&#xff0c;我们一起努力吧!&#x1f603;&#x1f603; 1.…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023