聊聊并发编程的可见性问题

代码

package com.company.base;

/**
 1. @Author: Alan
 2. @Date: 2022/12/4 10:53
 */
public class VisibilityTest {
    private boolean flag = true;
    private int count = 0;

    public void refresh() {
        System.out.println(Thread.currentThread().getName() + "开始执行.....");
        flag = false;
    }

    public void load() {
        System.out.println(Thread.currentThread().getName() + "开始执行.....");
        while (flag) {
            count++;
        }
        System.out.println(Thread.currentThread().getName() + "跳出循环: count=" + count);
    }


    public static void main(String[] args) throws InterruptedException {
        VisibilityTest test = new VisibilityTest();

        // 线程threadA模拟数据加载场景
        Thread threadA = new Thread(() -> test.load(), "threadA");
        threadA.start();

        // 让threadA执行一会儿
        Thread.sleep(1000);
        // 线程threadB通过flag控制threadA的执行时间
        Thread threadB = new Thread(() -> test.refresh(), "threadB");
        threadB.start();

    }
}

结果输出

虽然线程B已经将flag修改为了false，但是threadA仍然一直处于执行状态。

JMM内存模型分析

ThreadA

大致的执行流程：

1. threadA首先执行，其从主内存中通过read/load指令将flag读入本地内存中，此时flag=true。
2. CPU core1负责执行while(flag)等代码，当其使用到flag时，便会到本地内存中使用use指令进行加载
3. 从本地内存中加载到的flag=true，因此CPU会一直执行循环体。即使是后续线程ThreadB对flag进行了，其也无法探测到。除非使用一些“手段”。

ThreadB

大致的执行流程

1. threadB首先执行，其从主内存中通过read/load指令将flag读入本地内存中，此时flag=true。
2. CPU core2负责执行flag = false等代码，当其使用到flag时，便会到本地内存中使用use指令进行加载
3. CPU core2执行完毕后，flag=false，此时通过assign指令将最新值回写到其本地内存中（这个过程有一定的时间延迟，并不是立即写回），原先的旧值flag=true会被覆盖
4. 通过store/write执行将最新的flag写入到主内存中，此时flag=false。完成以上步骤后，threadB也不会通知到threadA重新读取工作内存中被修改过的flag。

通过以上的分析。我们大致清楚了为什么flag已经被修改为了false，ThreadA中的循环体依旧没有跳出循环。原因就是flag变量是一个共享变量，ThreadA/ThreadB在对其使用时会首先加载到各自的工作内存中，ThreadB将flag修改完后将其刷新到内存的操作，对于ThreadA来说是不可见的，即虽然主内存中的flag已经发生了改变，但是ThreadA依旧会读取工作内存中flag进行操作。

上述就是Java并发编程中可见性问题的原因，其核心是线程工作内存中的数据没有淘汰，因此一直CPU始终加载到一个旧数据，要是能有方法使得线程从主内存中读取数据，对工作内存中的数据进行淘汰，那么可见性问题也就得以解决啦。

如何解决可见性问题

使用volatile关键字

volatile关键字的底层汇编指令会调用一个lock前缀指令。lock前缀指令能够保证对工作的内存的写入必须写回内存，同时让其他线程工作内存中的变量副本失效，从而强制从主内存读取变量。

package com.company.base;

/**
 * @Author: Alan
 * @Date: 2022/12/4 10:53
 */
public class VisibilityTest {
    private volatile boolean flag = true;
    private int count = 0;

    public void refresh() {
        System.out.println(Thread.currentThread().getName() + "开始执行.....");
        flag = false;
        System.out.println(Thread.currentThread().getName() + "将flag从true修改为false");
    }

    public void load() {
        System.out.println(Thread.currentThread().getName() + "开始执行.....");
        while (flag) {
            count++;
        }
        System.out.println(Thread.currentThread().getName() + "跳出循环: count=" + count);
    }


    public static void main(String[] args) throws InterruptedException {
        VisibilityTest test = new VisibilityTest();

        // 线程threadA模拟数据加载场景
        Thread threadA = new Thread(() -> test.load(), "threadA");
        threadA.start();

        // 让threadA执行一会儿
        Thread.sleep(1000);
        // 线程threadB通过flag控制threadA的执行时间
        Thread threadB = new Thread(() -> test.refresh(), "threadB");
        threadB.start();
    }
}

结果输出

使用synchronized

底层也是和volatile类似，调用了依靠lock前缀指令实现的内存屏障（OpenJDK，x86下）。

public void load() {
        System.out.println(Thread.currentThread().getName() + "开始执行.....");
        while (flag) {
            synchronized (this){
                count++;
            }
        }
        System.out.println(Thread.currentThread().getName() + "跳出循环: count=" + count);
    }

使用ReentrantLock

底层也是和volatile类似，调用了依靠lock前缀指令实现的内存屏障（OpenJDK，x86下）。

public void load() {
        System.out.println(Thread.currentThread().getName() + "开始执行.....");
        while (flag) {
            ReentrantLock lock=new ReentrantLock();
            lock.lock();
            try {
                count++;
            }
            finally {
                lock.unlock();
            }
        }
        System.out.println(Thread.currentThread().getName() + "跳出循环: count=" + count);
    }