堆和栈简单理解

原文：https://blog.csdn.net/pt666/article/details/70876410/

堆（Heap）与栈（Stack）：程序内存布局场景下，堆与栈表示的是两种内存管理方式；                                                                  Java程序在运行时都要开辟空间，任何软件在运行时都要在内存中开辟空间，Java虚拟机运行时也是要开辟空间的。JVM运行时在内存中开辟一片内存区域，启动时在自己的内存区域中进行更细致的划分，因为虚拟机中每一片内存处理的方式都不同，所以要单独进行管理。

      JVM内存的划分有五片：

       1.   程序计数器(CPU寄存器)；

       2.   本地方法栈（本地方法区）；

       3.   方法区（常量池在里面）；

       4.   栈内存；

       5.   堆内存。

栈：①，栈是由操作系统自动分配释放的。②，存储的都是局部变量，栈先加载函数才能进行局部变量的定义，所以方法先进栈，然后再定义变量，变量有自己的作用域，一旦离开作用域，变量就会被释放。栈内存的更新速度很快，因为局部变量的生命周期都很短。

堆：①，堆由程序员分配释放， 若不释放，会被当作垃圾，Java中有垃圾回收机制会不定时自动收取（可能会在程序结束时就会被回收），分配方式倒是类似于链表。②存储的是数组和对象（其实数组就是对象），凡是new建立的都是在堆中，堆中存放的都是实体（对象），实体用于封装数据，而且是封装多个（实体的多个属性），如果一个数据消失，这个实体也没有消失，还可以用，所以堆是不会随时释放的。

栈内存 : 方法调用, 进到栈内存中占有空间运行, 方法运行完毕, 弹出栈内存, 释放空间

堆内存 : 引用数据类型通过new关键字开辟空间, 创建对象, 需要在堆内存中占有空间

方法区(数据共享) : 一个类型对应的.class字节码文件, static静态修饰成员, 字符串常量

（static静态随着类的加载而在方法区中加载，非静态的需要等到创建对象时加载。）

 

 下面我们通过一个图例详细讲一下堆和栈：

例1：

public static void main(String []args) {
		Car c = new Car();
		c.color = "军绿";
		c.num = 4;
		c.run();
		
		Car c1= new Car();
		c1.color = "红";
		c1.num = 8;
		c1.run();
	}

class Car {
	 int num;//轮子
	 String color;//颜色
	 public void run() {
		 System.out.println(color+"颜色的"+num+"个轮子的汽车正在行驶");
	 }
}

我们只看主方法内的，我们来看main()方法的执行流程：

①，将需要操作类型对应的.class字节码文件加载到方法区中,于是带有main方法的先进入方法区（此时我们应该了解，由于Java编译时有类型扫描机制（引导类加载器），于是，会检测到Car类型。） Car.class进入到方法区中, 有一个内存地址

②，main方法作为程序唯一执行入口, 被JVM虚拟机主动调用, main方法进去到栈内存执行

③，new Car()会创建出一个Car类型对象, 需要在堆内存中开辟出一块空间, 记录对象所属类型(Car.class)在方法区中地址, 将类型中所有非静态成员变量加载进入到对象所在堆内存区域中, JVM虚拟机会为每一个成员变量进行默认的赋初值动作

④，将对象内存地址返回到栈内存的变量引用处，即将c在堆中的内存地址返回到栈引用处。

⑤，在栈内存中使用对象, 就相当于在操作堆内存中空间地址中数据

 

例2：static静态修饰成员，以及字符串常量存储在方法区问题：

static修饰成员在加载.class文件的时候，会直接加载到方法区（非静态的是在创建对象时加载）。如果static修饰的是引用类型，使用new之后仍然会在堆空间开辟空间，此是static引用类型存储的是地址。如果static类型存储的是字符串常量，会在方法区常量池开辟空间，存储的依然是地址。

class Student {
    String name;
    int age;
    static String schoolName = "一中";
}

public class TestStudentStatic {
    public static void main(String[] args) {
    Student s = new Student();
    System.out.println(s);
    System.out.println(s.schoolName);// 一中
    s.schoolName = "第一中学";
    System.out.println(s.schoolName);// 第一中学

    Student s1 = new Student();
    System.out.println(s1);
    System.out.println(s1.schoolName);// 第一中学
}
}

不哔哔，上图：

比如主函数里的语句   int [] arr=new int [3];在内存中是怎么被定义的：

      主函数先进栈，在栈中定义一个变量arr,接下来为arr赋值，但是右边不是一个具体值，是一个实体。实体创建在堆里，在堆里首先通过new关键字开辟一个空间，内存在存储数据的时候都是通过地址来体现的，地址是一块连续的二进制，然后给这个实体分配一个内存地址。数组都是有一个索引，数组这个实体在堆内存中产生之后每一个空间都会进行默认的初始化（这是堆内存的特点，未初始化的数据是不能用的，但在堆里是可以用的，因为初始化过了，但是在栈里没有初始化），不同的类型初始化的值不一样。所以堆和栈里就创建了变量和实体：

                                                  

     那么堆和栈是怎么联系起来的呢?

     我们刚刚说过给堆分配了一个地址，把堆的地址赋给arr，arr就通过地址指向了数组。所以arr想操纵数组时，就通过地址，而不是直接把实体都赋给它。这种我们不再叫他基本数据类型，而叫引用数据类型。称为arr引用了堆内存当中的实体。（可以理解为c或c++的指针，Java成长自c++和c++很像，优化了c++）                                                                

     

              如果当int [] arr=null;

              arr不做任何指向，null的作用就是取消引用数据类型的指向。

              当一个实体，没有引用数据类型指向的时候，它在堆内存中不会被释放，而被当做一个垃圾，在不定时的时间内自动回收，因为Java有一个自动回收机制，（而c++没有，需要程序员手动回收，如果不回收就越堆越多，直到撑满内存溢出，所以Java在内存管理上优于c++）。自动回收机制（程序）自动监测堆里是否有垃圾，如果有，就会自动的做垃圾回收的动作，但是什么时候收不一定。

             所以堆与栈的区别很明显：

            1.栈内存存储的是局部变量而堆内存存储的是实体；

            2.栈内存的更新速度要快于堆内存，因为局部变量的生命周期很短；

            3.栈内存存放的变量生命周期一旦结束就会被释放，而堆内存存放的实体会被垃圾回收机制不定时的回收。

 

栈：栈由系统自动分配，速度快，但是程序员无法控制。

堆：堆是有程序员自己分配，速度较慢，容易产生碎片，不过用起来方便。