Java并发之原子性可见性有序性

Posted StoneGeek

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java并发之原子性可见性有序性相关的知识,希望对你有一定的参考价值。

前言

通过并发编程的形式,可以将多核CPU的计算能力发挥到极致,性能得到提升,能够让我们更充分地利用系统资源,与此同时,必须要保证原子性、有序性、可见性,才能保证程序不会出现问题

一、原子性

(1)解释

原子性指的是一个或者多个操作,要么全部执行并且在执行的过程中不被其他操作打断,要么就全部都不执行

(2)分析

分析以下代码,判断哪些是原子性的
x=10;//语句1
y=x;//语句2
x++;//语句3
x=x+1;//语句4

看到上面的代码可能小伙伴们会说都是原子性的,实则不然,只有语句1是原子性的。

x=10,线程执行这个语句时直接把数值10写入工作内存

y=x,线程执行这个语句时,首先从工作内存中读取x的值,再将x的值写入到工作内存,虽然这两个操作都是原子性的,但是合起来就不是了。

x++,线程执行这个语句时,本质上执行了三个动作,先把x从工作内存中读取,在进行+1,再把最后的结果写入到工作内存。

也就是说,在java的内存模型中,只有对基本数据类型的简单读取和赋值是原子性的(相互赋值不是原子性)。

对volatile变量的单次读/写操作可以保证原子性的,如long和double类型变量,但是并不能保证i++这种操作的原子性,因为本质上i++是读、写两次操作。
因为long和double两种数据类型的操作可分为高32位和低32位两部分,因此普通的long或double类型读/写可能不是原子的。因此,鼓励大家将共享的long和double变量设置为volatile类型,这样能保证任何情况下对long和double的单次读/写操作都具有原子性。

package com.paddx.test.concurrent;
public class VolatileTest01 {
volatile int i;
public void addI(){
    i++;
}
public static void main(String[] args) throws InterruptedException {
    final  VolatileTest01 test01 = new VolatileTest01();
    for (int n = 0; n < 1000; n++) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                test01.addI();
            }
        }).start();
    }
    Thread.sleep(10000);//等待10秒,保证上面程序执行完成
    System.out.println(test01.i);//结果为981
}
}
详解:大家可能会误认为对变量i加上关键字volatile后,这段程序就是线程安全的。
可能每个人运行的结果不相同。不过应该能看出,volatile是无法保证原子性的(否则结果应该是1000)。原因也很简单,i++其实是一个复合操作,包括三步骤:(1)读取i的值。(2)对i加1。(3)将i的值写回内存。

volatile是无法保证这三个操作是具有原子性的,我们可以通过AtomicInteger或者Synchronized来保证+1操作的原子性。

(3)实现

实现大范围原子性的方法:

悲观锁(synchronized或者Lock)

乐观锁(原子类 cas)

二、可见性

(1)解释

可见性指多个线程操作一个共享变量时,其中一个线程对变量进行修改后,其他线程可以立即看到修改的结果。

(2)分析

计算机在执行程序时,每条指令都是在CPU中执行的,而执行指令过程中,势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存(物理内存)当中的,这时就存在一个问题,由于CPU执行速度很快,而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多,因此如果任何时候对数据的操作都要通过和内存的交互来进行,会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。

也就是说,当程序在运行过程中,会将运算需要的数据从主存复制一份到CPU的高速缓存当中,那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据,当运算结束之后,再将高速缓存中的数据刷新到主存当中

package com.paddx.test.concurrent;
public class VolatileTest {
int a = 1;
int b = 2;
public void change(){
    a = 3;
    b = a;
}
public void print(){
    System.out.println("b="+b+";a="+a);
}
public static void main(String[] args) {
    while (true){
        final VolatileTest test = new VolatileTest();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                test.change();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                test.print();
            }
        }).start();
    }
}
}

解释:
直观上说,这段代码的结果只可能有两种:b=3;a=3 或 b=2;a=1。不过运行上面的代码(可能时间上要长一点),你会发现除了上两种结果之外,还出现了第三种结果:
为什么会出现b=3;a=1这种结果呢?正常情况下,如果先执行change方法,再执行print方法,输出结果应该为b=3;a=3。相反,如果先执行的print方法,再执行change方法,结果应该是 b=2;a=1。那b=3;a=1的结果是怎么出来的?原因就是第一个线程将值a=3修改后,但是对第二个线程是不可见的,所以才出现这一结果。如果将a和b都改成volatile类型的变量再执行,则再也不会出现b=3;a=1的结果了。

(3)实现

实现可见性的方法:

synchronized或者Lock:保证同一个时刻只有一个线程获取锁执行代码,锁释放之前把最新的值刷新到主内存,实现可见性。

volatile:被volatile修饰的变量,一个线程修改后直接把值写入主内存,其他线程直接从主内存中读取。

三、有序性

(1)解释

有序性,即程序的执行顺序按照代码的先后顺序来执行。

(2)分析

指令重排序,一般来说,处理器为了提高程序运行效率,可能会对输入代码进行优化,它不保证程序中各个语句的执行先后顺序同代码中的顺序一致,但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。

处理器在进行重排序时是会考虑指令之间的数据依赖性,如果一个指令Instruction 2必须用到Instruction 1的结果,那么处理器会保证Instruction 1会在Instruction 2之前执行。

再看多线程的一个例子:

//volatile boolean inited = false;
//线程1:
context = loadContext(); 
inited = true; 
//线程2:
while(!inited ){
sleep()
}
doSomethingwithconfig(context);

详解:上面代码中,由于语句1和语句2没有数据依赖性,因此可能会被重排序。假如发生了重排序,在线程1执行过程中先执行语句2,而此是线程2会以为初始化工作已经完成,那么就会跳出while循环,去执行doSomethingwithconfig(context)方法,而此时context并没有被初始化,就会导致程序出错。
从上面可以看出,指令重排序不会影响单个线程的执行,但是会影响到线程并发执行的正确性。
也就是说,要想并发程序正确地执行,必须要保证原子性、可见性以及有序性。只要有一个没有被保证,就有可能会导致程序运行不正确。

这里如果用volatile关键字对inited变量进行修饰,就不会出现这种问题了,因为当执行到语句2时,必定能保证context已经初始化完毕。

(3)实现

实现有序性的方法:

synchronized或者Lock

volatile(禁止指令重排序)
顺便提一下:

四、volatile的原理和实现机制

前面讲述了源于volatile关键字的一些使用,下面我们来探讨一下volatile到底如何保证可见性和禁止指令重排序的。

  下面这段话摘自《深入理解Java虚拟机》:

  “观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现,加入volatile关键字时,会多出一个lock前缀指令”

  lock前缀指令实际上相当于一个内存屏障(也成内存栅栏),内存屏障会提供3个功能:

  1)它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置,也不会把前面的指令排到内存屏障的后面;即在执行到内存屏障这句指令时,在它前面的操作已经全部完成;

  2)它会强制将对缓存的修改操作立即写入主存;

  3)如果是写操作,它会导致其他CPU中对应的缓存行无效。
  

五、Synchronized原理和实现机制

(1)synchronized静态代码块

将一个synchronized静态代码块反编译会看到两个专有名词
monitorenter
每个对象有一个监视器锁(monitor)。当monitor被占用时就会处于锁定状态,线程执行monitorenter指令时尝试获取monitor的所有权,过程如下:

1、如果monitor的进入数为0,则该线程进入monitor,然后将进入数设置为1,该线程即为monitor的所有者。

2、如果线程已经占有该monitor,只是重新进入,则进入monitor的进入数加1.

3.如果其他线程已经占用了monitor,则该线程进入阻塞状态,直到monitor的进入数为0,再重新尝试获取monitor的所有权。
monitorexit:
执行monitorexit的线程必须是objectref所对应的monitor的所有者。

指令执行时,monitor的进入数减1,如果减1后进入数为0,那线程退出monitor,不再是这个monitor的所有者。其他被这个monitor阻塞的线程可以尝试去获取这个 monitor 的所有权。
  
总结
通过这两段描述,我们应该能很清楚的看出Synchronized的实现原理,Synchronized的语义底层是通过一个monitor的对象来完成,其实wait/notify等方法也依赖于monitor对象,这就是为什么只有在同步的块或者方法中才能调用wait/notify等方法,否则会抛出java.lang.IllegalMonitorStateException的异常的原因。

(2)synchronized同步方法

将一个synchronized同步方法反编译:
ACC_SYNCHRONIZED
从反编译的结果来看,方法的同步并没有通过指令monitorenter和monitorexit来完成(理论上其实也可以通过这两条指令来实现),不过相对于普通方法,其常量池中多了ACC_SYNCHRONIZED标示符。JVM就是根据该标示符来实现方法的同步的:当方法调用时,调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置,如果设置了,执行线程将先获取monitor,获取成功之后才能执行方法体,方法执行完后再释放monitor。在方法执行期间,其他任何线程都无法再获得同一个monitor对象。 其实本质上没有区别,只是方法的同步是一种隐式的方式来实现,无需通过字节码来完成。

以上是关于Java并发之原子性可见性有序性的主要内容,如果未能解决你的问题,请参考以下文章

并发之原子性可见性有序性

Java并发之原子性,有序性,可见性,以及Happen-Before原则

并发之原子性可见性有序性

并发编程之原子性可见性有序性的简单理解

Java高并发编程实战2,原子性可见性有序性,傻傻分不清

学妹教你并发编程的三大特性:原子性可见性有序性