juc并发编程02——JMM模型

半旧518

已于 2022-04-12 21:08:47 修改

阅读量820

点赞数

分类专栏： juc 文章标签： java

于 2022-04-11 22:17:15 首次发布

本文链接：https://blog.csdn.net/qq_41708993/article/details/124107879

版权

juc 专栏收录该内容

17 篇文章 3 订阅

订阅专栏

我们在这篇文章中将介绍JMM模型，也就是java内存模型。注意，本文所提到的JMM模型与JVM内存模型属于不同层次的内容。JVM内存模型讲的是物理内存空间的分配，而JMM则强调对于JVM内存模型的抽象。

1.java内存模型

在计算机中，为了解决主内存的速度跟不上处理器速度的问题，我们给每个处理器添加一级或多级高速缓存(如下图)。但是，每个处理器上缓存的数据如何保证一致性呢？
在这里插入图片描述为了实现缓存数据的一致性，我们计算机中使用了缓存一致性协议。java中也有类似的机制来实现多线程的数据模型。

在这里插入图片描述 java的内存模型规定如下：

所有的变量均存在主内存中(这里及后文的变量指所有可能出现竞争的变量：包括成员变量、静态变量，不包括局部变量)
每个线程都有自己的工作内存，线程对变量的操作必须在工作内存中完成。不同线程之间的工作内存相互隔离。

那么这个内存模型在jvm中究竟是如何实现的呢？

主内存：对应堆中的实例对象
工作内存：对应虚拟机栈，虚拟机可能会对这部分内存进行优化，将其放入寄存器或者高速缓存中。

看如下实例。

public class Demo4 {
private static int i = 0;

    public static void main(String[] args) throws InterruptedException {
        new Thread(()-> {
            for(int j = 0; j < 1000000; j++) {
                i++;
            }
            System.out.println("thread1 run pass");
        }).start();

        new Thread(()-> {
            for(int j = 0; j < 1000000; j++) {
                i++;
            }
            System.out.println("thread2 run pass");
        }).start();


        Thread.sleep(1000);

        System.out.println(i);
    }
}

运行结果如下：

thread1 run pass
thread2 run pass
1729677

为什么呢？如果您有jvm的基础，就应该知道，原来自增操作并不是原子操作。可能出现如下图的情况。后面我们将讲解如何解决这个问题。

在这里插入图片描述

2.重排序

在编译或者运行期间，有可能会对指令进行重排序。有以下可能：

java编译器根据对java语义的理解进行重排序。
现代处理器可能会对机器指令自主进行重排序。

在单线程的环境下，指令重排序可以在不改变执行结果的前提下优化代码的执行效率。但是多线程下指令重排序可能会导致一些问题。

public class Demo5 {
    private static int a = 0;
    private static int b = 0;

    public static void main(String[] args) {
        new Thread(() -> {
            if(b == 1) {
                if(a == 0) {
                    System.out.println("A");
                }
                if(a == 1) {
                    System.out.println("B");
                }
            }
        }
        ).start();
        
        new Thread(
                () -> {
                    a = 1;
                    b = 1;
                }
        ).start();
    }

按朴素的理解，上面代码的输出只有可能是"B"或者没有输出。但是上面a，b的赋值可能被重排序.

public class Demo5 {
    private static int a = 0;
    private static int b = 0;

    public static void main(String[] args) {
        new Thread(() -> {
            if(b == 1) {
                if(a == 0) {
                    System.out.println("A");
                }
                if(a == 1) {
                    System.out.println("B");
                }
            }
        }
        ).start();
        
        new Thread(
                () -> {
                    b = 1;
                    a = 1;
                }
        ).start();
    }

因此可能出现结果为"A"的情况。

3.volitile关键字

之前我们说了，线程并不会直接操作主内存的变量，而是操作工作内存中拷贝的变量副本。理解了这一点后，思考下面代码是有限操作还是无限操作。

public class demo6 {
    private static int a = 0;

    public static void main(String[] args) throws InterruptedException {

            new Thread(() -> {
                while(a == 0) {}
                System.out.println( "thread finished");

            }).start();

            Thread.sleep(1000);
            System.out.println("edit var a...");
            a = 1;
        }


}

答案是无限操作，为什么呢？当然因为新建线程中使用的不过是工作缓存中的副本咯。

现在我们把代码稍微修改下。您觉得是有限操作还是无限操作呢？

public class demo6 {
    private static int a = 0;

    public static void main(String[] args) throws InterruptedException {

            new Thread(() -> {
                while (a == 0) {
                    System.out.println( "a = " +  a);
                }

            }).start();

            Thread.sleep(1000);
            System.out.println("edit var a...");
            a = 1;

        }


}

答案是有限操作，不信您可以自己试试看。为什么呢？不妨看看System.out.println()方法的源码。

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

原来使用了synchronized关键字呀，除了保证操作的原子性外，还可以保证可见性.线程加锁时将清空工作内存的变量值,线程解锁前,将会把变量的最新值更新到主内存中,因此，它就可以看到最新的a的值为1，退出程序了。

除了synchronized，我们更多使用volitile关键字来实现可见性。

使用volitile修饰变量a即可。

public class demo6 {
    private static volatile int a = 0;

    public static void main(String[] args) throws InterruptedException {

            new Thread(() -> {
                while (a == 0) {
                }
                System.out.println("thread execute finished...");

            }).start();

            Thread.sleep(1000);
            System.out.println("edit var a...");
            a = 1;
        }


}

volitile修饰变量为什么可以保证可见性呢？与sychoronized加锁会让工作空间变量失效不同，它是通过禁止指令重排序实现的。其底层原理是通过内存屏障实现，它可以保证其修饰的变量在进行读写操作时，之前的指令已经执行完，之后的指令还未执行，即操作volitile修饰变量的语句相对位置不会发生改变。

在这里插入图片描述

4.happens-before原则

前面我们已经了解了指令重排序的优缺点，JVM提出了happens-before(先行发生)原则，确保程序员只要按照原则编程，就能保证并发编程的正确性。

同一个线程内，前面操作happens-before后面的操作。即使可能出现指令重排，但是前面语句对于变量的修改一定对后续操作可见。
对于一个锁的解锁操作，happens-before对于这把锁后续的加锁操作。即前一个线程解锁后，后面线程都能看到该锁对于变量修改的结果，实际上，我们前面的举例就说了，synchorinized关键字在解锁时会把变量更新到主内存中。
volitile变量的写操作happens-before后续对这个变量的读操作。
线程启动原则。线程A启动线程B，在线程B中可以看到线程B启动前线程A的操作。
线程加入原则。线程A执行过程中join线程B，并成功返回。则线程B的操作happens-before线程A。
传递性规则。如果Ahappens-beforeB,Bhappens-beforeC,则Ahappens-beforeC.
上面的原则如果理解了就很容易掌握。基于上述原则，看如下代码。

public class Demo7 {
    private static int a = 0;
    private static int b = 0;

    public static void main(String[] args) {
        a = 10;
        b = a + 1;
        new Thread(() -> {
            if(b > 10) {
                System.out.println(a);
            }
        }
           
        ).start();
    }

}