Java并发 volatile可见性的验证

小灰灰 2023-03-14 10:57 24阅读 0赞

### 文章目录 ###

*  普通读 无法及时获得 主内存变量
 *  volatile读 及时获得 主内存变量
 *  普通读+sleep
 *  普通读+同步块
 *   *  同步块 遭遇 锁消除
 *  普通读+System.out.println
 *  总结

# 普通读 无法及时获得 主内存变量 #

*  主线程已经修改了flag为true，但子线程一直不会退出循环，因为子线程一直没有同步到 主内存中的变量的值。  
    ![在这里插入图片描述][20200517210412233.png]
 *  截图可见程序一直没有退出，使用dump threads后：

"Thread-0" #12 prio=5 os_prio=0 tid=0x0000000022d89800 nid=0x168 runnable [0x00000000248df000]
       java.lang.Thread.State: RUNNABLE
    	at volatileTest$1.run(volatileTest.java:10)
    	at java.lang.Thread.run(Thread.java:745)

# volatile读 及时获得 主内存变量 #

public class volatileTest { 
        static volatile boolean flag = false;//volatile变量
    
        public static void main(String[] args) throws Exception { 
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    while(!flag){ 
                    };
                }
            }).start();
            Thread.sleep(100);
            flag = true;
            System.out.println("主线程运行完毕");
        }
    }

*  加了一个volatile关键字，子线程就能检测到flag的变化了。子线程会退出。

# 普通读+sleep #

public class volatileTest { 
        static boolean flag = false;//非volatile变量
    
        public static void main(String[] args) throws Exception { 
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    while(!flag){ 
                        try { 
                            Thread.sleep(1);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    };
                }
            }).start();
            Thread.sleep(100);
            flag = true;
            System.out.println("主线程运行完毕");
        }
    }

加了sleep，子线程会退出。

其实就算变量不是volatile的，JVM也会尽量去保证可见性。最开始的例子，由于CPU一直执行循环，没有其他时间来获取 主内存中的变量的最新值，但加了sleep后，CPU就有时间去获取 主内存中的东西了。

# 普通读+同步块 #

public class volatileTest { 
        static boolean flag = false;//非volatile变量
        static Object sync = new Object();
    
        public static void main(String[] args) throws Exception { 
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    while(!flag){ 
                        synchronized (sync) { }//随便synchronized一个对象
                        //synchronized (this)也可以
                    };
                }
            }).start();
            Thread.sleep(100);
            flag = true;
            System.out.println("主线程运行完毕");
        }
    }

加了同步块，子线程会退出。

这是因为synchronized具体过程是：

1.  获得同步锁；
2.  清空工作内存；
3.  从主内存拷贝对象副本到工作内存；
4.  执行代码(计算或者输出等)；
5.  刷新主内存数据；
6.  释放同步锁。

简单的说，synchronized进入时，会将 主内存中最新的变量，拷贝进 自己线程 的工作内存。synchronized退出时，会把 自己线程的工作内存的变量 弄进 主内存中。

## 同步块 遭遇 锁消除 ##

public class volatileTest { 
        static boolean flag = false;//非volatile变量
    
        public static void main(String[] args) throws Exception { 
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    while(!flag){ 
                        synchronized (new Object()){ }
                    };
                }
            }).start();
            Thread.sleep(100);
            flag = true;
            System.out.println("主线程运行完毕");
        }
    }

子线程不会退出。

原因是：`synchronized (new Object()){}`中这个Object永远不可能逃逸到同步块以外去，所以同步操作其实根本不需要执行了，既然没有执行同步，那么相当于这里是啥也没有。

# 普通读+System.out.println #

public class volatileTest { 
        static boolean flag = false;
    
        public static void main(String[] args) throws Exception { 
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    while(!flag){ 
                        System.out.println("子线程running");
                    };
                }
            }).start();
            Thread.sleep(100);
            flag = true;
            System.out.println("主线程运行完毕");
        }
    }

加了`System.out.println`，子线程会退出。

因为out这个PrintStream实例的println实现是：

public void println(String x) { 
            synchronized (this) { 
                print(x);
                newLine();
            }
        }

因为它也有同步块。

# 总结 #

*  volatile读写，保证可见性。
 *  普通读写，不保证可见性（可能会保持，也可能不保持）。

[20200517210412233.png]: /images/20230312/3994f99df6454bcca99c0030d505de4d.png