24小时在线 - 古典小说 - 文学小说 - 关于我们
您的当前位置:首页 > 移动开发 > 移动开发 >

Java多线程高并发基础篇(6)-JMM重排序规则

来源:比特技术 编辑:比特技术网 时间:2018-04-23点击:
导读:Java多线程高并发基础篇(六)-JMM重排序规则 我们知道,重排序的目的是在不改变程序执行结果的前
Java多线程高并发基础篇(六)-JMM重排序规则

我们知道,重排序的目的是在不改变程序执行结果的前提下,提高编译器和处理器对程序的执行性能。但是,重排序不是任意的,所谓无规矩不成方圆。理解重排序就需要知道重排序必须遵守的规则,总结起来就是我们今天要说的Happens-Before规则。在JSR-133: JavaTM Memory Model and Thread Specification中有相关描述,原版英文请见pdf文件,下载了一份供大家学习。

一. Happens-Before规则

Happens-Before规则规定了哪些情况下指令不能进行重排序。

  • 程序顺序原则:一个线程内,代码执行的过程必须保证语义的串行性( as-if-serial,看起来是串行的;另外如果程序内数据存在依赖,也不允许进行重排序 )。
  • 监视器锁规则:解锁unlock必然发生在加锁lock前。
  • 传递性规则:如果操作A先于操作B,操作B先于操作C,那么操作A必先于操作C。
  • volatile规则:一个共享变量的写操作,必须先于读操作,这是volatile可见性语义的要求。
  • 线程的start规则:线程的start操作先于线程内其他任何操作。
  • 线程的join规则:如果线程ThreadA中执行了ThreadB.join()方法,那么ThreadB的所有操作先于ThreadA中ThreadB.join()返回后的操作。

二. 对于Happens-Before规则解释

1. as-if-serial语义

看起来像串行的--编译器和处理器对重排序的机制对程序员是透明的,但是我们观察到的结果跟按照编写程序的顺序是一致的,这就是看起来像的含义。

举一例说明:

 

int a = 2; // A
int b = 3; // B
int c = a*b; // C

在上述程序中,步骤C依赖于步骤A和B,但是步骤A和B之间没有依赖关系,依赖关系图长这样:

 

根据程序的顺序执行规则,由于C依赖于A和B,那么C的执行顺序不能排在A和B之前,但是A和B的顺序是可以互换的,也就是说,我们按照程序顺序执行的语义,看到的执行顺序是这样:A-->B-->C,但是编译器和处理器可能进行重排序成这样子:B-->A-->C,但是这个过程对我们来说是透明的,但是最终结果跟我们想要的是一样的。这就是看起来像 as-if-serial的语义。

 

2.锁规则

在并发编程中,锁保证了临界区的互斥访问,同时还可以让释放锁的线程向另一个线程发送消息。

我们举一例,先来段代码。

public class MonitorDemo {
  int a = 0;
  public synchronized void writer() { // 1
     a++; // 2
  } // 3
  public synchronized void reader() { // 4
      int i = a; // 5
      ……
  } // 6
}

 

比如现在有两个线程A和B,线程A执行writer方法,线程B随后执行reader方法,根据happens-before原则,我们来梳理下这个过程包含的happens-before关系。

①依据程序顺序执行顺序原则,1-->2-->3;4-->5-->6

②根据监视器锁规则,锁的获取先于锁的释放,那么在A线程未执行完writer时,线程B是无法得到锁的。因此3-->4.

③根据传递性规则,那我们可以得到2-->5.

最后我们得到的happens-before关系图是这样子的:


 

 

 

 这也就是说,当线程B获取到线程A释放的锁后,线程A操作过的共享变量的内容对B是可见的(线程A的步骤2改变了a的值,线程B的步骤5获得了同一把锁后立刻可以得到a的最新值)。

这里我们也对在并发编程中锁的语义进行总结:

  • 线程A释放一个锁,实质上是线程A向接下来将要获取这个锁的某个线程发出了(线程A对共享变量所做修改的)消息。

  • 线程B获取一个锁,实质上是线程B接收了之前某个线程发出的(在释放这个锁之前共享变量所做修改的)消息。

  • 线程A释放锁,随后线程B获取这个锁,这个过程实质上是线程A通过主内存向线程B发送消息。  

 3.volatile规则

3.1 volatile语义

在并发编程中,单个volatile变量的读、写可以看成是使用同一把锁对单个变量读写操作进行了同步锁操作。

例如,线程A和线程B执行下列代码,线程A执行set()方法,线程B随后执行get()方法。使用volatile
变量和对普通变量进行操作加锁的执行效果是一致的。

下面两个代码执行效果是等价的:

 

public class VolatileDemo {
  volatile long vl = 0L; // 使用volatile声明64位的long型变量
  public void set(long l) {
     vl = l; //1. 单个volatile变量的写
  } 
  public void getAndIncrement () {
     vl++; // 复合(多个)volatile变量的读/写
  }
  public long get() {
     return vl; //2. 单个volatile变量的读
  }
}

public class VolatileDemo2 {
  long vl = 0L; // 64位的long型普通变量
  public synchronized void set(long l) { // 对单个的普通变量的写加同步锁
     vl = l;
  }
  public void getAndIncrement () { // 普通方法调用
     long temp = get(); // 调用已同步的读方法
     temp += 1L; // 普通写操作
     set(temp); // 调用已同步的写方法
  }
  public synchronized long get() { // 对单个的普通变量的读加同步锁
     return vl;
  }
}
换句话说,volatile变量的写与锁的获取有相同的内存语义,volatile变量的读与锁的释放有相同的内存语义,这也就证明了对单个volatile变量的读写操作是原子性的,但是对volatile变量进行复合操作不具有原子性的,这个一定要注意。

 

我们来梳理下使用volatile变量的happens-before关系图,可能对理解更有帮助。

来个例子,线程A和线程B执行下列代码,线程A执行set()方法,线程B随后执行get()方法:

 

public class VolatileDemo {
  volatile long vl = 0L; // 使用volatile声明64位的long型变量
  public void set(long l) {//1
     vl = l; // 2
  } 
  public long get() {//3
     return vl; // 4
  }
}
 

 

①根据程序顺序执行原则,1-->2,;3-->4

②根据volatile规则,volatile变量的写先于读,所以2-->3

③根据传递性规则,1-->4

所以,我们最后得到的happens-before关系图是这样的:


总结一下,volatile的内存语义:

  • 线程A写一个volatile变量,实质上是线程A向接下来将要读这个volatile变量的某个线程发出了(其对共享变量所做修改的)消息。
  • 线程B读一个volatile变量,实质上是线程B接收了之前某个线程发出的(在写这个volatile变量之前对共享变量所做修改的)消息。
  • 线程A写一个volatile变量,随后线程B读这个volatile变量,这个过程实质上是线程A通过主内存向线程B发送消息。

3.2 volatile语义的实现

我们先来看看编译器制定的volatile重排序规则表。


 在规则表中,我们可以明确看到,

当第一个操作是volatile读时,不管第二个操作是什么都不能重排序。

当第一个操作是volatile写时,第二个操作为volatile读、写时不能重排序。

 

为了实现volatile的语义,编译器在编译代码时候,会生成对应的内存屏障指令,来禁止特定类型操作的处理器重排序。JMM采用保守(认为每个都必须这么做)的内存屏障插入策略来实现volatile语义:

  • 在每个volatile操作的前面插入一个StoreStore屏障。
  • 在每个volatile操作的后面插入一个StoreLoad屏障。
  • 在每个volatile操作的后面插入一个LoadLoad屏障。
  • 在每个volatile操作的后面插入一个LoadStore屏障。

举一例子体会下:

public class VolatileBarrierDemo {
	int c;
	volatile int a = 1;
	volatile int b = 2;
	void readAndWrite() {
		int i = a; // 第一个volatile读
		int j = b; // 第二个volatile读
		c = i + j; // 普通写
		a = i + 1; // 第一个volatile写
		b = j * 2; // 第二个 volatile写
	}
}

 最后生成的指令执行示意图如下(红色部分的屏障可以省略掉,因为紧跟着的操作跨越不了已有的屏障):



 

来源:比特技术在线(www.byte.online),欢迎分享本文,转载请保留出处!
http://www.byte.online/a/yidongkaifa/yidongkaifa/2018/129102.html
责任编辑:比特技术网

    打赏

    取消

    感谢您的支持,我会继续努力的!

    扫码支持
    扫码打赏,你说多少就多少

    打开支付宝扫一扫,即可进行扫码打赏哦

    网友评论:

    Copyright © www.byte.online 比特技术在线 版权所有 粤ICP备15038486号-3
    本站所有资料来源于网络,由个人收集整理,仅限于个人学习和研究,如果侵犯您的权益请联系我们删除!
    Top