What is the Happens before rule for java threads?

Text

happens-before stipulates that the write operation of the shared variable is visible to the read operation of other threads. It is a summary of a set of rules for visibility and orderliness, regardless of the following happens-before rules. , JMM cannot guarantee that a thread's write to a shared variable will be visible to other threads' reads of the shared variable.

Case 1

The write to the variable before the thread unlocks m will be visible to the next The reading of the variable by other threads locked on m is visible

    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();
/*
运行结果:
10
*/

Case 2

The writing of the volatile variable by the thread is visible by the subsequent reading of the variable by other threads

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

    new Thread(()->{
     System.out.println(x);
    },"t2").start();
/*
运行结果:
10
*/

Case 3

The writing to the variable before the thread starts is visible to the reading of the variable after the thread starts.

static int x;
x = 10;
new Thread(()->{
 System.out.println(x);
},"t2").start();
/*
运行结果:
10
*/

Case 4

The writing to the variable before the thread ends is visible. Write, visible to other threads for reading after they know it ends (such as other threads calling t1.isAlive() or t1.join() to wait for it to end)

static int x;
Thread t1 = new Thread(()->{
 x = 10;
},"t1");
t1.start();
t1.join();
System.out.println(x);
/*
运行结果:
10
*/

Case 5

Thread t1 The writing of variables before interrupting t2 (interrupt) is visible to other threads after they learn that t2 is interrupted (through t2.interrupted or t2.isInterrupted)

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);
}
/*
运行结果:
10
*/

Case 6

The writing of the default value of the variable (0, false, null) is visible to the reading of the variable by other threads

    static int a;
    public static void main(String[] args) {
        new Thread(()->{
            System.out.println(a);
        }).start();

    }
/*
运行结果:
0
*/

Case 7

is transitive, if x hb-> y and y hb-> z then we have

The above is the detailed content of What is the Happens before rule for java threads?. For more information, please follow other related articles on the PHP Chinese website!