这个标题让我想起来一个哲学问题：从哪里来，到哪里去。

那咱们就通过这个哲学问题谈一谈：一个目标在JVM中阅历了什么？

从哪里来？

我：目标从哪里来？

搭档甲：呃，国家发的？

搭档乙：充话费送的？

咳咳，我说的是JVM的目标

对于咱们程序员来说，没有目标？不存在的！我直接创立一个！

所以这个问题很简略：目标都是创立出来的。

可是这个问题也很难：目标是怎样创立出来的？

这就像咱都知道咱都是咱妈生的，但咱是怎样……？

一个对象在JVM中经历了什么？

那咱们就先来评论一下咱是怎样……？ 目标是怎样创立出来的？

目标创立流程

想要创立目标，首先得找到它的类元信息，所以创立目标的第一步，便是类加载查看。

类加载查看

虚拟机遇到一条加载类指令时，首先将去查看这个指令的参数是否能在常量池中定位到一个类的符号引证，而且查看这个符号引证代表的类是否已被加载、解析和初始化过。假如没有，那必须先履行相应的类加载进程。

有没有一种字都认识，连在一起就不晓得啥意思的感觉？

不要紧，我会出手

什么是加载类指令

常见的加载类指令有：

  • new关键字
  • Class.forName()
  • 初始化子类，父类未初始化时，先初始化父类
  • 虚拟器发动，初始化main()办法的类

加载类指令的参数便是指new User()的User

什么是符号引证？

简略来说，符号引证便是字面量，比方User便是一个符号引证。

具体来说，符号引证以一组符号来描述所引证的目标，符号能够是任何形式的字面量，只要运用时能无歧义地定位到目标即可。

现在再来看类加载的解说，便是当虚拟机遇到new User()时，首先会查看能否在常量池中定位到User, 而且查看User这个类是否被类加载过。

假如没有，那必须先履行相应的类加载进程，那么类加载进程是怎样样的？

咱们先假定类现已加载过了

类加载查看通过之后，下一步就得给目标买房分配内存了。

假如没有通过自然会产生ClassNotFound异常

分配内存

分配内存第一个问题：我怎样知道目标要的房子内存有多大？三室一厅？

目标的结构

要回答这个问题，就必须先要知道目标的内存结构是怎样的？

目标的内存结构由三部分组成

  • 目标头
  • 实例数据
  • 对齐填充
目标头

目标头分为两部分：

  • Mark Word符号字段：符号目标的hashcode,分代年纪等，见下图。

    该部分在32位机器上占4字节，64位占8字节

  • Klass Pointer类型指针：目标指向它的类元数据的指针，虚拟机通过这个指针来确认这个目标是哪个类的实例

    该部分敞开指针紧缩占4字节，不敞开占8字节

一个对象在JVM中经历了什么？

实例数据

实例数据便是目标中的一些变量，根底类型该多大就多大，引证类型占4个字节(封闭指针紧缩占8字节)

如int类型占4个字节，String, User，数组等便是引证类型。

对齐填充

当一个目标的目标头+实例数据所占的内存非8字节的倍数时，就会运用对齐填充的办法补上一些字节，让该目标所需内存达到8字节的倍数。

如该目标:

public static class B {
  //8B mark word 64位机器战8字节
  //4B Klass Pointer   假如封闭紧缩-XX:-UseCompressedClassPointers或-XX:-UseCompressedOops，则占用8B
  int id;        //4B
  String name;   //4B  假如封闭紧缩-XX:-UseCompressedOops，则占用8B
  // 8+4+4+4=20, 所以还需对齐填充4字节。
}

代码：github.com/lzj960515/P…

综上，其实目标所需的内存在类加载之后就现已确认了。

已然现已知道目标所需的内存了，那么又要怎样给目标区分内存呢？

区分内存的办法

区分内存有两种办法：指针磕碰和闲暇列表

指针磕碰(默许)

假如Java堆中内存是肯定规整的，一切用过的内存都放在一边，闲暇的内存放在另一边，中心放着一个指针作为分界点的指示器，那所分配内存就仅仅是把那个指针向闲暇空间那边挪动一段与目标巨细持平的距离。

由目标结构可知，目标的巨细都是8字节的倍数，假定JVM的内存都是一格一格的，每格8字节，现在要为一个16字节的目标分配内存，则指针磕碰的办法能够用下图表明

一个对象在JVM中经历了什么？

闲暇列表

假如Java堆中的内存并不是规整的，已运用的内存和闲暇的内存相互交错，那就没有办法简略地进行指针磕碰了，虚拟机就必须保护一个列表，记录上哪些内存块是可用的，在分配的时候从列表中找到一块足够大的空间区分给目标实例，并更新列表上的记录。

仍然是分配一个16字节的目标，用下图表明

一个对象在JVM中经历了什么？

区分内存的办法有了，可是还有一个问题，事务体系都是多线程运转的，也便是目标内存的分配存在并发问题。

用指针磕碰的办法举例，A目标和B目标一起需求分配内存，很可能指针在分配A目标内存后现已到了新的方位，可是分配B目标时的指针还在原来的方位上，此时再移动指针，就出现了并发问题。

能够类比成多线程履行count++，count会被重复累加的问题。

并发问题的处理办法

处理办法有两种：

  • CAS(compare and swap)：虚拟机选用CAS配上失利重试的办法确保更新操作的原子性来对分配内存空间的动作进行同步处理。

    即：分配目标的内存时，先进行比较指针是否产生变化，未产生变化则进行更改指针的方位，比较和更改这两步操作是原子性的。假如产生变化，则运用新的指针方位，并重试该过程。

  • TLAB(thread local allocation buffer)：这是一种非常值得学习的思维，他的思维是：已然不同的线程分配目标内存是存在抵触，那我是否能够在创立线程时就事前区分好一大块区域，每个线程分配目标内存时只在自己区域里做操作，这样就避免了并发问题。

    这同样能够学习到事务开发中，在Java中，许多Util不是线程安全的, 比方SimpleDateFormat,一个笨办法是每次运用时都新new一个，假如学习了这个思维，那咱们能够做一个Map出来，key为线程id，value为SimpleDateFormat目标实例，这样每个线程都有自己专属的SimpleDateFormat目标，就避免了并发问题。

初始化

内存分配完成后，虚拟机需求将分配到的内存空间都初始化为零值，假如运用TLAB，这一工作进程也能够提早至TLAB分配时进行。

这一步操作确保了目标的实例字段在Java代码中能够不赋初始值就直接运用，程序能访问到这些字段的数据类型所对应的零值。

比方你只写了int a但没赋值，JVM就给他赋个0，当然，你赋值了JVM也会先给他赋个0, 赋你写的值是在后面履行<init>办法。

设置目标头

关于目标头的信息在目标的结构部分现已具体说明

该过程便是给目标头设置一些必要的信息：目标的哈希码、目标的GC分代年纪等，还有类型指针，这样在运用时才干知道这个目标是哪个类的实例。

履行<init>办法

给目标的属性赋值，即程序员赋的值。

以及履行结构办法。

到此，一个目标就算是创立出来了。

到哪里去？

目标从哪里来咱们是知道了，那么目标到哪里去呢？

变为一抔黄土？

没错，目标最终也会嗝屁，目标是怎样嗝屁的？

运转时数据区

关于目标是怎样嗝屁的，那先得知道目标在哪里？

没错，通过目标创立的进程咱们知道了目标需求分配在内存里。

那到底是分配到内存哪里呢？

JVM的组成主要有三部分：类加载子体系、字节码履行引擎、运转时数据区。

目标就在运转时数据区中。

而运转时数据区又分为五个部分，堆、办法区、虚拟机栈、本地办法栈、程序计数器

一个对象在JVM中经历了什么？

堆

存放了几乎一切的目标实例。

元空间

存储每个类的结构，例如运转时常量池，字段和办法数据，以及办法和结构函数的代码，包括用于类和实例初始化和接口初始化的特别办法。

虚拟机栈

跟着线程创立而同步创立的一块内存区域，在每个办法被履行时，都会创立一个栈帧。

栈帧包括：

  • 局部变量表
  • 操作数栈
  • 动态衔接
  • 办法出口

每一个办法调用完毕，就对应着一个栈帧在虚拟机栈从入栈到出栈的进程

程序计数器

存储当时正在履行的字节码指令。

目标在内存中的分配办法

首先，评论这个问题前，咱们必须有一个共识：目标和目标是不一样的。

嗯，我说的是Java里的目标。

有一些目标存活时间长，甚至是应用运转了多长时间，它就存活了多长时间。比方类Class目标，Spring的Bean目标。

有一些目标存活时间短，刚创立就被毁掉，比方事务目标。

针对不同的目标，当然要有不同的分配办法。

目标在栈上分配

是的，目标除了会在堆里，同样也会栈上分配。

先看以下代码：

private void alloc() {
  User user = new User();
  user.name = "a";
  user.age = 10;
}
class User{
  String name;
  int age;
}

请问，user目标什么时候会变成废物目标？

明显, 当alloc办法结束后，user目标就现已变成废物目标了。

所以user跟着alloc办法的退出就现已能够被毁掉了，没有必要比及gc。

别的，咱们也知道，栈帧内的局部变量会跟着栈帧的封闭而毁掉。

所以，能不能把上面的代码改成这样：

private void alloc() {
  String name = "a";
  int age = 10;
}

这样不就能够让name和age跟着栈帧封闭而毁掉了。

没错，以上进程便是目标在栈上分配，该办法依赖于两个方面：

  • 逃逸剖析：剖析一个目标的作用域，是否不被外部办法所引证，只在本办法中运用。

    便是上面评论的user是否能够跟着alloc办法退出而毁掉。

  • 标量替换: 通过逃逸剖析确认一个目标不会被外部访问，JVM就不会创立该目标，而是将该目标成员变量分化若干个被这个办法运用的成员变量所代替。

    便是上面将代码改造的进程。

    标量：不可被进一步分化的量， 如根底数据类型

    聚合量：能够被进一步分化的量， 如目标

目标在Eden区分配

大多数情况下，目标都是在年轻代中Eden区分配。

Eden区内存不够时，则触发YoungGc，将存活的目标放入Survivor区。

大目标直接进入老时代

大目标便是需求大量接连内存空间的目标，关于如何界说大目标能够通过参数-XX:PretenureSizeThreshold=1m指定(这儿设置的是1m)，当目标的巨细超过1m后，会直接进入老时代。

这样设计的原因

因为在事务中，一般大目标都是长时间存活的目标，如大数组，静态变量。对于长时间存活的目标，假如还是像一般目标一样在Eden区和Survivor区重复gc后才进入老时代，这是没有意义且耗费资源的事情，所以应当让这样的目标尽早进入老时代，提升gc功率。

留意，事务目标千万不要做成了大目标，因为它会直接进入老时代，导致频频full gc

长时间存活的目标进入老时代

假如目标每并通过一次Young GC后仍然能够存活，则目标年纪+1，当年纪达到15(默许值)后就会进入老时代。

对于这一点，咱们能够设置合理的阈值。

比方我明确知道事务中目标肯定不会超过3次gc就会被收回，那么反过来说，超过3次gc还没有被收回的目标，便是些能够长时间存活的目标。

长时间存活的目标应该让它尽早进入老时代，所以我稳妥一点，能够设置阈值为5。

流程图

一个对象在JVM中经历了什么？

目标是如何毁掉的？

跟着程序的运转，当一些目标变成了废物目标，就会跟着gc被收回内存。

那JVM要如何判别哪些目标是废物目标呢？

引证计数法

引证计数法是一种非常简略的完成：给目标中添加一个引证计数器，每当有一个地方引证它，计数器就加1；当引证失效，计数器就减1。

任何时候计数器为0的目标便是不可能再被运用的。

当它有一个致命的问题：循环引证。

如下代码：

public class ReferenceCountingGc {
	Object instance = nulL;
  public static void main(String[〕 args) {
    ReferenceCountingGc objA = new ReferenceCountingGc();
    ReferenceCountingGc obiB = new ReferenceCountingGc();
    obiA.instance = objB;
    obiB.instance = objA;
    objA=null;
    objB=null;
  }
}

除了目标objA和objB相互引证着对方之外，这两个目标之间再无任何引证。可是他们因为互相引证对方，导致它们的引证计数器都不为0，于是引证计数算 法无法告诉GC收回器收回他们。

可达性剖析算法

将GC Roots目标作为起点，从这些节点开始向下查找引证的目标，找到的目标都符号为非废物目标，其余未符号的目标都是废物目标

GC Roots：线程栈的本地变量、静态变量、本地办法栈的变量、存活的线程等等

一个对象在JVM中经历了什么？

当触发gc后，便会有废物收集器对这些能够收回的目标进行收回，目标也就被毁掉了。

小结

本文从一个目标在JVM的阅历动身，串讲了JVM中的一些知识点，如目标的结构是怎样的？JVM是如何给目标分配内存的，分配的办法又有哪些？

其中有部分内容因为篇幅所限，阿紫会另开章节单独介绍，如类加载机制是怎样的？废物收集器又有哪些？

假如我的文章对你有所帮助，还请帮助点赞、保藏、转发一下，你的支持便是我更新的动力，非常感谢！

追更，想要了解更多精彩内容，欢迎重视公众号：程序员阿紫

个人博客网站：zijiancode.cn