翻译链接：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。