Java内存模型 HB法则

概述

• HB 7法则：volatile、start线程开始、join线程结束、lock锁释放之后、finalize对象销毁，时间先后、传递性
• java内存模型：每个线程操作数据是把对象拷贝到本地内存然进行操作，最后写回到主内存当中，不同线程之间不可见
• JMM为了防止重排序引发问题，保证了happens-before法则，这些法则是不会被重排序打乱的
• java的原子性：一个操作是原子操作，那么我们称它具有原子性，JDK1.5后再JUC包下有AotmicInteger来简化并发的原子操作，读取 操作 复查 写入的一个过程。多了一个可见性的复查过程避免线程不安全。unsafe类提供本地方法直接操作内存，从硬件方面实现原子性。

happens-before原则：

7个场景总结：

• 子线程.start()
• 子线程.join()
• volatile
• lock
• 传递性
• 初始化
• 单一线程前后性

1. Each action in a thread happens-before every subsequent action in that thread.
   在一个线程当中 先执行的代码结果 对随后进行的代码可见。（废话，一个线程公用一个本地缓存)

2. An unlock on a monitor happens-before every subsequent lock on that monitor
   对一个监视器进行解锁时的所有操作，对下一个锁的代码是可见的，比如在线程A中改了共有变量n的值，现在线程B获取了相同的锁，它是可以看见改变后n的值的。

3. A write to a volatile field happens-before every subsequent read of that volatile.
   A改了一个volatile的值，对接下来的所有的读取该变量值的线程可见

4. A可见于B B可见于C，那么A的所有操作也可见于C

5. start规则：如果线程A执行线程B的start方法，那么线程A的ThreadB.start()happens-before于线程B的任意操作
   A执行的操作之后再启动B线程，则A线程之前改过的值对B可见

static int index=1；
index++；
new Thread(new runnable(){
    public void run(){
        system.out.println(index);
    }
}).start();

6. join规则：如果线程A执行线程B的join方法，那么线程B的任意操作happens-before于线程A从TreadB.join()方法成功返回

main(){
    t1.start()
    t1.join()
    ti修改过的变量对main线程可见
}

7. 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；

可见性问题

基于java的内存模型，不同线程操作相同变量的时候，因为线程之间不可见，会导致可见性问题。

1. 举例：
   主内存中有变量count=100（比如某个对象的成员变量为count是100），现在多个线程去消费这个对象的count。
   线程A读取count=100，进行了count消费一个，修改本地内存为99，这个时候并不会直接写回到主内存当中，此时线程B去主内存中读取并消费count，最后线程A结束，写回count为99到主内存，线程B结束的时候，也写回99到主内存，因为可见性问题，导致count被消费2次，但是总量只减少了1。

2. 解决方案（volatile关键字、synchronized、final）

• synchronized可以保证线程安全，但是效率低
• volatile不能保证线程安全，但是可以缓解线程不可见的问题，比如A消费了count从100到99的时候，会立刻把count写回到主内存，如果B线程这个时候去取count这个对象，取到的就是99，而不是100。
• final关键字编译的时候就必须赋值，相当于常量，可以避免线程安全问题，但是运用的场景有限，一旦赋值不允许修改。

java重排序：

1. 编译期：编译器在编译的时候可能会打乱没有依赖关系的代码的编译顺序

2. CPU执行指令：执行不能保证编译的顺序，且有时候会并发的执行

3. 写入主内存时期：不能保证寄存器写会主内存的顺序是按照代码写的那样

4. 证明java的重排序
   注意只有当多个线程的时候才会出现这种情况，单线程一定不会出现这种情况，因为存在线程切换的时候，寄存器未写入到主内存当中，才会这样。

循环输出的话，会出现 a:1,x:0,b:1),y:0) 的情况的出现，可以证明。
因为不存在重排序的话，

• 如果先执行one线程，则a=1，y一定等于1；
• 如果先执行other线程的话，则b=1，导致x一定等于1
• 所以不存在 x和y同时为0的情况发生
  除非重排序，先执行x=b=0的时候，再切换线程y=a=0，的时候才会出现这种情况

public class Test {
    static int x = 0, y = 0;
    static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {
        while(true){
            x=y=a=b=0;
            test();
        }
    }
    
    public static void test() throws InterruptedException{
        Thread one = new Thread(new Runnable() {
            public void run() {
                a = 1;
                x = b;
            }
        });

        Thread other = new Thread(new Runnable() {
            public void run() {
                b = 1;
                y = a;
            }
        });
        one.start();other.start();
        one.join();other.join();
        if(x+y==0){
            System.out.println("a:" + a +",x:" + x + ",b:" + b +")"+ ",y:" + y +")");
        }
    }
}