Java 杂谈程序员

一篇文章读懂JAVA内存管理

2018-05-23  本文已影响0人  似水牛年

1. JVM的概念

JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。而引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。这就是Java的能够“一次编译，到处运行”的原因。

2. JMM的概念

JMM是Java Memory Model（Java内存模型）的缩写。JMM定义了Java 虚拟机(JVM)在计算机内存(RAM)中的工作方式。JVM是整个计算机虚拟模型，所以JMM是隶属于JVM的。Java线程之间的通信由JMM控制，JMM决定一个线程对共享变量的写入何时对另一个线程可见。

如果我们要想深入了解Java并发编程，就要先理解好Java内存模型。Java内存模型定义了多线程之间共享变量的可见性以及如何在需要的时候对共享变量进行同步。

3. 并发编程模型的分类

在并发编程中，我们需要处理两个关键问题：线程之间如何通信及线程之间如何同步。

在命令式编程中，线程之间的通信机制有两种：

3.1 共享内存模型

3.2 消息传递模型

4. Java的并发采用的是共享内存模型

Java线程之间的通信总是隐式进行，整个通信过程对程序员完全透明。如果编写多线程程序的Java程序员不理解隐式进行的线程之间通信的工作机制，很可能会遇到各种奇怪的内存可见性问题。

5. Java内存模型

Java内存模型(简称JMM)定义了线程和主内存之间的抽象关系：

Java内存模型

从上图来看，线程A与线程B之间如要通信的话，必须要经历下面2个步骤：

1. 首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
2. 然后，线程B到主内存中去读取线程A之前已更新过的共享变量。

从整体来看，这两个步骤实质上是线程A在向线程B发送消息，而且这个通信过程必须要经过主内存。JMM通过控制主内存与每个线程的本地内存之间的交互，来为Java程序员提供内存可见性保证。

上面也说到了，Java内存模型只是一个抽象概念，那么它在Java中具体是怎么工作的呢？为了更好的理解Java内存模型工作方式，下面就JVM对Java内存模型的实现、硬件内存模型及它们之间的桥接做详细介绍。

6. Java内存模型在JVM中的实现

关于JVM对Java内存模型的实现，我们从JVM的逻辑视图，硬件架构，CUP指令等多个角度进行解读。

6.1 JVM逻辑视图

在JVM内部，Java内存模型把内存分成了两部分：线程栈区和堆区，下图展示了Java内存模型在JVM中的逻辑视图：


Java内存模型在JVM中的逻辑视图

下图展示了上面描述的过程:


Java内存模型示例

关于栈区和堆区的存储内容，请参考下面的原则：

  1. 一个本地变量如果是原始类型，那么它会被完全存储到栈区
  2. 一个本地变量也有可能是一个对象的引用，这种情况下，这个本地引用会被存储到栈中，但是对象本身仍然存储在堆区
  3. 对于一个对象的成员方法，这些方法中包含本地变量，仍需要存储在栈区，即使它们所属的对象在堆区
  4. 对于一个对象的成员变量，不管它是原始类型还是包装类型，都会被存储到堆区
  5. Static类型的变量以及类本身相关信息都会随着类本身存储在堆区

JVM参数对于内存的设置

6.2 计算机硬件内存架构

不管是什么内存模型，最终还是运行在计算机硬件上的，所以我们有必要了解计算机硬件内存架构，下图就简单描述了当代计算机硬件内存架构：


硬件内存架构

当一个CPU需要访问主存时，会先读取一部分主存数据到CPU缓存，进而在读取CPU缓存到寄存器。

当一个CPU需要写数据到主存时，同样会先flush寄存器到CPU缓存，然后再在某些节点把缓存数据flush到主存。

6.3 Java内存模型和硬件架构之间的桥接

从上面可以看出，Java内存模型和硬件内存架构并不一致。硬件内存架构中并没有区分栈和堆，从硬件上看，不管是栈还是堆，大部分数据都会存到主存中，当然一部分栈和堆的数据也有可能会存到CPU寄存器中，如下图所示，Java内存模型和计算机硬件内存架构是一个交叉关系：


Java内存模型和计算机硬件内存架构的关系

6.4 多线程产生的内存问题

在我们进行多线程编程时，对象和变量存储到计算机的各个内存区域的，这样必然会面临一些问题，其中最主要的两个问题是：

1. 共享对象对各个线程的可见性
2. 共享对象的竞争现象

下面详细我们说一下这两个问题，并了解一下Java的是怎么解决这些问题的

6.4.1 共享对象的可见性

假设我们的共享对象存储在主存，一个CPU中的线程读取主存数据到CPU缓存，然后对共享对象做了更改，但CPU缓存中的更改后的对象还没有flush到主存，此时这个线程对共享对象的更改对其它CPU中的线程是不可见的。最终就是每个线程最终都会拷贝共享对象，而且拷贝的对象位于不同的CPU缓存中。

下图展示了上面描述的过程。左边CPU中运行的线程从主存中拷贝共享对象obj到它的CPU缓存，把对象obj的count变量改为2。但这个变更对运行在右边CPU中的线程不可见，因为这个更改还没有flush到主存中：


共享对象的可见性

要解决共享对象可见性这个问题，我们可以使用Java的volatile关键字。 volatile 关键字可以保证变量会直接从主存读取，而对变量的更新也会直接写到主存。volatile原理 是基于CPU内存屏障指令实现的，后面会讲到。

6.4.2 竞争现象

如果多个线程共享一个对象，如果它们要同时修改这个共享对象，这就产生了竞争现象。

如下图所示，线程A和线程B共享一个对象obj。假设线程A从主存读取Obj.count变量到自己的CPU缓存，同时，线程B也读取了Obj.count变量到它的CPU缓存，并且这两个线程都对Obj.count做了加1操作。此时，Obj.count加1操作被执行了两次，不过都在不同的CPU缓存中。

如果这两个加1操作是串行执行的，那么Obj.count变量便会在原始值上加2，最终主存中的Obj.count的值会是3。然而下图中两个加1操作是并行的，不管是线程A还是线程B先flush计算结果到主存，最终主存中的Obj.count只会增加1次变成2，尽管一共有两次加1操作。


20160921183251870.jpg

要解决上面的问题我们可以使用synchronized代码块。synchronized代码块可以保证同一个时刻只能有一个线程进入代码竞争区，synchronized代码块也能保证代码块中所有变量都将会从主存中读，当线程退出代码块时，对所有变量的更新将会flush到主存，不管这些变量是不是volatile类型的。

volatile和synchronized的区别
  1. volatile本质是在告诉JVM当前变量在寄存器（本地内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
  2. volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
  3. volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
  4. volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
  5. volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化

6.5 JMM深层解析

6.5.1 重排序

重排序通常是编译器或运行时环境为了优化程序性能而采取的对指令进行重新排序执行的一种手段。但是，重排序可能会导致程序执行的结果不是我们需要的结果。重排序分三种类型：

  1. 编译器优化的重排序 编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
  2. 指令级并行的重排序 现代处理器采用了指令级并行技术（Instruction-Level Parallelism， ILP）来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
  3. 内存系统的重排序 由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。

从Java源代码到最终实际执行的指令序列，会分别经历下面三种重排序：


重排序

上述的1属于编译器重排序，2和3属于处理器重排序。这些重排序都可能会导致多线程程序出现内存可见性问题。

6.5.2 Memory Barrier 内存屏障指令

内存屏障，又称内存栅栏，是一个CPU指令，基本上它是一条这样的指令：

1、保证特定操作的执行顺序。
2、影响某些数据（或则是某条指令的执行结果）的内存可见性。

编译器和处理器能够重排序指令，保证最终相同的结果，尝试优化性能。但插入一条Memory Barrier会告诉编译器和处理器：不管什么指令都不能和这条Memory Barrier指令重排序。

Memory Barrier所做的另外一件事是强制刷出各种CPU cache，如一个 Write-Barrier（写入屏障）将刷出所有在 Barrier 之前写入 cache 的数据，因此，任何CPU上的线程都能读取到这些数据的最新版本。

volatile

volatile是基于Memory Barrier实现的。

如果一个变量是volatile修饰的，JMM会在写入这个字段之后插进一个Write-Barrier指令，并在读这个字段之前插入一个Read-Barrier指令。

这意味着，如果写入一个volatile变量a，可以保证：

  1. 一个线程写入变量a后，任何线程访问该变量都会拿到最新值。
  2. 在写入变量a之前的写入操作，其更新的数据对于其他线程也是可见的。因为Memory Barrier会刷出cache中的所有先前的写入。
6.5.3 happens-before

从JDK5开始，Java使用新的JSR -133内存模型。JSR-133使用happens-before的概念来指定两个操作之间的执行顺序。由于这两个操作可以在一个线程之内，也可以是在不同线程之间。因此，JMM可以通过happens-before关系向程序员提供跨线程的内存可见性保证

我们通过代码示例来了解一下什么是 happens-before

double pi = 3.14;　　 // A
double r = 1.0;　　　　 // B
double area = pi * r * r;　 // C

上述计算圆的面积的代码中，存在三个happens-before关系：

  1. A happens-before B
  2. B happens-before C
  3. A happens-before C

在者三个happens-before关系中2和3是必须的，1是不必要的。因此JMM把happens-before要求禁止的重排序分了下面两类：

  1. 会改变程序执行结果的重排序
  2. 不会改变程序执行结果的重排序

JMM对这两种不同性质的重排序，采用了不同的策略，如下：

  1. 对于会改变程序执行结果的重排序，JMM要求编译器和处理器必须禁止这种重排序
  2. 对于不会改变程序执行结果的重排序，JMM对编译器和处理器不做要求，也就是说JMM允许这种重排序

下图是JMM的设计示意图


happens-before

JMM对编译器和处理器的束缚已经尽可能少。从上面的分析可以看出，JMM其实是在遵循一个基本原则：只要不改变程序的执行结果（指的是单线程程序和正确同步的多线程程序），编译器和处理器怎么优化都行。例如，如果编译器经过细致的分析后，认定一个锁只会被单个线程访问，那么这个锁可以被消除。再如，如果编译器经过细致的分析后，认定一个volatile变量只会被单个线程访问，那么编译器可以把这个volatile变量当作一个普通变量来对待。这些优化既不会改变程序的执行结果，又能提高程序的执行效率。

happens-before规则

对于Java程序员来说，happens-before规则简单易懂，它避免程序员为了理解JMM提供的内存可见性保证而去学习复杂的重排序规则以及这些规则的具体实现。

上一篇 下一篇

猜你喜欢

热点阅读