1.8版本 最清晰理解Java内存区域划分
从Java的各种基本数据类型看Java内存区域划分
- 写在前面
- 一、各种基本数据类型的存储
- 二、Java内存区域的划分（运行时数据区）
- 2.1 程序计数器（Program Counter）：
- 2.2 Java虚拟机栈（Stack）
- 拓展：方法/函数如何调用？
- 2.3 Java本地方法栈（Native Method Stack）
- 2.4 堆（Heap）
- 2.5 方法区（Method Area/Non-Heap)
- 2.5.1 ==方法区和永久代的关系==
- 2.5.2 常用参数
- 2.5.3 ==为什么要将永久代 (PermGen) 替换为元空间 (MetaSpace) 呢?==
- 2.6 运行时常量池
- 拓展：字符串常量池和运行时常量池什么关系？
- 2.7 直接内存
- 三、补充内容*
- 3.1 String 对象的两种创建方式：
- 3.2 String 类型的常量池比较特殊。
- 3.3 String 字符串拼接
- 3.4 String s1 = new String("abc");这句话创建了几个字符串对象？
- 3.5 八种基本数据类型，基本类型的包装类和常量池
- 四、总结
写在前面
在正式开始文章的阅读之前，我们还要区分几个概念，这很重要：（很多博客对Java内存模型，Java内存区域结构混一谈，丝毫不加辨析，以至于很多时候看完之后还是云里雾里）
- Java内存模型：JMM与多线程相关，看起来和Java内存区域很相似，但JMM是一个抽象的概念，不是具体存在的。JMM描述了一组规则或规范，这个规范定义了一个线程对共享变量的操作对其他线程是可见的。
- Java内存区域|Java内存结构：Java内存结构是JVM的运行时，虚拟机在执行Java程序时会内存区域划分为若干个不同的内存区域，这些区域各自都有自己的作用。只是不同的JVM虚拟机对区域的划分稍有不同，但都遵循下面第二节所规定的规范。
一、各种基本数据类型的存储
我们先来看一段小代码：
public class{
int a = 20;
public static void main（String[] args){
int b = 10;
String str1 = ”abc“;
String str2 = new String("abc");
}
}
我们先初步分析一下着三个变量的存储过程：
int 声明的都是8中基本数据类型中的一种。
- int a 是一个类的成员变量，成员变量的生命周期是和类在一起的，类下的每一个方法对于成员变量的值都是共享的，也就是成员变量需要多个方法都可以进行访问。
- int b 是main里面的一个局部变量，他的生命周期随着方法的结束而结束。
- String str1和String str2的两种声明方式相同吗？ 答案是否定的，我们先阐述结果，然后带着疑问继续看后面的分析。
首先str1和str2的内容是存储在stack（栈）中的，他们是分别指向自己应当指向的内存区域（可能是栈中，也可能是堆中）
str1是一个String类型的内容，"abc"在编译时被放入静态常量池（也就是class常量池）中，运行时被拿到运行时常量池中的字符串常量池，然后由str1指向"abc"的区域。
str2的 new String(“abc”)是存储在内存区域中的堆中的，这个new的过程是在运行期初始化阶段才确定的，然后Stack上的str2指向heap（堆）上的new String(“abc”)。
因为他们是指向的不同的内存区域，System.out.println(str1 == str2); 的结果也自然就是false了。
二、Java内存区域的划分（运行时数据区）
Java 虚拟机在执行 Java 程序的过程中会把它管理的内存划分成若干个不同的数据区域。
1.8之前：
1.8之后：
我们可以把它们分为两个类型的区域，一种是线程私有的，另一种是线程共享的。
- 线程共享的区域：
- 堆（Heap）
- 方法区（Method Area）
- 线程私有：
- 程序计数器（PC)
- 虚拟机栈（VM Stack）
- 本地方法栈（Native Method Stack）
2.1 程序计数器（Program Counter）：
可以看作是当前线程所执行的字节码的行号指示器，他标记着我们当前执行到了哪一条指令。类比我们计算机组成中的PC计数器，他实现着我们代码的控制流程。
在多线程的情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切换回来的时候能够知道该线程上次运行到哪儿了。
2.2 Java虚拟机栈（Stack）
与程序计数器一样，Java虚拟机栈也是线程私有的，它的生命周期和线程相同，描述的是 Java 方法执行的内存模型，每次方法调用的数据都是通过栈传递的。
Java 内存可以粗糙的区分为堆内存（Heap）和栈内存(Stack),其中栈就是现在说的虚拟机栈，或者说是虚拟机栈中局部变量表部分。 （实际上，Java虚拟机栈是由一个个栈帧组成，而每个栈帧中都拥有：局部变量表、操作数栈、动态链接、方法出口信息。）
局部变量表主要存放了编译器可知的各种数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，它不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是指向一个代表对象的句柄或其他与此对象相关的位置）。
Java 虚拟机栈会出现两种异常：StackOverFlowError 和 OutOfMemoryError。
- StackOverFlowError ：若 Java 虚拟机栈的内存大小不允许动态扩展，那么当线程请求栈的深度超过当前 Java 虚拟机栈的最大深度的时候，就抛出 StackOverFlowError 异常。
程序实现SOF：
public class StackOverFlow {
public int stackSize = 0;
public void stackIncre() {
stackSize++;
stackIncre();
}
public static void main(String[] args) throws Throwable{
StackOverFlow sof = new StackOverFlow();
try {
sof.stackIncre();
} catch (Throwable e) {
System.out.println(sof.stackSize);
throw e;
}
}
}
- OutOfMemery：若 Java 虚拟机栈的内存大小允许动态扩展，且当线程请求栈时内存用完了，无法再动态扩展了，此时抛出 OutOfMemoryError 异常。
程序实现OOM：
public class OutOfMemory {
public static void main(String[] args){
List list=new ArrayList();
for(;;){
int[] tmp=new int[1000000];
list.add(tmp);
}
}
}
Java 虚拟机栈也是线程私有的，每个线程都有各自的 Java 虚拟机栈，而且随着线程的创建而创建，随着线程的死亡而死亡。
拓展：方法/函数如何调用？
Java 栈可用类比数据结构中栈，Java 栈中保存的主要内容是栈帧，每一次函数调用都会有一个对应的栈帧被压入 Java 栈，每一个函数调用结束后，都会有一个栈帧被弹出。
Java 方法有两种返回方式：
- return 语句。
- 抛出异常。
不管哪种返回方式都会导致栈帧被弹出。
2.3 Java本地方法栈（Native Method Stack）
和虚拟机栈所发挥的作用非常相似，区别是： 虚拟机栈为虚拟机执行 Java 方法 （也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务。 在 HotSpot 虚拟机中和 Java 虚拟机栈合二为一。
本地方法被执行的时候，在本地方法栈也会创建一个栈帧，用于存放该本地方法的局部变量表、操作数栈、动态链接、出口信息。
方法执行完毕后相应的栈帧也会出栈并释放内存空间，也会出现 StackOverFlowError 和 OutOfMemoryError 两种异常。
2.4 堆（Heap）
Java 虚拟机所管理的内存中最大的一块，Java 堆是所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例以及数组都在这里分配内存。
Java 堆是垃圾收集器管理的主要区域，因此也被称作GC堆（Garbage Collected Heap）。从垃圾回收的角度，由于现在收集器基本都采用分代垃圾收集算法，所以Java堆还可以细分为：新生代和老年代：在细致一点有：Eden空间、From Survivor、To Survivor空间等。进一步划分的目的是更好地回收内存，或者更快地分配内存。
在 JDK 1.8中移除整个永久代，取而代之的是一个叫元空间（Metaspace）的区域（永久代使用的是JVM的堆内存空间，而元空间使用的是物理内存，直接受到本机的物理内存限制）。
2.5 方法区（Method Area/Non-Heap)
方法区与 Java 堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做 Non-Heap（非堆），目的应该是与 Java 堆区分开来。
HotSpot 虚拟机中方法区也常被称为 “永久代”，本质上两者并不等价。仅仅是因为 HotSpot 虚拟机设计团队用永久代来实现方法区而已，这样 HotSpot 虚拟机的垃圾收集器就可以像管理 Java 堆一样管理这部分内存了。但是这并不是一个好主意，因为这样更容易遇到内存溢出问题。（Java 8之前的实现）
在Java 8版本之前，方法区仅是逻辑上的分区，物理上并没有独立于堆而存在，而是位于永久代中。所以这时候的方法区也是可以被回收的。在Java 8版本之后Hot Spot移除了永久代，使用本地内存来存储类元数据信息，并命名为元空间
2.5.1 方法区和永久代的关系
《Java 虚拟机规范》只是规定了有方法区这么个概念和它的作用，并没有规定如何去实现它。那么，在不同的 JVM 上方法区的实现肯定是不同的了。 方法区和永久代的关系很像 Java 中接口和类的关系，类实现了接口，而永久代就是 HotSpot 虚拟机对虚拟机规范中方法区的一种实现方式。 也就是说，永久代是 HotSpot 的概念，方法区是 Java 虚拟机规范中的定义，是一种规范，而永久代是一种实现，一个是标准一个是实现，其他的虚拟机实现并没有永久带这一说法。
2.5.2 常用参数
JDK 1.8 之前永久代还没被彻底移除的时候通常通过下面这些参数来调节方法区大小
-XX:PermSize=N //方法区 (永久代) 初始大小
-XX:MaxPermSize=N //方法区 (永久代) 最大大小,超过这个值将会抛出 OutOfMemoryError 异常:java.lang.OutOfMemoryError: PermGen
相对而言，垃圾收集行为在这个区域是比较少出现的，但并非数据进入方法区后就“永久存在”了。
JDK 1.8 的时候，方法区（HotSpot 的永久代）被彻底移除了（JDK1.7 就已经开始了），取而代之是元空间，元空间使用的是直接内存。
下面是一些常用参数：
-XX:MetaspaceSize=N //设置 Metaspace 的初始（和最小大小）
-XX:MaxMetaspaceSize=N //设置 Metaspace 的最大大小
与永久代很大的不同就是，如果不指定大小的话，随着更多类的创建，虚拟机会耗尽所有可用的系统内存。
2.5.3 为什么要将永久代 (PermGen) 替换为元空间 (MetaSpace) 呢?
整个永久代有一个 JVM 本身设置固定大小上线，无法进行调整，而元空间使用的是直接内存，受本机可用内存的限制，并且永远不会得到 java.lang.OutOfMemoryError。你可以使用 -XX：MaxMetaspaceSize 标志设置最大元空间大小，默认值为 unlimited，这意味着它只受系统内存的限制。-XX：MetaspaceSize 调整标志定义元空间的初始大小如果未指定此标志，则 Metaspace 将根据运行时的应用程序需求动态地重新调整大小。
2.6 运行时常量池
jdk1.6、1.7、1.8实际上运行时常量池的位置都发生了很大的变化，jdk1.6运行时常量池存在于方法区，jdk1.7移到了堆区，而jdk1.8运行时常量池其实是存在于与方法区和堆区相对独立的元空间，而不是在堆区。
运行时常量池是方法区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述信息外，还有常量池信息（用于存放编译期生成的各种字面量和符号引用）
既然运行时常量池时方法区的一部分，自然受到方法区内存的限制，当常量池无法再申请到内存时会抛出 OutOfMemoryError 异常。
拓展：字符串常量池和运行时常量池什么关系？
- 运行时常量池存在于内存中，也就是class常量池被加载到内存之后的版本，不同之处是：它的字面量可以动态的添加，符号引用可以被解析为直接引用
- JVM在执行某个类的时候，必须经过加载、连接、初始化，而连接又包括验证、准备、解析三个阶段。而当类加载到内存中后，jvm就会将class常量池中的内容存放到运行时常量池中，由此可知，运行时常量池也是每个类都有一个。在解析阶段，会把符号引用替换为直接引用，解析的过程会去查询字符串常量池，也就是我们上面所说的StringTable，以保证运行时常量池所引用的字符串与字符串常量池中是一致的。
除此之外，常量池还有class constant pool
推荐阅读：字符串常量池、class常量池和运行时常量池
2.7 直接内存
直接内存并不是虚拟机运行时数据区的一部分，也不是虚拟机规范中定义的内存区域，但是这部分内存也被频繁地使用。而且也可能导致OutOfMemoryError异常出现。
JDK1.4中新加入的 NIO(New Input/Output) 类，引入了一种基于通道（Channel） 与缓存区（Buffer） 的 I/O 方式，它可以直接使用Native函数库直接分配堆外内存，然后通过一个存储在 Java 堆中的 DirectByteBuffer 对象作为这块内存的引用进行操作。这样就能在一些场景中显著提高性能，因为避免了在 Java 堆和 Native 堆之间来回复制数据。
本机直接内存的分配不会收到 Java 堆的限制，但是，既然是内存就会受到本机总内存大小以及处理器寻址空间的限制。
三、补充内容*
3.1 String 对象的两种创建方式：
就是我们上面（一）中的str1和str2两种创建string类型的方式。第一种方式是在常量池中拿对象，第二种方式是直接在堆内存空间创建一个新的对象
3.2 String 类型的常量池比较特殊。
它的主要使用方法有两种：**
- 用双引号声明出来的 String 对象会直接存储在常量池中。
- 如果不是用双引号声明的 String 对象，可以使用 String 提供的 intern 方String.intern() 是一个 Native 方法，它的作用是：如果运行时常量池中已经包含一个等于此 String 对象内容的字符串，则返回常量池中该字符串的引用；如果没有，则在常量池中创建与此 String 内容相同的字符串，并返回常量池中创建的字符串的引用。
String s1 = new String("计算机");
String s2 = s1.intern();
String s3 = "计算机";
System.out.println(s2);//计算机
System.out.println(s1 == s2);//false，因为一个是堆内存中的String对象一个是常量池中的String对象，
System.out.println(s3 == s2);//true，因为两个都是常量池中的String对
3.3 String 字符串拼接
String str1 = "str";
String str2 = "ing";
String str3 = "str" + "ing";//常量池中的对象
String str4 = str1 + str2; //在堆上创建的新的对象
String str5 = "string";//常量池中的对象
System.out.println(str3 == str4);//false
System.out.println(str3 == str5);//true
System.out.println(str4 == str5);//false
尽量避免多个字符串拼接，因为这样会重新创建对象。如果需要改变字符串的花，可以使用 StringBuilder 或者 StringBuffer。
3.4 String s1 = new String(“abc”);这句话创建了几个字符串对象？
将创建 1 或 2 个字符串。如果池中已存在字符串文字“abc”，则池中只会创建一个字符串“s1”。如果池中没有字符串文字“abc”，那么它将首先在池中创建，然后在堆空间中创建，因此将创建总共 2 个字符串对象。
验证：
String s1 = new String("abc");// 堆内存的地址值
String s2 = "abc";
System.out.println(s1 == s2);// 输出 false,因为一个是堆内存，一个是常量池的内存，故两者是不同的。
System.out.println(s1.equals(s2));// 输出 true
结果：
false
true
3.5 八种基本数据类型，基本类型的包装类和常量池
关于包装类的知识推荐阅读：[Java基础] Java包装类及自动装箱、拆箱
基本数据类型（String不是基本数据类型）的数据保存在stack中，如目录（一）中的b保存在栈中，10也保存在stack中，然后由b指向10
- Java 基本类型的包装类的大部分都实现了常量池技术，即Byte,Short,Integer,Long,Character,Boolean；这5种包装类默认创建了数值[-128，127]的相应类型的缓存数据，但是超出此范围仍然会去创建新的对象。
- 两种浮点数类型的包装类 Float,Double 并没有实现常量池技术
Integer i1 = 33;
Integer i2 = 33;
System.out.println(i1 == i2);// 输出true
Integer i11 = 333;
Integer i22 = 333;
System.out.println(i11 == i22);// 输出false
Double i3 = 1.2;
Double i4 = 1.2;
System.out.println(i3 == i4);// 输出false
Integer缓存源代码
/**
*此方法将始终缓存-128到127（包括端点）范围内的值，并可以缓存此范围之外的其他值。
*/
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
- Integer i1=40；Java 在编译的时候会直接将代码封装成Integer i1=Integer.valueOf(40);，从而使用常量池中的对象。
- Integer i1 = new Integer(40);这种情况下会创建新的对象。
Integer比较更丰富的一个例子:
Integer i1 = 40;
Integer i2 = 40;
Integer i3 = 0;
Integer i4 = new Integer(40);
Integer i5 = new Integer(40);
Integer i6 = new Integer(0);
System.out.println("i1=i2 " + (i1 == i2));
System.out.println("i1=i2+i3 " + (i1 == i2 + i3));
System.out.println("i1=i4 " + (i1 == i4));
System.out.println("i4=i5 " + (i4 == i5));
System.out.println("i4=i5+i6 " + (i4 == i5 + i6));
System.out.println("40=i5+i6 " + (40 == i5 + i6));
运行结果：
i1=i2 true
i1=i2+i3 true
i1=i4 false
i4=i5 false
i4=i5+i6 true
40=i5+i6 true
语句i4 == i5 + i6，因为+这个操作符不适用于Integer对象，首先i5和i6进行自动拆箱操作，进行数值相加，即i4 == 40。然后Integer对象无法与数值进行直接比较，所以i4自动拆箱转为int值40，最终这条语句转为40 == 40进行数值比较。
四、总结
我们平时讨论最多的是stack栈内存和heap堆内存，再次对数据类型在内存中的存储问题来解释一下：
-
在方法中声明的变量，即该变量是局部变量，每当程序调用方法时，系统都会为该方法建立一个方法栈，其所在方法中声明的变量就放在方法栈中，当方法结束系统会释放方法栈，其对应在该方法中声明的变量随着栈的销毁而结束，这就局部变量只能在方法中有效的原因
在方法中声明的变量可以是基本类型的变量，也可以是引用类型的变量。
- 当声明是基本类型的变量的时，其变量名及值（变量名及值是两个概念）是放在JAVA虚拟机栈中
- 当声明的是引用变量时，所声明的变量的reference（该变量实际上是在方法中存储的是内存地址值）是放在JAVA虚拟机的栈中，该变量所指向的对象是放在堆类存中的。
- 在 类中声明 的变量是成员变量，也叫全局变量，放在堆中的（因为全局变量不会随着某个方法执行结束而销毁）。
同样在类中声明的变量即可是基本类型的变量 也可是引用类型的变量
- 当声明的是基本类型的变量其变量名及其值放在堆内存中的
- 引用类型时，其声明的变量仍然会存储一个内存地址值，该内存地址值指向所引用的对象。引用变量名和对应的对象仍然存储在相应的堆中
参考：https://juejin.im/post/5b7d69e4e51d4538ca5730cb#heading-18
http://tangxman.github.io/2015/07/27/the-difference-of-java-string-pool/
https://blog.csdn.net/zm13007310400/article/details/77534349
https://blog.csdn.net/jingjbuer/article/details/46348667