4.happens-before

happens-before规则：

happens-before规定了对共享变量的写操作对其他线程的读操作可见，它是可见性与有序性的一套规则总结，抛开以下happens-before规则，JMM并不能保证一个线程对共享变量的写，对于其他线程对该共享变量的读可见

1.线程解锁m之前对变量的写，对于接下来对m加锁的其他线程对该变量的读可见

static int x;
static Object m = new Object();
new Thread(()->{
    synchronized(m){
        x = 10;
    }
},"t1").start();
new Thread(()->{
    synchronized(m){
        System.out.println(x);
    }
},"t2").start();

2.线程对volatile变量的写，对接下来其他线程对该变量的读可见

volatile static int x;
new Thread(()->{
     x = 10;
},"t1").start();
new Thread(()->{
     System.out.println(x);
},"t2").start();

3.线程start前对变量的写，对该线程开启后对该变量的读可见

static int x;
x = 10;
new Thread(()->{
     System.out.println(x);
},"t2").start();

4.线程结束前对变量的写，对其它线程得知它结束后的读可见（比如其他线程调用isAlive或join等待它结束）

static int x;
Thread t1 = new Thread(()->{
     x = 10;
},"t1");
t1.start();
t1.join();
System.out.println(x);

5.线程t1打断t2前对变量的写，对于其他线程得知t2被打断后对变量的读可见

static int x;
public static void main(String[] args) {
 Thread t2 = new Thread(()->{
     while(true) {
         if(Thread.currentThread().isInterrupted()) {
             System.out.println(x);
             break;
         }
     }
 },"t2");
 t2.start();
 new Thread(()->{
     sleep(1);
     x = 10;
     t2.interrupt();
 },"t1").start();
 while(!t2.isInterrupted()) {
     Thread.yield();
 }
 System.out.println(x);
}

6.对变量默认值(0，false，null)的写操作，对其他线程对该变量的读可见

7.具有传递性

volatile static int x;
static int y;
new Thread(()->{
     y = 10;
     x = 20;
},"t1").start();
new Thread(()->{
     // x=20 对 t2 可见, 同时 y=10 也对 t2 可见
     System.out.println(x);
},"t2").start();