栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

全面深入学习Java并发编程-第六章

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

全面深入学习Java并发编程-第六章

文章目录
  • 一、java 内存模型 (JMM)
    • 1. JMM 定义
    • 2. JMM 三大特性
    • 3. JMM 关于同步的规定
    • 4. 原子性
    • 5. 可见性
    • 6. 有序性
      • (1)小故事理解指令重排序
      • (2)指令重排序优化
      • (3)指令重排序带来的问题
    • 7. 可见性 vs 原子性
  • 二、 多线程设计模式之两阶段终止模式(使用volatile)
  • 三、多线程设计模式之Balking犹豫模式(同步模式)
  • 四、volatile 原理
  • 五、双重检测单例模式(double-checked locking)
  • 六、happens-before 规则
    • 1.synchronized解锁前的写
    • 2.volatile修饰的变量的写
    • 3.start之前的写
    • 4.线程结束之前的写
    • 5.线程被打断之前的写
    • 6.对变量默认值(0,false,null)的写,对其它线程对该变量的读可见
    • 7.传递性

一、java 内存模型 (JMM) 1. JMM 定义
  • JMM(Java内存模型Java Memory Model,简称JMM)本身是一种抽象的概念并不真实存在,它描述的是一组规则或规范,通过这组规范定义了程序中各个变量(包括实例字段,静态字段和构成数组对象的元素)的访问方式。
  • JMM 定义了主存、工作内存抽象概念,底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。
    • 主存包含所有的共享变量(静态变量、成员变量);
    • 工作内存是每个线程私有的(里面包含局部变量);
  • Java可以通过关键字对底层的CPU进行控制,简化了开发人员直接管理CPU;
2. JMM 三大特性
  • 原子性 - 保证指令不会受到线程上下文切换的影响;(Monitor 主要关注的是访问共享变量时,保证临界区代码的【原子性】)
  • 可见性 - 保证指令不会受 cpu 缓存的影响;(共享变量在多线程间的【可见性】)
  • 有序性 - 保证指令不会受 cpu 指令并行优化的影响;(多条指令执行时的【有序性】)
3. JMM 关于同步的规定
  1. 线程解锁前,必须把共享变量的值刷新回主内存
  2. 线程加锁前,必须读取主内存的最新值到自己的工作内存
  3. 加锁解锁是同一把锁
  • 由于JVM运行程序的实体是线程,而每个线程创建时JVM都会为其创建一个【工作内存】(有些地方称为栈空间)
  • 【工作内存】是每个线程的私有数据区域,而 JMM 中规定所有变量都存储在【主内存】
  • 【主内存】是共享内存区域,所有线程都可以访问,但线程对变量的操作(读取赋值等)必须在【工作内存】中进行
    • 首先要将变量从【主内存】拷贝到自己的【工作内存】空间,然后对变量进行操作,操作完成后再将变量写回【主内存】,不能直接操作【主内存】中的变量
  • 各个线程中的【工作内存】中存储着【主内存】中的变量副本拷贝,因此不同的线程间无法访问对方的【工作内存】,线程间的通信(传值)必须通过【主内存】来完成

例如:多线程访问共享变量
数据传输速率:硬盘 < 内存 < < cache < CPU

4. 原子性

第四章讲解的 Monitor 主要关注的是访问共享变量时,保证临界区代码的原子性

5. 可见性

退不出的循环

  • 先来看一个现象,main 线程对 run 变量的修改对于 t 线程不可见,导致了 t 线程无法停止:
@Slf4j(topic = "c.Test32")
public class Test32 {
    static boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(true){
                if(!run) {
                	log.debug("t线程停止");
                    break;
                }
            }
        }, "t");
        t.start();

        sleep(1);
        log.debug("main线程试图让t线程停止");
        run = false; // 线程t不会如预想的停下来
    }
}

分析:

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

解决方法:

volatile(易变关键字)

  • 它可以用来修饰成员变量和静态成员变量,可以避免线程从自己的工作缓存中查找变量的值,必须到主存中获取它的值,线程操作 volatile 变量都是直接操作主内存
@Slf4j(topic = "c.Test32")
public class Test32 {

    // 加 volatile 关键字
    volatile static boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(true){
                if(!run) {
                    log.debug("t线程停止");
                    break;
                }
            }
        }, "t");
        t.start();

        sleep(1);
        log.debug("main线程试图让t线程停止");
        run = false; 
    }
}

12:47:27.812 c.Test32 [main] - main线程试图让t线程停止
12:47:27.815 c.Test32 [t] - t线程停止

synchronized 关键字

  • synchronized 语句块既可以保证代码块的原子性,也同时保证代码块内变量的可见性。但缺点是synchronized 是属于重量级操作,性能相对更低
@Slf4j(topic = "c.Test32")
public class Test32 {

    static boolean run = true;

    // 锁对象
    final static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(true){
                synchronized (lock) {
                    if(!run) {
                        log.debug("t线程停止");
                        break;
                    }
                }
            }
        }, "t");
        t.start();

        sleep(1);
        log.debug("main线程试图让t线程停止");
        synchronized (lock) {
            run = false; 
        }
    }
}
12:51:57.165 c.Test32 [main] - main线程试图让t线程停止
12:51:57.168 c.Test32 [t] - t线程停止

通过 System.out.println(); 让线程停止

  • 因为print方法内部加了synchronized关键字(当然println也加了,换行操作也会持有锁)
  • 而synchronized方法也是能保证该同步块中变量的可见性,所以下次从主存中读出false就跳出了while。
  • 这里记录一下synchronized做的操作:
  1. 获得同步锁
  2. 清空工作内存
  3. 从主内存拷贝对象副本到工作内存
  4. 执行代码(计算或者输出等)
  5. 刷新主内存数据
  6. 释放同步锁
@Slf4j(topic = "c.TestSystemOutPrint")
public class TestSystemOutPrint {
    static boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(true){
                System.out.println();
                if(!run) {
                    log.debug("t线程停止");
                    break;
                }
            }
        },"t");
        t.start();
        Thread.sleep(1000);
        run = false;
    }
}
13:03:43.928 c.TestSystemOutPrint [t] - t线程停止
6. 有序性
  • JVM 会在不影响正确性的前提下,可以调整语句的执行顺序
static int i;
static int j;
// 在某个线程内执行如下赋值操作
i = ...;
j = ...;
  • 可以看到,至于是先执行 i 还是 先执行 j ,对最终的结果不会产生影响。所以,上面代码真正执行时
  • 既可以是
i = ...;
j = ...;
  • 也可以是
j = ...;
i = ...;
  • 这种特性称之为『指令重排』,多线程下『指令重排』会影响结果正确性
(1)小故事理解指令重排序

鱼罐头的故事

加工一条鱼需要 50 分钟,只能一条鱼、一条鱼顺序加工…

可以将每个鱼罐头的加工流程细分为 5 个步骤:

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

    即使只有一个工人,最理想的情况是:他能够在 10 分钟内同时并行做好这 5 件事,因为对第一条鱼的真空装罐,不会影响对第二条鱼的杀菌出锅…
(2)指令重排序优化
  • 事实上,现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令。
  • 为什么这么做呢?可以想到指令还可以再划分成一个个更小的阶段
    例如:每条指令都可以分为: 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回,这 5 个阶段

    术语参考:
  • instruction fetch (IF)
  • instruction decode (ID)
  • execute (EX)
  • memory access (MEM)
  • register write back (WB)

在不改变程序结果的前提下,这些指令的各个阶段可以通过重排序和组合来实现指令级并行

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

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

支持流水线的处理器

  • 现代 CPU 支持多级指令流水线
  • 例如:支持同时执行 取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回 的处理器,称为五级指令流水线。
  • 这时 CPU 可以在一个时钟周期内,同时运行五条指令的不同阶段(相当于一条执行时间最长的复杂指令)
  • IPC = 1,本质上,流水线技术并不能缩短单条指令的执行时间,但它变相地提高了指令地吞吐率。
(3)指令重排序带来的问题
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 已经执行过了)
  • 情况4:线程2 执行 ready = true,切换到线程1,进入 if 分支,相加结果为 0,再切回线程2 执行 num = 2

这种现象叫做指令重排,是 JIT 编译器在运行时的一些优化

  • 这个现象需要通过大量测试才能复现:借助 java 并发压测工具jcstress(Java Concurrency Stress)
  • jmeter侧重对于接口整体的响应速度等进行测试,而JCStress框架能对某块逻辑代码进行高并发测试,更加侧重JVM,类库等领域的研究

步骤:

  • 第一步,创建一个maven项目,导入jcstress依赖


  4.0.0

  com.lwk
  jcstressTest
  1.0-SNAPSHOT
  jar

  

  
  
  

  
    
      org.openjdk.jcstress
      jcstress-core
      ${jcstress.version}
    
  

  
    UTF-8

    
    0.5

    
    1.8

    
    jcstress
  

  
    
      
        org.apache.maven.plugins
        maven-compiler-plugin
        3.1
        
          ${javac.target}
          ${javac.target}
          ${javac.target}
        
      

      
        org.apache.maven.plugins
        maven-shade-plugin
        2.2
        
          
            main
            package
            
              shade
            
            
              ${uberjar.name}
              
                
                  org.openjdk.jcstress.Main
                
                
                  META-INF/TestList
                
              
            
          
        
      
    
  




  • 第二步,创建测试类
@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;
    boolean ready = false;
    @Actor
    public void actor1(I_Result r) {
        if(ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }

    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }

}
  • 第三步,打包并执行
mvn clean install
java -jar target/jcstress.jar
  • 会输出我们感兴趣的结果,摘录其中一次结果:
RUN RESULTS:
------------------------------------------------------------------------------------------------------------------------

*** INTERESTING tests
  Some interesting behaviors observed. This is for the plain curiosity.

  2 matching test results.
      [OK] com.lwk.ConcurrencyTest
    (JVM args: [-XX:-TieredCompilation])
  Observed state   Occurrences              Expectation  Interpretation
               0         5,037   ACCEPTABLE_INTERESTING  !!!!
               1   102,809,997               ACCEPTABLE  ok
               4    29,517,627               ACCEPTABLE  ok

      [OK] com.lwk.ConcurrencyTest
    (JVM args: [])
  Observed state   Occurrences              Expectation  Interpretation
               0         1,680   ACCEPTABLE_INTERESTING  !!!!
               1    78,936,078               ACCEPTABLE  ok
               4    36,682,503               ACCEPTABLE  ok

  • 加 volatile 禁止指令重排序
volatile boolean ready = false;
  • 没有出现0的结果
RUN RESULTS:
------------------------------------------------------------------------------------------------------------------------

*** INTERESTING tests
  Some interesting behaviors observed. This is for the plain curiosity.

  0 matching test results.


7. 可见性 vs 原子性
  • 前面例子体现的是可见性,它保证的是在多个线程之间,一个线程对 volatile 变量的修改对另一个线程可见, 但 volatile 不能保证原子性,仅用在一个写线程,多个读线程的情况

上例从字节码理解是这样的:

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

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

// 假设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

二、 多线程设计模式之两阶段终止模式(使用volatile)
  • 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
@Slf4j(topic = "c.Volatile_TwoPhaseTermination")
public class Volatile_TwoPhaseTermination {

    public static void main(String[] args) throws InterruptedException {
        Volatile_TwoPhase thread = new Volatile_TwoPhase();
        log.info("开始监控");
        thread.start();
        // 休眠时打断
        Thread.sleep(1000);
        log.info("停止监控");
        thread.stop();
    }
}

@Slf4j(topic = "c.Volatile_TwoPhase")
class Volatile_TwoPhase {

    Thread monitor;
    // 打断变量用volatile修饰,可以保证多个线程实时可见该变量的值
    public volatile boolean ifStop;

    public void start() {
        monitor = new Thread(() -> {
            while (true) {
                if (ifStop) {
                    log.info("料理后事");
                    break;
                }

                try {
                    Thread.sleep(5000);
                    log.info("执行监控");
                } catch (InterruptedException e) {
                    log.info("休眠时被立即打断");
                }
            }
        },"monitor");
        monitor.start();
    }

    public void stop() {
        ifStop = true;
        // 多执行一次打断动作interrupt(),是为了让休眠时的线程立马被打断,进入下轮循环
        // 而不是等时间休眠完再进入下轮循环
        monitor.interrupt();
    }
}

13:31:35.563 c.Volatile_TwoPhaseTermination [main] - 开始监控
13:31:36.627 c.Volatile_TwoPhaseTermination [main] - 停止监控
13:31:36.627 c.Volatile_TwoPhase [monitor] - 休眠时被立即打断
13:31:36.627 c.Volatile_TwoPhase [monitor] - 料理后事

三、多线程设计模式之Balking犹豫模式(同步模式)
  • Balking(犹豫)模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事,那么本线程就无需再做了,直接结束返回。

使用Balking犹豫模式防止多次启动相同的监控线程:

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

    public static void main(String[] args) throws InterruptedException {
        Volatile_TwoPhase thread = new Volatile_TwoPhase();
        log.info("开始监控");
        // 试图多次启动监控线程
        thread.start();
        thread.start();
        thread.start();
        // 休眠时打断
        Thread.sleep(1000);
        log.info("停止监控");
        thread.stop();
    }
}

@Slf4j(topic = "c.Volatile_TwoPhase")
class Volatile_TwoPhase {

    private Thread monitor;
    // 打断变量用volatile修饰,可以保证多个线程实时可见该变量的值
    private volatile boolean ifStop;
    // 判断是否启动过监控线程,使用Balking犹豫模式防止多次启动相同的监控线程
    private boolean starting = false;

    // 启动监控线程
    public void start() {
        
        // 此处使用的就是 Balking犹豫模式
        synchronized (this) {
            if (starting) {
                return;
            }
            starting = true;
        }

        monitor = new Thread(() -> {
            while (true) {
                if (ifStop) {
                    log.info("料理后事");
                    break;
                }

                try {
                    Thread.sleep(5000);
                    log.info("执行监控");
                } catch (InterruptedException e) {
                    log.info("休眠时被立即打断");
                }
            }
        },"monitor");
        monitor.start();
    }

    public void stop() {
        ifStop = true;
        // 多执行一次打断动作interrupt(),是为了让休眠时的线程立马被打断,进入下轮循环
        // 而不是等时间休眠完再进入下轮循环
        monitor.interrupt();
    }
}
14:03:56.424 c.Volatile_TwoPhaseTermination [main] - 开始监控
14:03:57.479 c.Volatile_TwoPhaseTermination [main] - 停止监控
14:03:57.479 c.Volatile_TwoPhase [monitor] - 休眠时被立即打断
14:03:57.479 c.Volatile_TwoPhase [monitor] - 料理后事

Balking犹豫模式的应用:

  • 同步方法的懒汉式单例模式中,应用到了 多线程Balking犹豫模式思想
// 同步方法的懒汉式单例模式,多线程下保证只有唯一的实例。
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;
    }
}
四、volatile 原理

volatile 的底层实现原理是内存屏障,Memory Barrier(Memory Fence)

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

volatile 可以保证 可见性 和 有序性

  • 写屏障(sfence)保证在该屏障之前的,对共享变量的改动,都同步到主存当中(可见性),并且 会确保指令重排序时,不会将写屏障之前的代码排在写屏障之后(有序性)
public void actor2(I_Result r) {
	num = 2;
	ready = true; // ready 是 volatile 赋值带写屏障
	// 写屏障
}
  • 读屏障(lfence)保证在该屏障之后,对共享变量的读取,加载的是主存中最新数据(可见性),并且 会确保指令重排序时,不会将读屏障之后的代码排在读屏障之前(有序性)
public void actor1(I_Result r) {
	// 读屏障
	// ready 是 volatile 读取值带读屏障
	if(ready) {
		r.r1 = num + num;
	} else {
		r.r1 = 1;
	}
}


volatile 不能保证 原子性

不能解决指令交错:

  • 写屏障仅仅是保证之后的读,能够读到最新的结果,但不能保证读跑到它前面去
  • 而有序性的保证也只是保证了本线程内相关代码不被重排序
五、双重检测单例模式(double-checked locking)
public final class Singleton {
	private Singleton() { }
	private static Singleton INSTANCE = null;
	public static Singleton getInstance() {
		if(INSTANCE == null) {
			// 首次使用 getInstance() 才使用 synchronized 加锁,后续使用时无需加锁
			synchronized(Singleton.class) {
				if (INSTANCE == null) {
					INSTANCE = new Singleton();
				}
			}
		}
		return INSTANCE;
	}
}

以上的实现特点是:

  • 是懒惰实例化的单例模式
  • 首次使用 getInstance() 才使用 synchronized 加锁,后续使用时无需加锁
  • 有隐含的,但很关键的一点:第一个 if 使用了 INSTANCE 变量,是在同步块之外,会出现指令重排的有序性问题

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

0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37 // INSTANCE 不为null,则跳到37行
6: ldc #3 // class cn/itcast/n5/Singleton 获取类对象引用 Singleton.class
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 "":()V	通过复制的引用去调用构造方法
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton; 将创建的对象赋值给静态变量INSTANCE 
27: aload_0	// 拿出之前astore_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 表示创建对象,将对象引用入栈
  • 20 表示复制一份对象引用
  • 21 表示利用一个对象引用,调用构造方法
  • 24 表示利用一个对象引用,赋值给 static INSTANCE

也许 jvm 会优化为:先执行 24,再执行 21。如果两个线程 t1,t2 按如下时间序列执行:

  • 关键在于 0: getstatic 这行代码在 monitor 控制之外,可以越过 monitor 读取 INSTANCE 变量的值
  • 这时 t1 还未完全将构造方法执行完毕,如果在构造方法中要执行很多初始化操作,那么 t2 拿到的是将是一个未初始化完毕的单例

对 INSTANCE 使用 volatile 修饰即可,可以禁用指令重排,但要注意在 JDK 5 以上版本的 volatile 才会真正有效

  • volatile保证可见性、有序性
  • synchronized保证可见性、有序性,原子性
  • synchronized虽然能保证共享变量的有序性,但不是通过禁止指令重排序实现的
  • 由于INSTANCE没有完全交给synchronized管理(即第一个if (INSTANCE == null)不在synchronized代码块中),并且synchronized代码块中依然有指令重排序,所以不加volatile会有线程安全问题

加 volatile

public final class Singleton {
	private Singleton() { }
	// 加 volatile
	private static volatile Singleton INSTANCE = null;
	public static Singleton getInstance() {
		if(INSTANCE == null) {		
			synchronized(Singleton.class) {
				if (INSTANCE == null) {
					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 "":()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 并不能保证一个线程对共享变量的写,对于其它线程对该共享变量的读可见。

注意:以下变量都是指成员变量或静态成员变量

1.synchronized解锁前的写
  • 线程解锁 m 之前对变量的写,对于接下来对 m 加锁的其它线程对该变量的读可见
static Object m = new Object();
        new Thread(()->{
            synchronized(m) {
                x = 10;
            }
        },"t1").start();
        new Thread(()->{
            synchronized(m) {
                System.out.println(x);
            }
        },"t2").start();
2.volatile修饰的变量的写
  • 线程对 volatile 变量的写,对接下来其它线程对该变量的读可见
volatile static int x;
  new Thread(()->{
      x = 10;
  },"t1").start();
  new Thread(()->{
      System.out.println(x);
  },"t2").start();
3.start之前的写
  • 线程 start 前对变量的写,对该线程开始后对该变量的读可见
static int x; x = 10;
new Thread(()->{
 System.out.println(x);
},"t2").start();
4.线程结束之前的写
  • 线程结束前对变量的写,对其它线程得知它结束后的读可见(比如其它线程调用 t1.isAlive() 或 t1.join()等待它结束)
static int x;
Thread t1 = new Thread(()->{
    x = 10;
},"t1");
t1.start();
t1.join();
System.out.println(x);
5.线程被打断之前的写
  • 线程 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);
}
6.对变量默认值(0,false,null)的写,对其它线程对该变量的读可见 7.传递性
  • 变量值的可见是具有传递性的,如果 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();
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/966565.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号