Java volatile之println细节

悠悠 2024-03-27 14:07 10阅读 0赞

## volatile定义 ##

volatile是java虚拟机提供的轻量级的同步机制

#### 特性 ####

保证可见性

不保证原子性

禁止指令重排

##### 示例 #####

在不使用volatile的情况下，主线程获取的num和子线程中设置数值的num存放在不同位置的，彼此不可见，因此，在子线程中设置num的值时，主线程中的num并不会被改变，依然是num=0

public class VolatileTest {
        public static void main(String[] args) {
            MyData myData = new MyData();
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" 修改前的值："+myData.num);
                //休眠
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //修改数值
                myData.setNum();
                System.out.println("修改后的值："+myData.num);
            }).start();
    
            while (myData.num == 0){
    
            }
            System.out.println(Thread.currentThread().getName()+"执行完");
        }
    }
    class MyData{
        int num = 0;
        public synchronized void setNum() {
            num = 123;
        }
    }
    
    运行结果：
    Thread-0 修改前的值：0
    修改后的值：123
    （循环）

但是加了volatile之后，使num成员变量存储在了内存中，增加了num的可见性，因此使得主线程能够访问到子线程设置的num，从而能退出循环，继续执行

public class VolatileTest {
        public static void main(String[] args) {
            MyData myData = new MyData();
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" 修改前的值："+myData.num);
                //休眠
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //修改数值
                myData.setNum();
                System.out.println("修改后的值："+myData.num);
            }).start();
    
            while (myData.num == 0){
    
            }
            System.out.println(Thread.currentThread().getName()+"执行完");
        }
    }
    class MyData{
        volatile int num = 0;
        public synchronized void setNum() {
            num = 123;
        }
    }
    
    运行结果：
    
    Thread-0 修改前的值：0
    修改后的值：123
    main执行完

### But ###

###### 如果在while循环中加入了输出语句，结果就不一样了 ######

以不加volatile为例

public class VolatileTest {
        public static void main(String[] args) {
            MyData myData = new MyData();
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" 修改前的值："+myData.num);
                //休眠
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //修改数值
                myData.setNum();
                System.out.println("修改后的值："+myData.num);
            }).start();
    
            while (myData.num == 0){
                System.out.println("正在循环");
            }
            System.out.println(Thread.currentThread().getName()+"执行完");
        }
    }
    class MyData{
        int num = 0;
        public synchronized void setNum() {
            num = 123;
        }
    }
    
    运行结果：
    ...
    正在循环
    正在循环
    修改后的值：123
    main执行完

此时会发现在不加volatile的情况下，程序竟然结束了循环！也就是说，主线程在经过了1秒后竟然能够访问子线程中修改后的num值了，而不是之前的死循环。

###### 这又是为什么呢？ ######

通过查看System.out.println(); 这个输出语句的底层源码可见

/**
         * Prints a String and then terminate the line.  This method behaves as
         * though it invokes <code>{@link #print(String)}</code> and then
         * <code>{@link #println()}</code>.
         *
         * @param x  The <code>String</code> to be printed.
         */
        public void println(String x) {
            synchronized (this) {
                print(x);
                newLine();
            }
        }

好家伙，直接在println方法中同步了PrintStream 对象，当我们调用输出方法时，主线程和子线程中的num值得到了同步，使得产生了一种，好像不用volatile也能实现主线程访问子线程修改后的num的感觉。

因此在此得到了解释。