浅析 JAVA 中堆内存与栈内存的区别

Java 把内存划分成两种：一种是栈内存，一种是堆内存。

一、栈内存

存放基本类型的变量，对象的引用和方法调用，遵循先入后出的原则。
栈内存在函数中定义的 “一些基本类型的变量和对象的引用变量” 都在函数的栈内存中分配。当在一段代码块定义一个变量时，Java 就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java 会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。
Java 中的代码是在函数体中执行的，每个函数主体都会被放在栈内存中，比如 main 函数。假如 main 函数里调用了其他的函数，比如 add（），那么在栈里面的的存储就是最底层是 main，mian 上面是 add。栈的运行时后入先出的，所以会执行时会先销毁 add，再销毁 main。
栈的优势是，栈内存与堆内存相比是非常小的，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（int, short, long, byte, float, double, boolean, char）和对象句柄。栈有一个很重要的特殊性，就是存在栈中的数据可以共享。

二、堆内存

存放所有 new 出来的对象和数组
特此强调，堆内存和数据结构中的堆完全是两码事，分配方式倒是类似于链表
堆内存是区别于栈区、全局数据区和代码区的另一个内存区域。堆允许程序在运行时动态地申请某个大小的内存空间，堆内存实际上指的就是（满足堆内存性质的）优先队列的一种数据结构，第 1 个元素有最高的优先权。
在堆内存分配时首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的 delete 语句才能正确的释放本内存空间。
另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。堆内存是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆内存的大小受限于计算机系统中有效的虚拟内存。由此可见，堆内存获得的空间比较灵活，也比较大。堆内存是由 new 分配的内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便。
栈与堆都是 Java 用来在 Ram 中存放数据的地方。与 C ++ 不同，Java 自动管理栈和堆，程序员不能直接设置栈或堆 Java 的堆是一个运行时数据区，类的（对象从中分配空间。这些对象通过新的，newarray，anewarray 和 multianewarray 等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java 的的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。

三、其他数据存储

1、常量池：存放基本类型常量和字符串常量（public static final）
2、静态域：存放静态成员 (static 定义的)
3、非 RAM 存储：硬盘等永久存储空间
堆内存和栈内存的区别：
1、应用程序所有的部分都使用堆内存，然后栈内存通过一个线程运行来使用。
2、不论对象什么时候创建，他都会存储在堆内存中，栈内存包含它的引用。栈内存只包含原始值变量好和堆中对象变量的引用。
3、存储在堆中的对象是全局可以被访问的，然而栈内存不能被其他线程所访问。
4、栈中的内存管理使用 LIFO 的方式完成，而堆内存的管理要更复杂了，因为它是全局被访问的。
5、栈内存是生命周期很短的，然而堆内存的生命周期从程序的运行开始到运行结束。
6、我们可以使用 - Xms 和 - Xmx JVM 选项定义开始的大小和堆内存的最大值，我们可以使用 - Xss 定义栈的大小
7、当栈内存满的时候，Java 抛出 java.lang.StackOverFlowError 异常而堆内存满的时候抛出 java.lang.OutOfMemoryError: Java Heap Space 错误
8、和堆内存比，栈内存要小的多，因为明确使用了内存分配规则（LIFO），和堆内存相比栈内存非常快。
总结：
1 栈：为编译器自动分配和释放，如函数参数、局部变量、临时变量等等
2 堆：为成员分配和释放，由程序员自己申请、自己释放。否则发生内存泄露。典型为使用 new 申请的堆内容。
除了这两部分，还有一部分是：
3 静态存储区：内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。它主要存放静态数据、全局数据和常量。

Java 中的堆内存与栈内存，你 Get 到了吗？
Java 中的堆和栈
学 Java 的朋友应该都知道，在 Java 中把「内存」划分成两种：一种是「栈内存」，一种是「堆内存」。

我们平时在函数中定义的一些「基本类型的变量」和「对象的引用变量」都是在函数的「栈内存」中分配的。当我们在一段「代码块」中定义一个变量时，Java 就会在栈中为这个变量分配「内存空间」，当超过变量的作用域后，Java 会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。

而「堆内存」用来存放「由 new 创建的对象」和「数组」。在堆中分配的内存，由「Java 虚拟机的自动垃圾回收器」来管理。当在堆中产生了一个数组或对象后，我们还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的「首地址」，栈中的这个变量就成了数组或对象的「引用变量」。

❝
「引用变量」其实就相当于是为数组或对象起的一个名称，以后我们就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。
❞
❝
「引用变量」就是普通的变量，定义的时候是在栈中分配，引用变量在程序运行到其作用域之外后被释放。而数组和对象本身是在堆中分配的，即使是程序运行到使用 new 产生数组或者对象的语句所在的代码块之外，所创建的数组和对象本身占据的内存不会被释放，「数组和对象在没有引用变量指向它的时候，才变为垃圾」，不能在被使用，但仍然占据内存空间不放，在随后的一个不确定的时间被垃圾回收器收走 (释放掉)。
❞

❝
这也是 Java 比较占内存的原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针！
❞
「具体的说」：

栈与堆都是 Java 用来在「Ram」中存放数据的地方。与 C++ 不同的是，在 Java 中会自动管理栈和堆，程序员不能直接地设置栈或堆。

Java 的堆是一个「运行时数据区」, 类的对象从中分配空间。这些对象通过 new、newarray、anewarray 和 multianewarray 等指令建立，它们不需要程序代码来「显式」的释放。堆是由垃圾回收来负责的，堆的「优势」是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java 的垃圾收集器会自动收走这些不再使用的数据。但「缺点」是，由于要在运行时动态分配内存，所以存取的速度比较慢。

栈的「优势」是，存取速度比堆要快，仅次于「寄存器」，栈数据可以「共享」。但「缺点」是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量 (int, short, long, byte, float, double, boolean, char) 和对象句柄 (对象变量)。

下图是我根据自己的理解画的内存图，可做参考：

举个例子
栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义：

int a = 10;
int b = 10；
编译器会先处理 int a = 10；首先它会在栈中创建一个变量为 a 的引用，然后查找常量池中是否有 10 这个值，如果没找到，就将 10 存放进来，然后将 a 指向 10。接着处理 int b = 10；在创建完 b 的引用变量后，因为在常量池中已经有 10 这个值，便将 b 直接指向 10。这样，就出现了 a 与 b 同时均指向 10 的情况。这时，如果再令 a=11；那么编译器会重新搜索常量池中是否有 11 值，如果没有，则将 11 存放进来，并令 a 指向 11；如果已经有了，则直接将 a 指向这个地址。因此 a 值的改变不会影响到 b 的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况 a 的修改并不会影响到 b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量。

java 中内存分配策略
按照「编译原理」的观点，程序运行时的内存分配有三种策略，分别是「静态的」、「栈式的」、和「堆式的」。

「静态存储分配」是指在编译时就能确定每个数据目标在运行时刻的存储空间需求，因而在编译时就可以给他们分配固定的内存空间。这种分配策略要求程序代码中不允许有可变数据结构 (比如可变数组) 的存在，也不允许有嵌套或者递归的结构出现，因为它们都会导致编译程序无法计算准确的存储空间需求。

「栈式存储分配」也可称为动态存储分配，是由一个类似于堆栈的运行栈来实现的。和静态存储分配相反，在栈式存储方案中，程序对数据区的需求在编译时是完全未知的，只有到运行的时候才能够知道，但是规定在运行中进入一个程序模块时，必须知道该程序模块所需的数据区大小才能够为其分配内存。和我们在数据结构所熟知的栈一样，栈式存储分配按照先进后出的原则进行分配。

「静态存储分配」要求在编译时能知道所有变量的存储要求，栈式存储分配要求在过程的入口处必须知道所有的存储要求，而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配，比如可变长度串和对象实例。堆由大片的可利用块或空闲块组成，堆中的内存可以按照任意顺序分配和释放。

堆和栈的比较
上面的定义从编译原理的教材中总结而来，除静态存储分配之外，都显得很呆板和难以理解，下面撇开静态存储分配，集中比较堆和栈:

从堆和栈的功能和作用来通俗的比较，堆主要用来存放对象的，栈主要是用来执行程序的。而这种不同又主要是由于堆和栈的特点决定的:

在编程中，例如 C/C++ 中，所有的方法调用都是通过栈来进行的，所有的局部变量，形式参数都是从栈中分配内存空间的。实际上也不是什么分配，只是从栈顶向上用就行，就好像工厂中的传送带 (conveyor belt) 一样，Stack Pointer 会自动指引你到放东西的位置，你所要做的只是把东西放下来就行。退出函数的时候，修改栈指针就可以把栈中的内容销毁。这样的模式速度最快，当然要用来运行程序了。需要注意的是，在分配的时候，比如为一个即将要调用的程序模块分配数据区时，应事先知道这个数据区的大小，也就说是虽然分配是在程序运行时进行的，但是分配的大小多少是确定的，不变的，而这个 “大小多少” 是在编译时确定的，不是在运行时。

堆是应用程序在运行的时候请求操作系统分配给自己内存，由于从操作系统管理的内存分配，所以在分配和销毁时都要占用时间，因此用堆的效率非常低。但是堆的优点在于，编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间，因此，用堆保存数据时会得到更大的灵活性。事实上，面向对象的多态性，堆内存分配是必不可少的，因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定。在 C++ 中，要求创建一个对象时，只需用 new 命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存。当然，为达到这种灵活性，必然会付出一定的代价：在堆里分配存储空间时会花掉更长的时间！这也正是导致我们刚才所说的效率低的原因，看来列宁同志说的好，人的优点往往也是人的缺点，人的缺点往往也是人的优点。

JVM 中的堆和栈
JVM 是基于堆栈的虚拟机。JVM 为每个新创建的线程都分配一个堆栈。也就是说，对于一个 Java 程序来说，它的运行就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM 对堆栈只进行两种操作：以帧为单位的压栈和出栈操作。

我们知道，某个线程正在执行的方法称为此线程的当前方法。我们可能不知道，当前方法使用的帧称为当前帧。当线程激活一个 Java 方法，JVM 就会在线程的 Java 堆栈里新压入一个帧。这个帧自然成为了当前帧。在此方法执行期间，这个帧将用来保存参数，局部变量，中间计算过程和其他数据。这个帧在这里和编译原理中的活动纪录的概念是差不多的。

从 Java 的这种分配机制来看，堆栈又可以这样理解：堆栈 (Stack) 是操作系统在建立某个进程时或者线程 (在支持多线程的操作系统中是线程) 为这个线程建立的存储区域，该区域具有先进后出的特性。

每一个 Java 应用都唯一对应一个 JVM 实例，每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中，并由应用所有的线程共享。跟 C/C++ 不同，Java 中分配堆内存是自动初始化的。Java 中所有对象的存储空间都是在堆中分配的，但是这个对象的引用却是在堆栈中分配，也就是说在建立一个对象时从两个地方都分配内存，在堆中分配的内存实际建立这个对象，而在堆栈中分配的内存只是一个指向这个堆对象的指针 (引用) 而已。