zoukankan      html  css  js  c++  java
  • 高并发第四弹:线程安全性可见性有序性

    很重要的 搞清楚happen-before  -->Java并发编程之happens-before

    感谢 Java并发编程:volatile关键字解析

    • 可见性:一个线程对主内存的修改可以及时的被其他线程观察到。
    • 有序性:一个线程观察其他线程中的指令执行顺序,由于指令 重排序的存在,该观察结果一般杂乱无序。
    • 原子性:提供了互斥访问。
    特性操作
    可见性 可以由final(不会修改)、volatile(强制更新+读取主内存)以及synchronized(在unlock时会刷新所有已修改数据到主内存,lock时会从主内存重新加载数据)实现
    有序性 可以由volatile(禁止指令重排序)/synchronized(一个变量最多只能有一个线程对其lock)实现
    原子性 只有synchronized可以实现原子性,保证synchronized的代码块串行执行  

    synchronized在加锁时进行数据的重加载(主内存 -> 工作内存),在释放锁时将数据刷新到主内存。

    冲突访问(Conflicting Accesses) 对同一个共享字段或数组元素存在两个访问(读或写),且至少有一个访问是写操作,就称作有冲突。当程序包含两个没有被 happens-before 关系排序的冲突访问时,就称存在数据争用。

    动作A对于动作B是happen-before,即意味着动作A的修改(所有数据)对于动作B是可见的。

    happens-before关系如下:

    1. 某个线程中的每个动作都 happens-before 该线程中该动作后面的动作(这里无论指令是否重排序都必须满足)。
    2. 某个管程 m 上的解锁动作 synchronizes-with 所有后续在 m 上的锁定动作(这里的后续是根据同步顺序定义的)。
    3. 对 volatile 变量 v 的写操作 synchronizes-with 所有后续任意线程对 v 的读操作(这里的后续是根据同步顺序定义的)。
    4. 用于启动一个线程的动作(start方法) synchronizes-with 该新启动线程中的第一个动作。
    5. 初始化动作对于其他线程的第一个调用是happen-before
    6. happen-before是闭包传递的。这里写图片描述
    7. 个程序不存在数据争用,那么该程序是顺序一致的,即该程序不存在可见性问题。但是该程序还是可能在原子访问上出现问题,所以不存在数据争用并不是意味着线程安全,只有加上原子性保证才是线程安全的。这也是为什么synchronized是线程安全的,而volatile(保证所有变量访问都是happen-before)只有在所有操作都是原子的情况下才是线程安全的原因。

    另外,Java内存模型具备一些先天的“有序性”,即不需要通过任何手段就能够得到保证的有序性,这个通常也称为 happens-before 原则。如果两个操作的执行次序无法从happens-before原则推导出来,那么它们就不能保证它们的有序性,虚拟机可以随意地对它们进行重排序。

      下面就来具体介绍下happens-before原则(先行发生原则):

    • 程序次序规则:一个线程内,按照代码顺序,书写在前面的操作先行发生于书写在后面的操作
    • 锁定规则:一个unLock操作先行发生于后面对同一个锁额lock操作
    • volatile变量规则:对一个变量的写操作先行发生于后面对这个变量的读操作
    • 传递规则:如果操作A先行发生于操作B,而操作B又先行发生于操作C,则可以得出操作A先行发生于操作C
    • 线程启动规则:Thread对象的start()方法先行发生于此线程的每个一个动作
    • 线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
    • 线程终结规则:线程中所有的操作都先行发生于线程的终止检测,我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
    • 对象终结规则:一个对象的初始化完成先行发生于他的finalize()方法的开始

      这8条原则摘自《深入理解Java虚拟机》。

      这8条规则中,前4条规则是比较重要的,后4条规则都是显而易见的。

      下面我们来解释一下前4条规则:

      对于程序次序规则来说,我的理解就是一段程序代码的执行在单个线程中看起来是有序的。注意,虽然这条规则中提到“书写在前面的操作先行发生于书写在后面的操作”,这个应该是程序看起来执行的顺序是按照代码顺序执行的,因为虚拟机可能会对程序代码进行指令重排序。虽然进行重排序,但是最终执行的结果是与程序顺序执行的结果一致的,它只会对不存在数据依赖性的指令进行重排序。因此,在单个线程中,程序执行看起来是有序执行的,这一点要注意理解。事实上,这个规则是用来保证程序在单线程中执行结果的正确性,但无法保证程序在多线程中执行的正确性。

      第二条规则也比较容易理解,也就是说无论在单线程中还是多线程中,同一个锁如果出于被锁定的状态,那么必须先对锁进行了释放操作,后面才能继续进行lock操作。

      第三条规则是一条比较重要的规则,也是后文将要重点讲述的内容。直观地解释就是,如果一个线程先去写一个变量,然后一个线程去进行读取,那么写入操作肯定会先行发生于读操作。

      第四条规则实际上就是体现happens-before原则具备传递性。

    深入volatile的

    1.volatile关键字的两层语义

      一旦一个共享变量(类的成员变量、类的静态成员变量)被volatile修饰之后,那么就具备了两层语义:

      1)保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是立即可见的。

      2)禁止进行指令重排序。

    2.volatile的原理和实现机制

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

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

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

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

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

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

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

    使用场景

    synchronized关键字是防止多个线程同时执行一段代码,那么就会很影响程序执行效率,而volatile关键字在某些情况下性能要优于synchronized,但是要注意volatile关键字是无法替代synchronized关键字的,因为volatile关键字无法保证操作的原子性。通常来说,使用volatile必须具备以下2个条件:

      1)对变量的写操作不依赖于当前值

      2)该变量没有包含在具有其他变量的不变式中

      实际上,这些条件表明,可以被写入 volatile 变量的这些有效值独立于任何程序的状态,包括变量的当前状态。

      事实上,我的理解就是上面的2个条件需要保证操作是原子性操作,才能保证使用volatile关键字的程序在并发时能够正确执行。

      下面列举几个Java中使用volatile的几个场景。

    1.状态标记量

    volatile boolean flag = false;
     
    while(!flag){
        doSomething();
    }
     
    public void setFlag() {
        flag = true;
    }

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

    2.double check

    class Singleton{
        private volatile static Singleton instance = null;
         
        private Singleton() {
             
        }
         
        public static Singleton getInstance() {
            if(instance==null) {
                synchronized (Singleton.class) {
                    if(instance==null)
                        instance = new Singleton();
                }
            }
            return instance;
        }
    }

    synchronized关键字是防止多个线程同时执行一段代码,那么就会很影响程序执行效率,而volatile关键字在某些情况下性能要优于synchronized,但是要注意volatile关键字是无法替代synchronized关键字的,因为volatile关键字无法保证操作的原子性。通常来说,使用volatile必须具备以下2个条件:

      1)对变量的写操作不依赖于当前值

      2)该变量没有包含在具有其他变量的不变式中

      实际上,这些条件表明,可以被写入 volatile 变量的这些有效值独立于任何程序的状态,包括变量的当前状态。

      事实上,我的理解就是上面的2个条件需要保证操作是原子性操作,才能保证使用volatile关键字的程序在并发时能够正确执行。

      下面列举几个Java中使用volatile的几个场景。

    1.状态标记量

    1
    2
    3
    4
    5
    6
    7
    8
    9
    volatile boolean flag = false;
     
    while(!flag){
        doSomething();
    }
     
    public void setFlag() {
        flag = true;
    }

     

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    volatile boolean inited = false;
    //线程1:
    context = loadContext();  
    inited = true;            
     
    //线程2:
    while(!inited ){
    sleep()
    }
    doSomethingwithconfig(context);

     

    2.double check

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    class Singleton{
        private volatile static Singleton instance = null;
         
        private Singleton() {
             
        }
         
        public static Singleton getInstance() {
            if(instance==null) {
                synchronized (Singleton.class) {
                    if(instance==null)
                        instance = new Singleton();
                }
            }
            return instance;
        }
    }
  • 相关阅读:
    Cheatsheet: 2012 03.23 ~ 03.31
    Cheatsheet: 2012 04.13 ~ 04.24
    Cheatsheet: 2012 02.09 ~ 02.29
    Cheatsheet: 2012 03.01 ~ 03.12
    Cheatsheet: 2012 03.13 ~ 03.22
    Cheatsheet: 2012 01.20 ~ 01.31
    Cheatsheet: 2012 04.01 ~ 04.12
    Cheatsheet: 2012 04.25 ~ 05.03
    Cheatsheet: 2012 01.10 ~ 01.19
    1.30
  • 原文地址:https://www.cnblogs.com/aihuxi/p/9671713.html
Copyright © 2011-2022 走看看