【并发重要原则】happens-before理解和应用

理解happens-before主要为了理解源码。主要jdk里面一堆华丽呼哨的操作,如果基础不牢靠,看着心累。

目录:
1.happens-before的理解
2.应用1,futuretask non-volatile

引用:
1.why outcome object in FutureTask is non-volatile? (老外对代码的理解真的厉害)
2.happens-before俗解
3. Java内存模型之happens-before
4. 一句话理解什么是happens-before
5. happen-before规则及其对DCL的分析(含代码)

1.happens-before的理解

1.1 为什么要有一个happens-before的原则?

结论:happens-before觉得着什么时候变量操作对你可见。

我们知道cpu的运行极快,而读取主存对于cpu而言有点慢了,在读取主存的过程中cpu一直闲着(也没数据可以运行),这对资源来说造成极大的浪费。所以慢慢的cpu演变成了多级cache结构,cpu在读cache的速度比读内存快了n倍。

当线程在执行时,会保存临界资源的副本到私有work memory中,这个memory在cache中,修改这个临界资源会更新work memory但并不一定立刻刷到主存中,那么什么时候应该刷到主存中呢?什么时候和其他副本同步?
而且编译器为了提高指令执行效率,是可以对指令重排序的,重排序后指令的执行顺序不一样,有可能线程2读取某个变量时,线程1还未进行写入操作。这就是线程可见性的来源。

针对以上两个问题,JMM给出happens-before通用的规则(注意这仅对java而言,其他的就布吉岛了)

1.2 happens-before原则有啥好处?

i = 1;       //线程A执行
j = i ;      //线程B执行

j 是否等于1呢?假定线程A的操作(i = 1)happens-before线程B的操作(j = i)。
那么可以确定线程B执行后j = 1 一定成立。
如果他们不存在happens-before原则,那么j = 1 不一定成立。

(即使代码是先执行j=1,然后执行j=i,也不一定j=1,主要看是否符合happens-before)

1.3 happens-before原则

  1. 如果操作1 happens-before 操作2,那么第操作1的执行结果将对操作2可见,而且操作1的执行顺序排在第操作2之前。
  2. 两个操作之间存在happens-before关系,并不意味着一定要按照happens-before原则制定的顺序来执行。如果重排序之后的执行结果与按照happens-before关系来执行的结果一致,那么这种重排序并不非法。

1.4如何判断是否为 happens-before?

  • 程序次序规则: 在一个单独的线程中,按照程序代码的执行流顺序,(时间上)先执行的操作happen—before(时间上)后执行的操作
    同一个线程中前面的所有写操作对后面的操作可见

  • 管理锁定规则:一个unlock操作happen—before后面(时间上的先后顺序)对同一个锁的lock操作。
    如果线程1解锁了monitor a,接着线程2锁定了a,那么,线程1解锁a之前的写操作都对线程2可见(线程1和线程2可以是同一个线程)

  • volatile变量规则:对一个volatile变量的写操作happen—before后面(时间上)对该变量的读操作。
    如果线程1写入了volatile变量v(临界资源),接着线程2读取了v,那么,线程1写入v及之前的写操作都对线程2可见(线程1和线程2可以是同一个线程)

  • 线程启动规则:Thread.start()方法happen—before调用用start的线程前的每一个操作。
    假定线程A在执行过程中,通过执行ThreadB.start()来启动线程B,那么线程A对共享变量的修改在接下来线程B开始执行前对线程B可见。注意:线程B启动之后,线程A在对变量修改线程B未必可见。

  • 线程终止规则:线程的所有操作都happen—before对此线程的终止检测,可以通过Thread.join()方法结束、Thread.isAlive()的返回值等手段检测到线程已经终止执行。
    (线程t1写入的所有变量,在任意其它线程t2调用t1.join(),或者t1.isAlive() 成功返回后,都对t2可见。)

  • 线程中断规则:对线程interrupt()的调用 happen—before 发生于被中断线程的代码检测到中断时事件的发生。
    (线程t1写入的所有变量,调用Thread.interrupt(),被打断的线程t2,可以看到t1的全部操作)

  • 对象终结规则:一个对象的初始化完成(构造函数执行结束)happen—before它的finalize()方法的开始。
    (对象调用finalize()方法时,对象初始化完成的任意操作,同步到全部主存同步到全部cache。)

  • 传递性:如果操作A happen—before操作B,操作B happen—before操作C,那么可以得出A happen—before操作C。
    A h-b B , B h-b C 那么可以得到 A h-b C

1.5 一言以蔽之,这些规则背后的道理

在程序运行过程中,所有的变更会先在寄存器或本地cache中完成,然后才会被拷贝到主存以跨越内存栅栏(本地或工作内存到主存之间的拷贝动作),此种跨越序列或顺序称为happens-before。
注:happens-before本质是顺序,重点是跨越内存栅栏
通常情况下,写操作必须要happens-before读操作,即写线程需要在所有读线程跨越内存栅栏之前完成自己的跨越动作,其所做的变更才能对其他线程可见。

2.应用

2.1 单例模式

单例模式可能存在问题哦,请看我的文章【单例模式】DCL的问题和解决方法

可以看出,如果有两个线程都执行过synchronized ,那么符合"管理锁定规则",那么我们可以线程 singleton即使不加上volatile,也不会影响线程间的可见性

public class Singleton {     
    private static Singleton singleton;  
    private Singleton() {      }     
    public static Singleton getInstance() {     
        if (singleton == null) {    
            synchronized (Singleton.class) {     
                if (singleton == null) {     
                    Singleton temp = null;  
                    try {  
                        temp = new Singleton();    
                    } catch (Exception e) {   }  
                    if (temp != null) 
                        singleton = temp; 
                }    
            }    
        }    
        return singleton;    
    }  
}  

2.2 CopyOnWriteArrayList 的例子

线程A和线程B要执行的以下代码,最后结果b=1吗?(其中list为CopyOnWriteArrayList)

线程A 线程B
a = 1; list.get(0);
list.set(1,""); int b = a;

执行顺序流1:

步骤 线程A 线程B
a a = 1;
b list.set(1,"");
c list.get(0);
d int b = a;

执行顺序流2:

步骤 线程A 线程B
a a = 1;
b list.get(0);
c list.set(1,"");
d int b = a;

在确线程B是否一定能看到线程A的a变量前,我们先看看CopyOnWriteArrayList 的源码:
可以发现基本get/set都是一个volatile申明的array变量

    private transient volatile Object[] array;

    public E get(int index) {
        return get(getArray(), index);
    }
    final Object[] getArray() {
        return array;
    }

    public E set(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //TODO xxx
            setArray(newElements);
        } finally {
            lock.unlock();
    }
    final void setArray(Object[] a) {
        array = a;
    }    

通过我们的源码的分析,基本可以判断这里要用到volatile变量规则,
即:对一个volatile变量的写操作happen—before后面(时间上)对该变量的读操作。

我们对执行顺序流进行分析:
(步骤a happens-before 步骤b 记为 hb(a,b))

顺序流1:
根据程序次序规则可以得到 hb(a,b),hb(c,d),如果我们希望b=1,那么只需要 hb(b,c)
由于volatile变量规则,我们可以得到hb(b,c),所以一定b=1。

顺序流2:
根据程序次序规则可以得到 hb(a,c),hb(b,d),如果我们希望b=1,那么我们需要hb(a,b)或hb(c,d)。
然而没有规则可以得到以上条件,故不成立,b不一定等于1。

推荐阅读更多精彩内容