工作内存刷新时机

工作内存多线程底层原理

Java多线程

发布日期: 2022-05-26

文章字数: 1.3k

阅读时长: 5 分

前言

前一阵子学习多线程时，学到volatile是保证了线程之间的可见性，volatile对应的内存语义为：

1、写一个volatile变量时，将工作内存共享变量刷新到主内存

2、读一个volatile变量时，将工作内存置为无效，从主内存中读取共享变量

对于非volatile变量，如果没有加锁的操作，就不能保证多线程之间是可见的，但是在练习的时候就碰到了如下的一个例子：

例子

话不多说，直接上代码

public class test {
    static boolean flag = true;
    static int x = 0;
    public static void main(String[] args) throws InterruptedException {
        System.out.println("初始值：" + x);
        Thread t1 = new Thread(() -> {
            while(flag){
                x=1;
            }
            System.out.println("更改值：" + x);
        });
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = false;
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("end");
    }
}

这段代码首先是设置了一个共享变量flag，默认为true，线程t1在flag=true的时候执行循环，线程t2会的功能是设置flag=false，本意是使得线程t1可以退出循环，而t2执行的时候sleep一段时间也是保证t1先行与t2运行。运行的结果如下所示：

可以看到，整个程序一直保持运行无法正常结束，由此可以推知t2线程对共享变量的修改t1线程是看不到的，这也符合Java内存模型工作内存和主内存的预期，但是如果我们修改t1循环内的代码后，如下：

public class test {
    static boolean flag = true;
    static int x = 0;
    public static void main(String[] args) throws InterruptedException {
        System.out.println("初始值：" + x);
        Thread t1 = new Thread(() -> {
            while(flag){
                x=1;
                Object[] onums1 = new Object[10000];
                Object[] onums2 = new Object[10000];
                Object[] onums3 = new Object[10000];
                Object[] onums4 = new Object[10000];
            }
            System.out.println("更改值：" + x);
        });
        Thread t2 = new Thread(() -> {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = false;
        });
        t1.start();
        t2.start();
        t2.join();
        t1.join();
        System.out.println("end"); 
    }
}

则再次运行后的结果为：

神奇的是，t1线程并没有一直在循环中，由此可以推知这种情况下t1线程一定是重新从主内存中再次获取到了共享变量，那为什么就增加了创建几个大数组就可以让线程重新去主内存刷新共享变量呢？这就涉及到工作内存的刷新时机

另一个例子

首先我们来看网上有一个更为常见的例子，就是上述循环的代码块里面写一个print语句，类似这样：

while(flag){
    x=1;
    System.out.println("确认更改值：" + x);
}

其余代码不变，最终线程t1也能够感知到flag状态的更改而结束循环，这种情况是因为System.out.println中是存在synchronized锁的，源代码如下：

public void println(String x) {
    if (getClass() == PrintStream.class) {
        writeln(String.valueOf(x));
    } else {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
}