深入理解JVM内存结构

深入理解JVM内存结构（二）

1. JVM 向操作系统申请内存：
   JVM 第一步就是通过配置参数或者默认配置参数向操作系统申请内存空间，根据内存大小找到具体的内存分配表，然后把内存段的起始地址和终止地址分配给 JVM，接下来 JVM 就进行内部分配。
2. JVM 获得内存空间后，会根据配置参数分配堆、栈以及方法区的内存大小
   -Xms30m -Xmx30m -Xss1m -XX:MaxMetaspaceSize=30m
3. 类加载（类加载的细节后续章节会讲）：这里主要是把 class 放入方法区、还有 class 中的静态变量和常量也要放入方法区
4. 执行方法及创建对象：启动 main 线程，执行 main 方法，开始执行第一行代码。此时堆内存中会创建一个 student 对象，对象引用 student 就存放在栈中。后续代码中遇到 new 关键字，会再创建一个 student 对象，对象引用 student 就存放在栈中。
   
   JVM 在操作系统上启动，申请内存，先进行运行时数据区的初始化，然后把类加载到方法区，最后执行方法。
   方法的执行和退出过程在内存上的体现上就是虚拟机栈中栈帧的入栈和出栈。
   同时在方法的执行过程中创建的对象一般情况下都是放在堆中，最后堆中的对象也是需要进行垃圾回收清理的。

堆空间分代划分

堆被划分为新生代和老年代（Tenured），新生代又被进一步划分为 Eden 和 Survivor 区，最后 Survivor 由 From Survivor 和 To Survivor 组成

GC 概念

垃圾回收，在 JVM 中是自动化的垃圾回收机制。 System.gc(),主动发起垃圾回收，项目中切记不要使用。

深入辨析堆和栈

功能
以栈帧的方式存储方法调用的过程，并存储方法调用过程中基本数据类型的变量（int、short、long、byte、float、double、boolean、char 等）以及对象的引用变量，其内存分配在栈上，变量出了作用域就会自动释放；
而堆内存用来存储 Java 中的对象。无论是成员变量，局部变量，还是类变量，它们指向的对象都存储在堆内存中；
线程独享还是共享
栈内存归属于单个线程，每个线程都会有一个栈内存，其存储的变量只能在其所属线程中可见，即栈内存可以理解成线程的私有内存。
堆内存中的对象对所有线程可见。堆内存中的对象可以被所有线程访问。
空间大小
栈的内存要远远小于堆内存

内存溢出

查看GC信息可以使用jvm自带的一些可视化工具，我用的是JHSDB.

1.栈溢出
参数：-Xss1m
HotSpot 版本中栈的大小是固定的，是不支持拓展的。
java.lang.StackOverflowError 一般的方法调用是很难出现的，如果出现了可能会是无限递归。

2.堆溢出
内存溢出：申请内存空间,超出最大堆内存空间。
如果是内存溢出，则通过 调大 -Xms，-Xmx 参数。
如果不是内存泄漏，就是说内存中的对象却是都是必须存活的，那么久应该检查 JVM 的堆参数设置，与机器的内存对比，看是否还有可以调整的空间，再从代码上检查是否存在某些对象生命周期过长、持有状态时间过长、存储结构设计不合理等情况，尽量减少程序运行时的内存消耗。内存泄漏是指分配出去的内存回收不回来，会导致oom。

package ex2.oom;


/**
 * @author  
 * VM Args：-Xms30m -Xmx30m -XX:+PrintGCDetails
 * 堆内存溢出（直接溢出）
 */
public class HeapOom {
     
   public static void main(String[] args)
   {
     
       String[] strings = new String[35*1000*1000];  //35m的数组（堆）
   }
}

**3.方法区溢出**
（1 ） 运行时常量池溢出
（2 ）方法区中保存的 Class 对象没有被及时回收掉或者 Class 信息占用的内存超过了我们配置。
 注意 Class 要被回收，条件比较苛刻（仅仅是可以，不代表必然，因为还有一些参数可以进行控制）：
1、该类所有的实例都已经被回收，也就是堆中不存在该类的任何实例。
2、 加载该类的 ClassLoader 已经被回收。
3、 该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

```java
package ex2.oom;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * 方法区导致的内存溢出
 * VM Args: -XX:MetaspaceSize=10M -XX:MaxMetaspaceSize=10M
 * */
public class MethodAreaOutOfMemory {

    public static void main(String[] args) {
        while (true) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(TestObject.class);
            enhancer.setUseCache(false);
            enhancer.setCallback(new MethodInterceptor() {
                public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
                    return arg3.invokeSuper(arg0, arg2);
                }
            });
            enhancer.create();
        }
    }

    public static class TestObject {
        private double a = 34.53;
        private Integer b = 9999999;
    }
}

4.本机直接内存溢出
直接内存的容量可以通过 MaxDirectMemorySize 来设置（默认与堆内存最大值一样），所以也会出现 OOM 异常；
由直接内存导致的内存溢出，一个比较明显的特征是在 HeapDump 文件中不会看见有什么明显的异常情况，如果发生了 OOM，同时 Dump 文件很小，可以考虑重点排查下直接内存方面的原因。

字面量 ：给基本类型变量赋值的方式就叫做字面量或者字面值。
比如：String a=“b” ，这里“b”就是字符串字面量，同样类推还有整数字面值、浮点类型字面量、字符字面量。
符号引用 ：符号引用以一组符号来描述所引用的目标。符号引用可以是任何形式的字面量，JAVA 在编译的时候一个每个 java 类都会被编译成一个 class文件，但在编译的时候虚拟机并不知道所引用类的地址(实际地址)，就用符号引用来代替，而在类的解析阶段（后续 JVM 类加载会具体讲到）就是为了把这个符号引用转化成为真正的地址的阶段。
一个 java 类（假设为 People 类）被编译成一个 class 文件时，如果 People 类引用了 Tool 类，但是在编译时 People 类并不知道引用类的实际内存地址，因此只能使用符号引用（org.simple.Tool）来代替。而在类装载器装载 People 类时，此时可以通过虚拟机获取 Tool 类的实际内存地址，因此便可以既将符号org.simple.Tool 替换为 Tool 类的实际内存地址。
运行时常量池
运行时常量池（Runtime Constant Pool）是每一个类或接口的常量池（Constant_Pool）的运行时表示形式，它包括了若干种不同的常量：
从编译期可知的数值字面量到必须运行期解析后才能获得的方法或字段引用。运行时常量池是在类加载完成之后，将 Class 常量池中的符号引用值转存到运行时常量池中，类在解析之后，将符号引用替换成直接引用。运行时常量池在 JDK1.7 版本之后，就移到堆内存中了，这里指的是物理空间，而逻辑上还是属于方法区（方法区是逻辑分区）。在 JDK1.8 中，使用元空间代替永久代来实现方法区，但是方法区并没有改变，变动的只是方法区中内容的物理存放位置，但是运行时常量池和字符串常量池被移动到了堆中。但是不论它们物理上如何存放，逻辑上还是属于方法区的。
字符串常量池
字符串常量池这个概念是最有争议的，所以与运行时常量池的关系不去抬杠，我们从它的作用和 JVM 设计它用于解决什么问题的点来分析它。以 JDK1.8 为例，字符串常量池是存放在堆中，并且与 java.lang.String 类有很大关系。设计这块内存区域的原因在于：String 对象作为 Java 语言中重要的数据类型，是内存中占据空间最大的一个对象。高效地使用字符串，可以提升系统的整体性能。所以要彻底弄懂，我们的重心其实在于深入理解 String。

通过String类进行分析
String 对象的不可变性：
在实现代码中 String 类被 final 关键字修饰了，而且变量 char 数组也被 final 修饰了。
我们知道类被 final 修饰代表该类不可继承，而 char[]被 final+private 修饰，代表了 String 对象不可被更改。Java 实现的这个特性叫作 String 对象的不可变性，即 String 对象一旦创建成功，就不能再对它进行改变。

Java 这样做的好处在哪里呢？
第一， 保证 String 对象的安全性。假设 String 对象是可变的，那么 String 对象将可能被恶意修改。
第二， 保证 hash 属性值不会频繁变更，确保了唯一性，使得类似 HashMap 容器才能实现相应的 key-value 缓存功能。
第三， 可以实现字符串常量池。在 Java 中，通常有两种创建字符串对象的方式，一种是通过字符串常量的方式创建，如 String str=“abc”；另一种是字符串变量通过 new 形式的创建，如 String str = new String(“abc”)。

1 、String str= “abc ” ；
当代码中使用这种方式创建字符串对象时，JVM 首先会检查该对象是否在字符串常量池中，如果在，就返回该对象引用，否则新的字符串将在常量池中
被创建。这种方式可以减少同一个值的字符串对象的重复创建，节约内存。（str 只是一个引用）

2.String str = new String( “abc ”)
首先在编译类文件时，"abc"常量字符串将会放入到常量结构中，在类加载时，“abc"将会在常量池中创建；其次，在调用 new 时，JVM 命令将会调用 String的构造函数，同时引用常量池中的"abc” 字符串，在堆内存中创建一个 String 对象；最后，str 将引用 String 对象。

3、 使用 new，对象会创建在堆中，同时赋值的话，会在常量池中创建一个字符串对象，复制到堆中。
具体的复制过程是先将常量池中的字符串压入栈中，在使用 String 的构造方法是，会拿到栈中的字符串作为构方法的参数。
这个构造函数是一个 char 数组的赋值过程，而不是 new 出来的，所以是引用了常量池中的字符串对象。存在引用关系。

public class Location {
     
    private String city;
    private String region;
    public String getCity() {
     
        return city;
    }

    public void setCity(String city) {
     
        this.city = city;
    }

    public String getRegion() {
     
        return region;
    }

    public void setRegion(String region) {
     
        this.region = region;
    }

   
    public void mode3(){
     
        Location location = new Location();
        location.setCity("深圳");
        location.setRegion("南山");
    }
     public static void main(String[] args) {
     
         mode3()
    }

4 、String str2= “ab”+ “cd”+ “ef”;
分析代码可知：首先会生成 ab 对象，再生成 abcd 对象，最后生成 abcdef 对象，从理论上来说，这段代码是低效的。
编译器自动优化了这行代码， 编译后的代码，你会发现编译器自动优化了这行代码，如下
String str= “abcdef”;

.5、大循环使用+

 public void mode5(){
     
//        String str = "abcdef";
//        for(int i=0; i<1000; i++) {
     
//            str = str + i;
//        }
        //优化
        String str = "abcdef";
        for(int i=0; i<1000; i++) {
     
            str = (new StringBuilder(String.valueOf(str)).append(i).toString());
        }
    }

Intern
String 的 intern 方法，如果常量池中有相同值，就会重复使用该对象，返回对象引用。

  public void mode(){
     
        //去字符串常量池找到是否有等于该字符串的对象，如果有，直接返回对象的引用。
        String a =new String("ling").intern();// new 对象、ling 字符常量池创建
        String b = new String("ling").intern();// b ==a。
        if(a==b) {
     
            System.out.print("a==b");
        }else{
     
            System.out.print("a!=b");
        }
    }

1、new Sting() 会在堆内存中创建一个 a 的 String 对象，king"将会在常量池中创建
2、在调用 intern 方法之后，会去常量池中查找是否有等于该字符串对象的引用，有就返回引用。
3、调用 new Sting() 会在堆内存中创建一个 b 的 String 对象。
4、在调用 intern 方法之后，会去常量池中查找是否有等于该字符串对象的引用，有就返回引用。
所以 a 和 b 引用的是同一个对象。

  public static void main(String[] args) {
     
        String a="qwer";
        String b=new String("qwer");
        String c=b.intern();
        System.out.println(a==b);//false
        System.out.println(b==c);//false
        System.out.println(a==c);//true
//        String str1=new StringBuilder("计算机").append("软件").toString();
//        System.out.println(str1.intern()==str1);//true
//
//        String str2=new StringBuilder("ja").append("va").toString();
//        System.out.println(str2.intern()==str2);//str2分配到堆，引用java字面量，而str2.intern()，已存在字面量在方法区常量池
    }

字面量创建在方法区，new创建在堆上分配指向常量池，
写的不好，仅供参考，哈哈！