04-共享模型之内存

最新推荐文章于 2024-07-05 13:24:14 发布
最新推荐文章于 2024-07-05 13:24:14 发布
阅读量52 收藏
点赞数
分类专栏： JUC 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26813531/article/details/129407819
版权

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

4.1 Java内存模型

JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。
主存： 物理内存
工作内存： 缓存 速度快

可见性：voliate synchronized关键字均可以实现
voliate 轻量 不能保证原子性即不能解决指令交错问题 适用情况：一个线程写,多线线程读。
synchronized 重量
指令重排 单线程下没问题 多线程下可能会有问题

JMM 体现在以下几个方面
原子性 - 保证指令不会受到线程上下文切换的影响
可见性 - 保证指令不会受 cpu 缓存的影响
有序性 - 保证指令不会受 cpu 指令并行优化的影响

4.2 可见性

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

public class CantStopThread {
    
    static /*volatile*/ boolean run = true;
    
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            while (run) {
                // 线程将主存的run加载到工作内存中  即后续不在读取主存的数据

            }
        });
        thread.start();

        // 主线程在一秒后 将run改为了false 但是thread却没有停止
        Sleeper.sleep(1);
        // 修改主存中的数据对线程的内存不可见
        run = false;

    }
}

为什么呢？分析一下：

  1. 初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。
  2. image.png
  3. 因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率。
  4. image.png
  5. 1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量 的值，结果永远是旧值
  6. image.png

解决方法
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 是属于重量级操作，性能相对更低

如果在前面示例的死循环中加入 System.out.println() 会发现即使不加 volatile 修饰符，线程 t 也能正确看到对 run 变量的修改了，想一想为什么？
因为println里有对当前对象加synchronized关键字

4.3 CPU缓存结构原理

  1. CPU 缓存结构

image.png
查看 cpu 缓存

lscpu

Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 1
On-line CPU(s) list: 0
Thread(s) per core: 1
Core(s) per socket: 1
Socket(s): 1
NUMA node(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 142
Model name: Intel(R) Core(TM) i7-8565U CPU @ 1.80GHz
Stepping: 11
CPU MHz: 1992.002
BogoMIPS: 3984.00
Hypervisor vendor: VMware
Virtualization type: full
L1d cache: 32K
L1i cache: 32K
L2 cache: 256K
L3 cache: 8192K
NUMA node0 CPU(s): 0

速度比较
image.png
查看 cpu 缓存行

cat /sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size

cpu 拿到的内存地址格式是这样的

[高位组标记][低位索引][偏移量]

image.png

  1. CPU 缓存读

读取数据流程如下

  • 根据低位，计算在缓存中的索引
  • 判断是否有效
    • 0 去内存读取新数据更新缓存行
    • 1 再对比高位组标记是否一致
      • 一致，根据偏移量返回缓存数据
      • 不一致，去内存读取新数据更新缓存行
  1. 缓存一致性

MESI 协议

  1. E、S、M 状态的缓存行都可以满足 CPU 的读请求
  2. E 状态的缓存行，有写请求，会将状态改为 M，这时并不触发向主存的写
  3. E 状态的缓存行，必须监听该缓存行的读操作，如果有，要变为 S 状态

image.png

  1. M 状态的缓存行，必须监听该缓存行的读操作，如果有，先将其它缓存（S 状态）中该缓存行变成 I 状态（即 6. 的流程），写入主存，自己变为 S 状态
  2. S 状态的缓存行，有写请求，走 4. 的流程
  3. S 状态的缓存行，必须监听该缓存行的失效操作，如果有，自己变为 I 状态
  4. I 状态的缓存行，有读请求，必须从主存读取

image.png

4.4 内存屏障

Memory Barrier（Memory Fence）

  • 可见性

    • 写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中
    • 读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据

  • 有序性

    • 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
    • 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前

4.5 模式之两阶段终止模式-volatile

@Slf4j(topic = "c.TestTwoPhaseTermination")
public class TestTwoPhaseTermination {

    public static void main(String[] args) {
        //TPTInterrupt t = new TPTInterrupt();
        TPTVolatile t = new TPTVolatile();
        t.start();

        Sleeper.sleep(5);
        log.debug("stop");
        t.stop();
    }

}

@Slf4j(topic = "c.TPTVolatile")
class TPTVolatile {
	
	private Thread thread;
	private volatile boolean stop = false;
	
	public void start() {
		thread = new Thread(() -> {
			while (true) {
				if (stop) {
					log.debug("料理后事");
					break;
				}
				try {
					// sleep被打断 进入catch块
					Thread.sleep(1000);
					// 这里被打断的话  不会catch块 进入下次循环判断是否被打断
					log.debug("将监控结果保存");
				} catch (InterruptedException e) {
				}
			}
		}, "监控线程");
		thread.start();
	}
	
	public void stop() {
		stop = true;
		thread.interrupt();
	}
}

4.6 同步模式之Balking

  1. 定义

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

  1. 实现
@Slf4j(topic = "c.MonitorService")
public class MonitorService {

    //表示是否已经存在运行的监视线程了
    private volatile boolean starting;

    public void start() {
        log.info("尝试启动监视线程。。。");
        synchronized (this) {
            if (starting) {
                return;
            }
            starting = true;
        }
        // 真正启动监视线程
    }

}

它还经常用来实现线程安全的单例

public final class Singleton {

    private Singleton INSTANCE = null;

    private Singleton() {
    }

    public synchronized Singleton getInstance() {
        if (INSTANCE != null) {
            return INSTANCE;
        }
        INSTANCE = new Singleton();
        return INSTANCE;
    }

}

4.7 有序性

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

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

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

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

也可以是

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

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

4.7.1 原理之指令级并行

4.7.1.1 名词

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 时间，可以用下面的公式来表示

程序 CPU 执行时间 = 指令数 * CPI * Clock Cycle Time

4.7.1.2 鱼罐头的故事

加工一条鱼需要 50 分钟，只能一条鱼、一条鱼顺序加工…
image.png
可以将每个鱼罐头的加工流程细分为 5 个步骤：

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

image.png
即使只有一个工人，最理想的情况是：他能够在 10 分钟内同时做好这 5 件事，因为对第一条鱼的真空装罐，不会影响对第二条鱼的杀菌出锅…

4.7.1.3 指令重排序优化

事实上，现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令。为什么这么做呢？可以想到指令
还可以再划分成一个个更小的阶段，例如，每条指令都可以分为： 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 这 5 个阶段
image.png
在不改变程序结果的前提下，这些指令的各个阶段可以通过重排序和组合来实现指令级并行，这一技术在 80’s 中叶到 90’s 中叶占据了计算架构的重要地位。

分阶段，分工是提升效率的关键！

指令重排的前提是，重排指令不能影响结果，例如

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

4.7.1.4 支持流水线的处理器

现代 CPU 支持多级指令流水线，例如支持同时执行 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 的处理
器，就可以称之为五级指令流水线。这时 CPU 可以在一个时钟周期内，同时运行五条指令的不同阶段（相当于一
条执行时间最长的复杂指令），IPC = 1，本质上，流水线技术并不能缩短单条指令的执行时间，但它变相地提高了指令地吞吐率。
image.png

4.7.1.5 SuperScalar 处理器

大多数处理器包含多个执行单元，并不是所有计算功能都集中在一起，可以再细分为整数运算单元、浮点数运算单元等，这样可以把多条指令也可以做到并行获取、译码等，CPU 可以在一个时钟周期内，执行多于一条指令，IPC > 1
image.png
image.png

4.8 诡异的结果

public class VisibilityTest {

    private int a = 0;
    private boolean flag = false;
	
	// 线程1 执行此方法
    public void method1(I_Result result) {
        if (flag) {
            result.r1 = a * 2;
        } else {
            result.r1 = 1;
        }
    }

	// 线程2 执行此方法
    public void method2(I_Result result) {
        a = 2;
        flag = true;
    }
}

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

/**
 * @author zhoujunlin
 * @date 2022年06月07日 11:08
 * @desc 执行方式
 * idea中配置 启动类Main Class: org.openjdk.jcstress.Main  固定不变
 * Program arguments: -t VisibilityTest (你的类名) -v
 */
@JCStressTest
@State
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "期待的结果")
@Outcome(id = {"0"}, expect = Expect.ACCEPTABLE_INTERESTING, desc = "令人惊讶的结果")
public class VisibilityTest {

    private int a = 0;
    private boolean flag = false;

    @Actor
    public void method1(I_Result result) {
        if (flag) {
            result.r1 = a * 2;
        } else {
            result.r1 = 1;
        }
    }

    @Actor
    public void method2(I_Result result) {
        // 这个方法里 两个语句可能会发生指令重排 jit
        a = 2;
        flag = true;
    }
}

执行结果如下：

  Results across all configurations:

  RESULT      SAMPLES     FREQ       EXPECT  DESCRIPTION
       0       56,026    0.02%  Interesting  令人惊讶的结果
       1   41,833,488   13.63%   Acceptable  期待的结果
       4  264,980,758   86.35%   Acceptable  期待的结果

给flag变量添加volatile,执行结果如下：

  RESULT      SAMPLES     FREQ       EXPECT  DESCRIPTION
       0            0    0.00%  Interesting  令人惊讶的结果
       1  200,288,492   70.84%   Acceptable  期待的结果
       4   82,435,860   29.16%   Acceptable  期待的结果

4.9 原理之volatile

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

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

4.9.1 如何保证可见性

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

image.png

4.9.2 如何保证有序性

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

image.png
还是那句话，不能解决指令交错：

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

image.png

4.9.3 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
			// 首次访问会同步，而之后的使用没有 synchronized
			synchronized(Singleton.class) {
				if (INSTANCE == null) { // t1
					INSTANCE = 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。如果两个线程 t1，t2 按如下时间序列执行：
image.png
关键在于 0: getstatic 这行代码在 monitor 控制之外，它就像之前举例中不守规则的人，可以越过 monitor 读取
INSTANCE 变量的值。
这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的是将是一个未初始化完毕的单例。
对 INSTANCE 使用 volatile 修饰即可，可以禁用指令重排，但要注意在 JDK 5 以上的版本的 volatile 才会真正有效。

4.9.4 double-checked locking 解决

public final class Singleton {
	private Singleton() { }
	private static volatile Singleton INSTANCE = null;
	public static Singleton getInstance() {
		// 实例没创建，才会进入内部的 synchronized代码块
		if (INSTANCE == null) { 
			synchronized (Singleton.class) { // t2
				// 也许有其它线程已经创建实例，所以再判断一次
				if (INSTANCE == null) { // t1
					INSTANCE = 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 对共享变量的读取，加载的是主存中最新数据
有序性
写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前
image.png

4.9.5 final原理

理解了 volatile 原理，再对比 fifinal 的实现就比较简单了

public class TestFinal {
    final int a = 20; 
}

字节码

0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: bipush 20
7: putfield #2 // Field a:I
 <-- 写屏障
10: return

发现 final 变量的赋值也会通过 putfifield 指令来完成，同样在这条指令之后也会加入写屏障，保证在其它线程读到它的值时不会出现为 0 的情况

4.10 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();
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）的写，对其它线程对该变量的读可见
  • 具有传递性
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();

4.11 balking与单例模式

public class Initialize {

    private volatile boolean initialized = false;

    public void init() {
        if (initialized) {
            return;
        }
        doInit();
        initialized = true;
    }

    private void doInit() {
        Sleeper.sleep(30);
    }

}

// 虽然volatile保证了可见性 但是没有并不能保证线程安全 即doInit可能会执行多次

public class Initialize {

    private boolean initialized = false;

    public synchronized void init() {
        if (initialized) {
            return;
        }
        doInit();
        initialized = true;
    }

    private void doInit() {
        Sleeper.sleep(30);
    }

}

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

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

// 问题1：为什么加 final  防止继承 方法的重写破坏
// 问题2：如果实现了序列化接口, 还要做什么来防止反序列化破坏单例 
// 实现readResolve可以解决反序列化永远只有一个
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：枚举单例是如何限制实例个数的  创建几个枚举就是几个
// 问题2：枚举单例在创建时是否有并发问题  没有
// 问题3：枚举单例能否被反射破坏单例      可以 
// 问题4：枚举单例能否被反序列化破坏单例  不能
// 问题5：枚举单例属于懒汉式还是饿汉式    饿汉  就是几个成员变量...
// 问题6：枚举单例如果希望加入一些单例创建时的初始化逻辑该如何做   枚举的构造方法..
enum Singleton { 
 INSTANCE; 
}

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;
	}
}

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;
		} 
	}
}

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;
	}
}
层巅余落日
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
共享内存编程模型.ppt
05-03
共享内存编程模型.ppt
浅谈Java内存模型之happens-before
08-26
"浅谈Java内存模型之happens-before" Java内存模型是Java虚拟机中的一种机制，用于定义Java程序中线程之间的内存访问方式。在多线程环境下，线程之间的通信和数据共享是非常复杂的，需要有一些规则来保证数据的一致...
JUC-内存
诗和远方，代码和你
07-21 211
该缓存行只被缓存在该CPU的缓存中，并且是被修改过的，与主存中的数据不一致(dirty)，该缓存行中的内存需要在未来的某个时间点（其它CPU读取主存中相应数据之前）写回(writeback)主存。CPU处理器速度远远大于在主内存中的，为了解决速度差异，在它们之间架设了多级缓存，如L1、L2、L3级别的缓存，这些缓存离CPU越近就越快，将频繁操作的数据缓存到这里，加快访问速度。，线程对所有变量的操作都是先对变量进行拷贝，然后在工作内存中进行，不能直接操作主内存中的变量；...
对缓存的思考——提高命中率
weixin_30858241的博客
02-14 445
开篇 编写高效的程序并不只在于算法的精巧，还应该考虑到计算机内部的组织结构，cpu微指令的执行，缓存的组织和工作原理等。 好的算法在实际中不见得有高效率，如果完全没有考虑缓存、微指令实现的话。 前两篇博文 局部性原理浅析介绍了程序的局部性原理，如何写出局部性良好代码。 提高程序性能、何为缓存讨论了存储器层次结构，计算机内部的存储结构、缓存的概念，简单的介绍了缓存的工作机制。 建议先...
【并发编程】- 源码篇
suchahaerkang的博客
05-15 487
文章目录指令级并行原理1. 名词2. 鱼罐头的故事3. 指令重排序优化4. 支持流水线的处理器5. SuperScalar 处理器CPU 缓存结构原理1. CPU 缓存结构2. CPU 缓存读3. CPU 缓存一致性4. 内存屏障volatile 原理1. 如何保证可见性2. 如何保证有序性3. double-checked locking 问题 指令级并行原理 1. 名词 Clock Cycle Time 主频的概念大家接触的比较多，而 CPU 的 Clock Cycle Time（时钟周期时间），等于
37 | 高速缓存（上）：“4 毫秒” 究竟值多少钱？
qyf__123的博客
09-06 560
37 | 高速缓存（上）：“4 毫秒” 究竟值多少钱？ 在这一节内容开始之前，我们先来看一个 3 行的小程序。你可以猜一猜，这个程序里的循环 1 和循环 2，运行所花费的时间会差多少？你可以先思考几分钟，然后再看我下面的解释。 int[] arr = new int[64 * 1024 * 1024]; // 循环 1 for (int i = 0; i < arr.length; ...
《JUC并发编程 - 高级篇》04 -共享模型之内存 （Java内存模型 | 可见性 | 有序性 ）
LXYDSF的博客
07-15 1120
《JUC并发编程 - 高级篇》04 -共享模型之内存 （Java内存模型 | 可见性 | 有序性 ）
商业编程-源码-共享内存封装类.zip
06-23
- **共享内存模型**：共享内存是进程间通信（IPC）的一种方式，不同进程通过映射到同一块物理内存区域实现数据交换。 - **优点**：高速、直接访问，无需复制数据，特别适合大量数据传输。 - **挑战**：同步和互斥...
06-02-FFmpeg内存模型1
08-04
在FFmpeg内存模型中，有两种不同的数据共享情况： 1. **数据共享**：当两个`AVPacket`的`buf`成员引用相同的内存空间时，它们共享同一数据缓存。这种情况下，需要注意的是，当一个`AVPacket`被释放时，不能直接释放...
浅析java内存模型--JMM(JavaMemoryModel)
02-24
在Java语言中，采用的是共享内存模型来实现多线程之间的信息交换和数据同步的。线程之间通过共享程序公共的状态，通过读-写内存中公共状态的方式来进行隐式的通信。同步指的是程序在控制多个线程之间执行程序的相对...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 515
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
ShardingSphere
Casual_Lei的博客
07-04 638
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 324
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
如何使用缓存提升SpringBoot性能（EhCache和Redis方式）
三两肉的博客
07-03 1034
缓存是指将文件或数据的副本存储在缓存或临时存储位置中，以便未来对该数据的请求可以更快地提供服务。当从存储中检索数据时，会在缓存中创建该数据的副本。如果再次需要该数据，可以从缓存中比从主存储器中更快地检索到该数据，主存储器可能涉及复杂的计算或较慢的访问速度。如何使用缓存提升SpringBoot性能（EhCache和Redis方式）
maven配置使用nexus仓库
ApexPredator的博客
07-03 215
maven配置使用nexus仓库
JavaSE阶段面试题（一）
tq02的博客
07-03 599
本章节主要讲述SE阶段的常见面试题
返回值处理器器【Spring源码学习】
最新发布
weixin_44794897的博客
07-05 243
定义返回值类型处理器的组合；测试使用的controller测试方法。
Java中的静态代理与动态代理详解
07-03 390
在Java中，代理模式分为静态代理和动态代理两种形式。缺点是每一个代理类只能为一个接口服务，如果接口增加方法，代理类也需要相应修改。大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！静态代理是在编译时就已经确定代理类的实现，代理类与真实类实现相同的接口或继承相同的父类。动态代理是在运行时动态生成代理类，无需手动编写代理类，可以根据需要代理任意接口。通过本文的介绍，相信大家对Java中的静态代理和动态代理有了更深入的理解和应用。
Java 汉诺塔问题 详细分析
2301_80641575的博客
07-02 278
汉诺塔问题

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

层巅余落日

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值