Java并发编程之volatile与JMM多线程内存模型实例分析

一、通过程序看现象

在开始为大家讲解Java 多线程缓存模型之前,我们先看下面的这一段代码。这段代码的逻辑很简单:主线程启动了两个子线程,一个线程1、一个线程2。线程1先执行,sleep睡眠2秒钟之后线程2执行。两个线程使用到了一个共享变量shareFlag,初始值为false。如果shareFlag一直等于false,线程1将一直处于死循环状态,所以我们在线程2中将shareFlag设置为true。

public class VolatileTest {
public static boolean shareFlag = false;

public static void main(String[] args) throws InterruptedException {
new Thread(() ->
{
System.out.print("
开始执行线程1 =>
"
);

while (!shareFlag){ //shareFlag = false则一直死循环
//System.out.println("
shareFlag="
+ shareFlag);

}
System.out.print("
线程1执行完成 =>
"
);

}).start();

Thread.sleep(2000);

new Thread(() ->
{
System.out.print("
开始执行线程2 =>
"
);

shareFlag = true;

System.out.print("
线程2执行完成 =>
"
);

}).start();

}
}

如果你没有学过JMM线程模型,可能你看完上面的代码,希望得到的输出结果是下面这样的:

开始执行线程1 =>
开始执行线程2 =>
线程2执行完成 =>
线程1执行完成=>

Java并发编程之volatile与JMM多线程内存gpt-3.5-turbo实例分析

如下图所示,正常人理解这段代码,首先执行线程1进入循环,线程2修改shareFlag=true,线程1跳出循环。所以跳出循环的线程1会打印"
线程1执行完成=>
"
,但是经过笔者实验,**"
线程1执行完成=>
"
不会被打印,线程1也没有跳出死循环**,这是为什么呢?

二、为什么会产生这种现象(JMM模型)?

要解释上面提到的问题,我们就需要学习JMM(Java Memory Model)Java 内存模型,笔者觉得叫做Java多线程内存模型更准确一些。

  • 首先,在JMM中每个线程有自己的工作内存,在程序启动的时候,线程将共享变量加载(read&
    load)到自己的工作内存中,加载到线程工作内存中的内存变量是主内存中共享变量的副本。也就是说此时shareFlag在内存中有三个副本,值都等于false。

  • 当线程2执行shareFlag=true的时候将其工作内存副本修改为shareFlag=true,同时将副本的值同步写回(store&
    write)到主内存中。

  • 但是线程1的工作内存中的shareFlag=false没有发生变化,所以线程1一直处于死循环之中。

三、MESI 缓存一致性协议

线程2对共享变量的修改不会被线程1感知,这符合上文的实验结果和JMM模型。那怎么样才能让线程1感知到共享变量的值发生了变化呢?其实也很简单,给shareFlag共享变量加上volatile关键字就可以了。

public volatile static boolean shareFlag = false;

其底层原理是这样的,加上volatile关键字提示JMM遵循MESI 缓存一致性协议,该协议包含如下的缓存使用规范(看不懂可以不看,下文会用简单的语言及例子描述一下)。

  • Modified:代表当前Cache行的数据是修改过的(Dirty),并且只在当前CPU的Cache中是修改过的;此时该Cache行的数据与其他Cache中的数据不同,与内存中该行的数据也不同。

  • Exclusive:代表当前Cache行的数据是有效数据,其他CPU的Cache中没有这行数据;并且当前Cache行数据与内存中的数据相同。

  • Shared:代表多个CPU的Cache中都会缓存有这行数据,并且Cache中的数据与内存中的数据一致;

  • Invalid:表示当前Cache行中的数据无效;

  • 上文中的缓存使用规范可能过于复杂,简单的说就是

    • 当线程2修改shareFlag的时候(参考Modify),告知bus总线我修改了共享变量shareFlag,

    • 线程1对Bus总线进行监听,当它获知共享变量shareFlag发生了修改就会将自己工作内存中的shareFlag副本删除使其失效。

    • 当线程1再次需要使用到shareFlag的时候,发现工作内存中没有shareFlag变量副本,就会重新从主内存中加载(read&
      load)



    Java是一种高级编程语言,常用于Web应用程序开发、服务端,以及智能手机等应用程序开发。Java开发需要掌握一定的并发编程技术,涉及到重要的概念volatile和JMM多线程内存。本文将从实例出发,深入剖析Java并发编程之volatile与JMM多线程内存,帮助读者理解并掌握相关技术知识。
    Volatile的概念及应用
    Volatile是Java中一个非常重要的关键字,被用于多线程的共享变量,它可以保证多线程之间对变量的可见性。在多线程场景中,每个线程都有自己的工作内存,而volatile变量可以使每个线程的工作内存都能够及时地更新。因此,当一个线程修改了volatile变量的值时,其他线程能够立即获知。下面通过一个实例来说明volatile的应用。
    class VolatileTest {
    volatile int counter = 0;
    void increase() {
    counter++;
    System.out.println(Thread.currentThread().getName() + \": \" + counter);
    }
    public static void main(String[] args) {
    VolatileTest volatileTest = new VolatileTest();
    for(int i=0; i<10; i++) {
    new Thread(() -> {
    for(int j=0; j<10; j++) {
    volatileTest.increase();
    }
    }).start();
    }
    }
    }
    上面的代码中,我们定义了一个VolatileTest类,其中包含了一个volatile变量counter和一个increase()方法,该方法是一个计数器,并打印每个线程的计数值。通过main()方法创建10个线程,每个线程都调用VolatileTest对象的increase()方法,对counter进行100次自增操作。由于counter是volatile变量,所以能够保证在多线程间的可见性,最终所有线程都会叠加到相同的计数值。执行结果如下:
    Thread-10: 15
    Thread-7: 15
    Thread-2: 15
    Thread-1: 15
    Thread-4: 15
    Thread-0: 15
    Thread-8: 15
    Thread-6: 15
    Thread-5: 15
    Thread-3: 15
    可以看到,每个线程都能看到其他线程对计数器的修改,因此线程间可以正确的共享变量。
    JMM多线程内存模型分析
    在Java多线程编程中,JMM(Java Memory Model)是一个非常重要的概念,它是Java虚拟机用来定义多线程程序中各个线程之间互相访问共享变量的内存模型。JMM提供了一组规则来规定线程之间的无序性,原子性和可见性,保证了线程安全执行。下面通过一个实例来说明操作指令重排序,从而更好地理解JMM的多线程内存模型。
    class JmmTest {
    volatile int x = 0;
    volatile int y = 0;
    volatile int a = 0;
    volatile int b = 0;

    void increase() {
    a = 1;
    x = b;
    }

    void decrease() {
    b = 1;
    y = a;
    }
    public static void main(String[] args) {
    for(int i=0; i<1000000; i++) {
    JmmTest jmmTest = new JmmTest();
    Thread t1 = new Thread(() -> {
    jmmTest.increase();
    });
    Thread t2 = new Thread(() -> {
    jmmTest.decrease();
    });
    t1.start();
    t2.start();

    try {
    t1.join();
    t2.join();
    } catch (InterruptedException e) {
    e.printStackTrace();
    }
    if(jmmTest.x == 0 && jmmTest.y == 0) {
    System.out.println(\"发现指令重排!第\" + i + \"次\");
    }
    }
    }
    }
    JmmTest类中定义了4个volatile变量x、y、a、b,并包含了increase()和decrease()方法,这两个方法分别将x与b的值交换,以及y与a的值交换。在main()方法中,我们通过循环创建100万次线程,并调用increase()和decrease()方法,将两个方法交替执行。同时,我们判断如果发现x和y的值同时为0,则说明JVM对代码进行了指令重排序。执行结果如下:
    发现指令重排!第110522次
    发现指令重排!第115876次
    发现指令重排!第116568次
    ...
    可以看到,每次运行结果都会显示出JVM对代码进行了指令重排序,即使在多线程环境下,也容易出现这种问题,因此合理运用volatile变量和JMM模型,能够从根本上避免并发执行时出现的问题。
    结论
    通过上述两个实例,我们可以看到,在Java编程中,volatile变量以及JMM内存模型的合理使用,可以有效保障多线程中的安全性和正确性。在实际开发中,我们需要合理选择合适的方式来保障并发编程的正确性。最后,Java并发编程之volatile与JMM多线程内存,是重要的技术知识点,需要认真学习研究。