【译】Java内存模型

作者: hmz | 来源:发表于2015-11-08 15:51 被阅读299次

    翻译链接:http://tutorials.jenkov.com/java-concurrency/java-memory-model.html


    内容:

    • Java内存模型

    • 硬件内存架构

    • 使以上两者相互联系的

    • 共享对象的可见性

    • 竞争状态


    Java内存模型指定了JVM如何与计算机内存RAM协作。

    若你想正确地设计并发行为,那必须得好好理解Java的内存模型(以下简称JMM)。JMM指定了各个线程在需要时如何获得其他线程的变量值,又怎样去同步访问这些共享的变量。

    原始的JMM是并不满足需求,因而在Java1.5中JMM被重新修订,并仍在Java8中使用。


    内部JMM

    JVM在为线程栈(thread stacks)和堆(heap)分配内存时使用到了JMM。以下的图表从表现了JMM的逻辑视角:

    每一个在JVM中运行的线程拥有自己的线程栈。线程栈中包含了当前该线程拥有的、能够被调用执行的方法。我将称之为“调用栈”(call stack)。当线程执行这些代码时,该调用栈也会相应地改变。

    线程栈中包含了每个被执行的方法的所有的本地变量(local variable)(所有的方法都在调用栈中)。每个线程只能访问它自己的线程栈。线程创建的本地变量对于其他线程来说是不可见的。即使两个线程在执行相同的代码,这两个线程仍然会在各自的线程栈中创建这段代码中的该本地变量。因此,每一个线程拥有自己版本的每个本地变量。

    所有的原始数据类型(boolean, byte, short, char, int, long, float, double)的本地变量都被存储在线程栈中,因而对于其他线程而言是不可见的。一个线程可能通过传递一份原始数据类型变量的拷贝给另一个线程,但不能共享它们给其他线程。

    堆包含Java应用无论哪个线程创建的对象。它还包括一些原始数据类型(e.g. Byte, Integer, Long etc.)。不管这些对象赋值给本地变量,还是在另一个对象中作为成员变量被创建,它们都将被存储在堆内存中。

    下图表示了调用栈和本地变量是存储在线程栈中,而对象是在堆内存中。

    一个本地变量可能是原始数据类型,在这种情况下它们被存储在线程栈中。

    一个本地变量也可能指向一个对象,这时本地变量仍然存储在线程栈中,该对象也仍在堆内存中。

    一个对象可能包含有本地变量的方法。方法中的变量还是在线程栈中,即使该对象是在堆内存中。

    一个对象的成员变量和该对象一起存储在堆内存中。即使成员变量是原始类型或指向一个对象。

    静态类变量和它的类定义一起存储在堆中。

    堆中的对象可以被所有线程访问,当这些线程中有变量指向它,线程还可以访问对象中的成员变量。若两个线程同时调用同一个对象的同一方法,它们能够访问该对象的成员变量,每个线程将复制各自版本的本地变量。

    以下是图解:

    两个线程都拥有各自的一组线程栈中的成员变量,其中Local Variable2指向了一个堆中的共享对象Object 3.两个线程每个都拥有不同的本地变量指向Object3,两个本地变量都在各自的线程栈中,虽然它们指向了堆中的同一个对象。

    注意共享对象Object3 同时被成员变量Object2和Object4指向,因此两个线程还能访问Object2和Object4。

    这张图表还展示了一个本地对象指向堆中的两个不同的对象。在这种情况下了,按理论来说,两个线程都能访问Object1和Object5,只要两个线程都用引用到这两个对象。但是在这张图表中,每个一线程都只有一个引用指向其中一个对象。

    那么,怎样的java代码可以展现上面的内存逻辑图?以下便是一个简单的例子。


    public class MyRunnable implements Runnable() {

    public void run() {

    methodOne();

    }

    public void methodOne() {

    int localVariable1 = 45;

    MySharedObject localVariable2 =

    MySharedObject.sharedInstance;

    //... do more with local variables.

    methodTwo();

    }

    public void methodTwo() {

    Integer localVariable1 = new Integer(99);

    //... do more with local variable.

    }

    }

    public class MySharedObject {

    //static variable pointing to instance of MySharedObject

    public static final MySharedObject sharedInstance =

    new MySharedObject();

    //member variables pointing to two objects on the heap

    public Integer object2 = new Integer(22);

    public Integer object4 = new Integer(44);

    public long member1 = 12345;

    public long member1 = 67890;

    }

    如果两个线程都执行了run()方法,那么上面的图表便是结果表示了。run()方法会调用methodOne(),接着methodOne会调用methosTwo()。methodOne()声明了一个原始数据类型的本地变量(lovalVariable1是int类型)和一个指向了对象的的本地变量localVariable2。

    每一个线程执行methodOne()都会创建一份它们自己的localVariable1和localVariable2在各自的线程栈中。其中两者的localVariable1是完全无关的,只存在于各自的线程栈中。一个线程不能看见另一个线程对它的本地变量做了什么操作。

    每一个线程执行methodOne方法还会创建一份localVariable2的复制,但是这两份复制都最终指向了堆中的同一个对象。这块代码中的localVariable2都指向一个静态变量对象。静态变量在内存中只有一份复制,该复制存储于堆内存中。因此,两个localVariable2都指向同一个MySharedObject实例,并且该实例也是被存储于堆内存中。它和图中的Object3相一致。

    要注意MySharedObject也包含了两个成员变量。成员变量和类对象一起被存储在堆内存中。这两个成员变量都指向了两个Integer对象。这两个Integer对象和图中的Object2和Object4相一致。

    注意methodTwo方法创建了一个名为localVariable1的本地变量。这个成员变量是对Integer对象的对象引用。这个方法使得localVariable1的引用指向一个新的Integer实例。localVariable1的引用会在每个执行methodTwo方法的线程中复制并存储。这两个Integer对象被实例化后会被存储在堆内存中。但是每当这个方法被执行时,一个新的Integer对象就将会被创建。在方法methodTwo中创建的Integer对象对应上图中的Object1和Object5。

    注意MySharedObject类中的long类型成员变量是原始数据类型,因为它们是成员变量,因此仍然会被存储在堆内存中,只有本地变量才会存储在线程栈中。


    硬件内存架构

    为了理解JMM是如何与硬件内存架构合作,理解它也变的非常重要,因为现代硬件内存架构和java内部内存模型是不太一样的。

    以下是简单化的现代计算机硬件架构。

    现代计算机常常有两个或以上的CPU,一些CPU还是多核的。关键是,这样的多CPU硬件特性使得多个线程同时运行成为可能。每一个CPU都可以在任何时刻运行一个线程。这意味着如果你的Java应用是多线程的,每一个CPU都有一个线程同时在运行。

    每一个CPU都包含一组寄存器,它们是CPU内存的基础。CPU在寄存器上进行操作变量的速度远远快于在主存上,这是因为CPU访问寄存器的速度远快于访问主存的速度。

    每一个CPU可能还会有一个CPU缓存层。事实上,大部分现代的CPU都会有一定大小的CPU缓存。CPU访问缓存层的速度大于访问主存,一般而言小于寄存器。一些CPU可能会有还几个级别的缓存(Level 1,Level2),JMM如何与之交互在这里并不是重点,关键是要知道CPU有一个缓存层。

    计算机包含一个主存区(RAM),所有的CPU都可以访问RAM,其大小往往远大于CPU的缓存区。

    通常,当CPU需要访问主存,它会读取一部分的主存内容到CPU缓存,甚至会读取一些缓存到寄存器里,然后再进行操作。当CPU需要把结果送回到主存时,它会把结果流入到缓存,再从缓存流入到主存。当CPU需要在缓存数据的时候,之前在缓存中的数据往往会流回到主存中。缓存在一段时间内流入数据,在另一段时间内流出数据。每一次更新的时候它不需要把整个缓存读或写。通常,缓存更新的只是被称为“缓存线”的小内存块,只是一个或多个的内存线一遍遍被写或被读。


    使两者相联系的桥梁

    根据前面已经说明的,JMM和硬件内存架构是不一样的。硬件内存架构并不区分线程栈和堆。在硬件中,线程栈和堆都在主存中。部分线程栈和堆可能会在CPU缓存中,或者CPU内部的寄存器中。如下图所示。

    当对象和变量存储在计算机的不同存储部位的时候,可能会产生以下两个主要问题:

    1.线程更新共享变量时,变量的可见性。

    2.当读写共享变量时的竞争机制。

    以上问题将会在下几节中解释。

    共享对象的可见性

    如果一个以上的线程共享同一个对象,而该对象又没有适宜地使用volatile声明,或者没有使用同步方法,那么对于其他线程来说这个更新可能是不可见的。

    想象一下刚开始共享对象实在主存中被初始化。CPU1上的一个线程读取这个共享对象到CPU1缓存中,在那里改变了该对象值。只要CPU缓存没有把数据流回到主存中,被改变的共享对象对于其他线程便是不可见的。这种情况下,每一个线程都有一份共享对象的最终值位于它们所在CPU的缓存中。

    下图便展现了上述情况。在左边CPU的一个线程复制了一份共享对象于它的缓存中,并且把它的count变量改变成了2。这个改动对于其他在右边CPU上的线程来说是不可见的,因为count的更新后的数值并没有被流回主存。


    为了解决这种情况,你可以使用

    volatile

    关键字,它可以确保给定的变量可以直接从主存中读取,一旦被更新又能马上回到主存。

    竞争机制

    如果两个或以上的线程共享一个对象,那么会有多个线程更新的共享对象,竞争将会发生。

    如果线程A读取共享对象的变量count到它的缓存中,同时线程B也做了相同的事情,但是在另一个CPU缓存中。A对count进行了一次加1的操作,B也做了如此,那么现在var1已经被增加了两次,在两个不同的CPU缓存中。

    如果这些操作是依次进行的,那么count变量是被增加两次,并且以原值加2 后的数值返回主存。

    但是如果这两次操作是并发且没有合适的同步,那么尽管两个线程都对count进行了增加并返回了主存,那么主存里count的更新后数值还是比原值大1,尽管它被增加过两次。

    下图就是说明了上述的主要意思。

    为了解决这个问题,你可以使用Java的synchronized块。同步块确保任何时间只能有一个线程能够访问给定的代码块。同步块还能保证代码块中的所有变量只能从主存中读取,当线程退出同步块的时候,所有已经更新的变量会流回到主存,无论它们是否被声明volatile

    相关文章

      网友评论

      本文标题:【译】Java内存模型

      本文链接:https://www.haomeiwen.com/subject/gsgchttx.html