转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

• 图是一种较为复杂的非线性结构
• 线性数据结构的元素满足唯一的线性关系，每个元素（除第一个和最后一个外）只有一个直接前驱和一个直接后继
• 树形数据结构的元素之间有着明显的层级关系
• 图形结构的元素之间的关系是任意的
  • 图就是由顶点的有穷非空集合和顶点之间的边组成的集合，通常表示为：G（V，E），其中，G表示一个图，V表示顶点的集合，E表示边的集合
  • 下面显示的即图这种数据结构，而且还是一张有向图

图的基本概念#

顶点#

• 图中的数据元素，我们称之为顶点，图至少有一个顶点（有穷非空集合）
• 对应到好友关系图，每一个用户就代表一个顶点

边#

• 顶点之间的关系用边表示
• 对应到好友关系图，两个用户是好友的话，那两者之间就存在一条边

度#

• 度表示一个顶点包含多少条边
• 有向图中，分为出度和入度，出度表示从该顶点出去的边的条数，入度表示从进入该顶点的边的条数
• 对应到好友关系图，度就代表了某个人的好友数量

无向图和有向图#

边表示的是顶点之间的关系，有的关系是双向的，比如同学关系，A是B的同学，那么B也肯定是A的同学，那么在表示A和B的关系时，就不用关注方向，用不带箭头的边表示，这样的图就是无向图。

有的关系是有方向的，比如父子关系，师生关系，微博的关注关系，A是B的爸爸，但B肯定不是A的爸爸，A关注B，B不一定关注A。在这种情况下，我们就用带箭头的边表示二者的关系，这样的图就是有向图。

无权图和带权图#

对于一个关系，如果我们只关心关系的有无，而不关心关系有多强，那么就可以用无权图表示二者的关系。

对于一个关系，如果我们既关心关系的有无，也关心关系的强度，比如描述地图上两个城市的关系，需要用到距离，那么就用带权图来表示，带权图中的每一条边一个数值表示权值，代表关系的强度。

下图就是一个带权有向图。

图的存储#

邻接矩阵存储#

• 邻接矩阵将图用二维矩阵存储，是一种比较直观的表示方式
• 如果第i个顶点和第j个顶点有关系，且关系权值为n，则A[i] [j] = n
• 在无向图中，我们只关心关系的有无，所以当顶点i和顶点j有关系时，A[i] [j]=1 ; 当顶点i和顶点j没有关系时，A[i] [j] = 0 ，如下图所示
  无向图的邻接矩阵是一个对称矩阵，因为在无向图中，顶点i和顶点j有关系，则顶点j和顶点i必有关系
• 有向图的邻接矩阵存储 邻接矩阵存储的方式优点是简单直接（直接使用一个二维数组即可），并且在获取两个顶点之间的关系的时候也非常高效*直接获取指定位置的数组元素。但是这种存储方式的确定啊也比较明显即 比较浪费空间

邻接表存储#

• 针对上面邻接矩阵比较浪费内存空间的问题，诞生了图的另一种存储方法–邻接表

• 邻接链表使用一个链表来存储某个顶点的所有后继相邻顶点。对于图中每个顶点Vi ，把所有邻接于Vi 的顶点Vj 链接成一个单链表

  • 无向图的邻接表存储
  • 有向图的邻接表存储

• 邻接表中存储的元素的个数（顶点数）以及图中边的条数

  • 无向图中，邻接表的元素个数等于边的条数的两倍，如下图 7条边，邻接表存储的元素个数为14 （即每条边存储了两次）

    

  • 有向图中，邻接表元素个数等于边的条数，如图所示的有向图中，边的条数为8，邻接表

图的搜索#

广度优先搜索#

• 广度优先搜索：像水面上的波纹一样，一层一层向外扩展，如图

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

数组#

• 数组（Array）是一种常见数据结构，由相同类型的元素（element）组成，并且是使用一块连续的内存来存储
• 直接可以利用元素的**索引（index）**可以计算出该元素对应的存储地址
• 数组的特点是：提供随机访问并且容量有限

假设数组长度为n：
访问：O(1) //访问特定位置的元素

插入：O(n) //最坏的情况插入在数组的首部并需要移动所有元素时

删除：O(n) //最坏的情况发生在删除数组的开头并需要移动第一元素后面所有的元素时

链表#

链表简介#

• 链表（LinkedList）虽然是一种线性表，但是并不会按线性的顺序存储数据，使用的不是连续的内存空间来存储数据

• 链表的插入和删除操作的复杂度为O(1)，只需要直到目标位置元素的上一个元素即可。但是，在查找一个节点或者访问特定位置的节点的时候复杂度为O(n)

• 使用链表结构可以克服数组需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理

  但链表不会节省空间，相比于数组会占用更多空间，因为链表中每个节点存放的还有指向其他节点的指针。除此之外，链表不具有数组随机读取的优点

链表分类#

单链表、双向链表、循环链表、双向循环链表

假设链表中有n个元素
访问：O(n) //访问特地给位置的元素

插入删除：O(1) //必须要知道插入元素的位置

单链表#

• 单链表只有一个方向，结点只有一个后继指针next指向后面的节点。因此，链表这种数据结构通常在物理内存上是不连续的
• 我们习惯性地把第一个结点叫做头结点，链表通常有一个不保存任何值的head节点（头结点），通过头结点我们可以遍历整个链表，尾结点通常指向null
• 如下图

循环链表#

• 循环链表是一种特殊的单链表，和单链表不同的是循环链表的尾结点不是指向null，而是指向链表的头结点
• 如图

双向链表#

• 双向链表包含两个指针，一个prev指向前一个节点，另一个next指向
• 如图

双向循环链表#

双向循环链表的最后一个节点的next指向head，而head的prev指向最后一个节点，构成一个环

应用场景#

• 如果需要支持随机访问的话，链表无法做到
• 如果需要存储的数据元素个数不确定，并且需要经常添加和删除数据的话，使用链表比较合适
• 如果需要存储的数据元素的个数确定，并且不需要经常添加和删除数据的话，使用数组比较合适

数组 vs 链表#

• 数组支持随机访问，链表不支持
• 数组使用的是连续内存空间 对CPU缓存机制友好，链表则相反
• 数组的大小固定，而链表则天然支持动态扩容。如果生命的数组过小，需要另外申请一个更大的内存空间存放数组元素，然后将原数组拷贝进去，这个操作比较耗时

栈#

栈简介#

• 栈（stack）只允许在有序的线性数据集合的一端（称为栈顶top）进行加入数据（push）和移除数据（pop）。因而按照**后进先出（LIFO，Last In First Out）**的原理运作。
• 栈中，push和pop的操作都发生在栈顶
• 栈常用一维数组或链表来实现，用数组实现的叫顺序栈，用链表实现的叫做链式栈

假设堆栈中有n个元素。 访问：O（n）//最坏情况 插入删除：O（1）//顶端插入和删除元素

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

这部分内容由于涉及太多概念性内容，所以参考了维基百科和百度百科相应的介绍。

什么是数据库，数据库管理系统，数据库系统，数据库管理员#

• 数据库：数据库（DataBase 简称DB）就是信息的集合或者说数据库管理系统管理的数据的集合。
• 数据库管理系统：数据库管理系统（Database Management System 简称DBMS）是一种操纵和管理数据库的大型软件，通常用于建立、使用和维护 数据库。
• 数据库系统（范围最大）：数据库系统（Data Base System，简称DBS）通常由**软件、数据和数据管理员（DBA）**组成。
• 数据库管理员：数据库管理员（Database Adminitrator，简称DBA）负责全面管理和控制数据库系统 (是一个人)

数据库系统基本构成如下图所示

什么是元组，码，候选码，主码，外码，主属性，非主属性#

• 元组：元组（tuple）是关系数据库中的基本概念，关系是一张表，表中的每行（即数据库中的每条记录）就是一个元组，每列就是一个属性。在二维表里，元组也成为行
• 码：码就是能唯一标识实体的属性，对应表中的列
• 候选码：若关系中的某一属性或属性组的值能唯一的标识一个元组，而其任何、子集都不能再标识，则称该属性组为候选码。例如：在学生实体中，“学号”是能唯一的区分学生实体的，同时又假设“姓名”、“班级”的属性组合足以区分学生实体，那么**{学号}和{姓名，班级}都是候选码**。
• 主码：主码也叫主键，主码是从候选码中选出来的。一个实体集中只能有一个主码，但可以有多个候选码
• 外码：外码也叫外键。如果一个关系中的一个属性是另外一个关系中的主码则这个属性为外码。
• 主属性 ： 候选码中出现过的属性称为主属性(这里强调单个）。比如关系 工人（工号，身份证号，姓名，性别，部门）. 显然工号和身份证号都能够唯一标示这个关系，所以都是候选码。工号、身份证号这两个属性就是主属性。如果主码是一个属性组，那么属性组中的属性都是主属性。
• 非主属性： 不包含在任何一个候选码中的属性称为非主属性。比如在关系——学生（学号，姓名，年龄，性别，班级）中，主码是“学号”，那么其他的“姓名”、“年龄”、“性别”、“班级”就都可以称为非主属性。

主键和外键有什么区别#

• 主键(主码) ：主键用于唯一标识一个元组，不能有重复，不允许为空。一个表只能有一个主键。
• 外键(外码) ：外键用来和其他表建立联系用，外键是另一表的主键，外键是可以有重复的，可以是空值。一个表可以有多个外键

为什么不推荐使用外键与级联#

• 对于外键和级联，阿里巴巴开发手册这样说道

  【强制】不得使用外键与级联，一切外键概念必须在应用层解决。

  说明: 以学生和成绩的关系为例，学生表中的 student_id 是主键，那么成绩表中的 student_id 则为外键。如果更新学生表中的 student_id，同时触发成绩表中的 student_id 更新，即为级联更新。

  缺点： 外键与级联更新适用于单机低并发，不适合分布式、高并发集群; 级联更新是强阻塞，存在数据库更新风暴的风 险; 外键影响数据库的插入速度

• 为什么不要使用外键

  1. 增加了复杂性

     a. 每次做DELETE 或者UPDATE都必须考虑外键约束，会导致开发的时候很痛苦, 测试数据极为不方便; b. 外键的主从关系是定的，假如那天需求有变化，数据库中的这个字段根本不需要和其他表有关联的话就会增加很多麻烦。

  2. 增加了额外操作

     数据库需要增加维护外键的工作，比如当我们做一些涉及外键字段的增，删，更新操作之后，需要触发相关操作去检查，保证数据的的一致性和正确性，这样会不得不消耗资源；（个人觉得这个不是不用外键的原因，因为即使你不使用外键，你在应用层面也还是要保证的。所以，我觉得这个影响可以忽略不计。）

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

JDK 命令行工具#

这些命令在 JDK 安装目录下的 bin 目录下：

• jps (JVM Process Status）: 类似 UNIX 的 ps 命令。用于查看所有 Java 进程的启动类、传入参数和 Java 虚拟机参数等信息；
• jstat（JVM Statistics Monitoring Tool）: 用于收集 HotSpot 虚拟机各方面的运行数据;
• jinfo (Configuration Info for Java) : Configuration Info for Java,显示虚拟机配置信息;
• jmap (Memory Map for Java) : 生成堆转储快照;
• jhat (JVM Heap Dump Browser) : 用于分析 heapdump 文件，它会建立一个 HTTP/HTML 服务器，让用户可以在浏览器上查看分析结果;
• jstack (Stack Trace for Java) : 生成虚拟机当前时刻的线程快照，线程快照就是当前虚拟机内每一条线程正在执行的方法堆栈的集合。

jps: 查看所有 Java 进程#

jps(JVM Process Status) 命令类似 UNIX 的 ps 命令。

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

本文由 JavaGuide 翻译自 https://www.baeldung.com/jvm-parametersopen in new window，并对文章进行了大量的完善补充。翻译不易，如需转载请注明出处，作者： baeldungopen in new window 。

概述#

本篇文章中，将掌握最常用的JVM参数配置。下面提到了一些概念，堆、方法区、垃圾回收等。

堆内存相关#

Java 虚拟机所管理的内存中最大的一块，Java 堆是所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎 所有的对象实例以及数组都在这里分配内存。

显式指定堆内存-Xms和-Xmx#

• 与性能相关的最常见实践之一是根据应用程序要求初始化堆内存。

• 如果我们需要指定最小和最大堆大小（推荐显示指定大小）：

  -Xms<heap size>[unit] 
  -Xmx<heap size>[unit]

  • heap size 表示要初始化内存的具体大小。
  • unit 表示要初始化内存的单位。单位为***“ g”*** (GB) 、“ m”（MB）、“ k”（KB）。

• 举例，为JVM分配最小2GB和最大5GB的堆内存大小

  -Xms2G -Xmx5G

显示新生代内存（Young Generation）#

• 在堆总可用内存配置完成之后，第二大影响因素是为 Young Generation 在堆内存所占的比例。默认情况下，YG 的最小大小为 1310 MB，最大大小为无限制。

• 两种指定 新生代内存(Young Generation) 大小的方法

  1. 通过 -XX:NewSize 和 -XX:MaxNewSize

     -XX:NewSize=<young size>[unit] 
     -XX:MaxNewSize=<young size>[unit]

     如，为新生代分配最小256m的内存，最大1024m的内存我们的参数为：

     -XX:NewSize=256m
     -XX:MaxNewSize=1024m

  2. 通过-Xmn<young size>[unit] 指定 举例，为新生代分配256m的内存（NewSize与MaxNewSize设为一致） -Xmn256m

     将新对象预留在新生代，由于 Full GC 的成本远高于 Minor GC，因此尽可能将对象分配在新生代是明智的做法，实际项目中根据 GC 日志分析新生代空间大小分配是否合理，适当通过“-Xmn”命令调节新生代大小，最大限度降低新对象直接进入老年代的情况。

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

概述#

• Java中，JVM可以理解的代码就叫做字节码（即扩展名为.class的文件），它不面向任何特定的处理器，只面向虚拟机
• Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时效率极高，且由于字节码并不针对一种特定的机器。因此，Java程序无需重新编译便可在多种不通操作系统的计算机运行
• Clojure（Lisp 语言的一种方言）、Groovy、Scala 等语言都是运行在 Java 虚拟机之上。下图展示了不同的语言被不同的编译器编译成.class文件最终运行在 Java 虚拟机之上。.class文件的二进制格式可以使用 WinHexopen in new window 查看。

.class文件是不同语言在Java虚拟机之间的重要桥梁，同时也是支持Java跨平台很重要的一个原因

Class文件结构总结#

根据Java虚拟机规范，Class文件通过ClassFile定义，有点类似C语言的结构体

ClassFile的结构如下：

ClassFile {
    u4             magic; //Class 文件的标志
    u2             minor_version;//Class 的小版本号
    u2             major_version;//Class 的大版本号
    u2             constant_pool_count;//常量池的数量
    cp_info        constant_pool[constant_pool_count-1];//常量池
    u2             access_flags;//Class 的访问标记
    u2             this_class;//当前类
    u2             super_class;//父类
    u2             interfaces_count;//接口
    u2             interfaces[interfaces_count];//一个类可以实现多个接口
    u2             fields_count;//Class 文件的字段属性
    field_info     fields[fields_count];//一个类可以有多个字段
    u2             methods_count;//Class 文件的方法数量
    method_info    methods[methods_count];//一个类可以有个多个方法
    u2             attributes_count;//此类的属性表中的属性数
    attribute_info attributes[attributes_count];//属性表集合
} 

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

回顾一下类加载过程#

开始介绍类加载器和双亲委派模型之前，简单回顾一下类加载过程。

• 类加载过程：加载->连接->初始化。
• 连接过程又可分为三步：验证->准备->解析。

[

加载是类加载过程的第一步，主要完成下面 3 件事情：

1. 通过全类名获取定义此类的二进制字节流
2. 将字节流所代表的静态存储结构转换为方法区的运行时数据结构
3. 在内存中生成一个代表该类的 Class 对象，作为方法区这些数据的访问入口

类加载器#

类加载器介绍#

类加载器从 JDK 1.0 就出现了，最初只是为了满足 Java Applet（已经被淘汰） 的需要。后来，慢慢成为 Java 程序中的一个重要组成部分，赋予了 Java 类可以被动态加载到 JVM 中并执行的能力。

根据官方 API 文档的介绍：

A class loader is an object that is responsible for loading classes. The class ClassLoader is an abstract class. Given the binary name of a class, a class loader should attempt to locate or generate data that constitutes a definition for the class. A typical strategy is to transform the name into a file name and then read a “class file” of that name from a file system.

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

类的声明周期#

类加载过程#

• Class文件，需要加载到虚拟机中之后才能运行和使用，那么虚拟机是如何加载这些Class文件呢
• 系统加载Class类文件需要三步：加载->连接->初始化。连接过程又分为三步：验证->准备->解析
  

加载#

类加载的第一步，主要完成3件事情

构造与类相关联的方法表

1. 通过全类名获取定义此类的二进制字节流
2. 将字节流所代表的静态存储结构，转换为方法区的运行时数据结构
3. 在内存中生成一个该类的Class对象，作为方法区这些数据的访问入口

虚拟机规范对上面3点不具体，比较灵活

1. 对于1 没有具体指明从哪里获取、怎样获取。可以从ZIP包读取 （JAR/EAR/WAR格式的基础）、其他文件生成（JSP）等

• 非数组类的加载阶段（加载阶段获取类的二进制字节流的动作）是可控性最强的阶段，这一步我们可以去完成还可以自定义类加载器去控制字节流的获取方式（重写一个类加载器的**loadClass()**方法
• 数组类型不通过类加载器创建，它由Java虚拟机直接创建

加载阶段和连接阶段的部分内容是交叉执行的，即加载阶段尚未结束，连接阶段就可能已经开始了

验证#

验证是连接阶段的第一步，这一阶段的目的是确保 Class 文件的字节流中包含的信息符合《Java 虚拟机规范》的全部约束要求，保证这些信息被当作代码运行后不会危害虚拟机自身的安全。

验证阶段主要由四个检验阶段组成：

1. 文件格式验证（Class 文件格式检查）
2. 元数据验证（字节码语义检查）
3. 字节码验证（程序语义检查）
4. 符号引用验证（类的正确性检查）

准备#

• 准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些内存都将在方法区中分配，注意：

  1. 这时候进行内存分配的仅包括类变量（ClassVariables，即静态变量：被static关键字修饰的变量，只与类相关，因此被称为类变量），而不包括实例变量。

     实例变量会在对象实例化时，随着对象一块分配到Java堆中

  2. 从概念上讲，类变量所使用的内存都应当在 方法区 中进行分配。不过有一点需要注意的是：JDK 7 之前，HotSpot 使用永久代来实现方法区的时候，实现是完全符合这种逻辑概念的。 而在 JDK 7 及之后，HotSpot 已经把原本放在永久代的字符串常量池、静态变量等移动到堆中，这个时候类变量则会随着 **Class 对象（上面有提到，内存区生成Class对象）**一起存放在 Java 堆中

  3. 这里所设置的初始值**“通常情况”下是数据类型默认的零值（如 0、0L、null、false 等**），比如我们定义了**public static int value=111** ，那么 value 变量在准备阶段的初始值就是 0 而不是 111（初始化阶段才会赋值）。特殊情况：比如给 value 变量加上了 final 关键字public static final int value=111 ，那么准备阶段 value 的值就被赋值为 111

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

前言#

当需要排查各种内存溢出问题、当垃圾收集成为系统达到更高并发的瓶颈时，我们就需要对这些**“自动化”的技术实施必要的监控和调节**

堆空间的基本结构#

• Java的自动内存管理主要是针对对象内存的回收和对象内存的分配。且Java自动内存管理最核心的功能是堆内存中的对象分配和回收

• Java堆是垃圾收集器管理的主要区域，因此也被称作GC堆（Garbage Collected Heap）

• 从垃圾回收的角度来说，由于现在收集器基本都采用分代垃圾收集算法，所以Java堆被划分为了几个不同的区域，这样我们就可以根据各个区域的特点选择合适的垃圾收集算法

• JDK7版本及JDK7版本之前，堆内存被通常分为下面三部分：

  1. 新生代内存（Young Generation）
  2. 老生代（Old Generation）
  3. 永久代（Permanent Generation）

JDK8版本之后PermGen（永久）已被Metaspace（元空间）取代，且已经不在堆里面了，元空间使用的是直接内存。

内存分配和回收原则#

对象优先在Eden区分配#

• 多数情况下，对象在新生代中Eden区分配。当Eden区没有足够空间进行分配时，会触发一次MinorGC 首先，先添加一下参数打印GC详情：-XX:+PrintGCDetails

  public class GCTest {
  	public static void main(String[] args) {
  		byte[] allocation1, allocation2;
  		allocation1 = new byte[30900*1024];//会用掉3万多K
  	}
  } 

  运行后的结果（这里应该是配过xms和xmx了，即堆内存大小） 如上，Eden区内存几乎被分配完全（即使程序什么都不做，新生代也会使用2000多K）

  注： PSYoungGen 为 38400K ，= 33280K + 5120K （Survivor区总会有一个是空的，所以只加了一个5120K ）

  假如我们再为allocation2分配内存会怎么样(不处理的话，年轻代会溢出)

  allocation2 = new byte[900 * 1024];

  在给allocation2分配内存之前，Eden区内存几乎已经被分配完。所以当Eden区没有足够空间进行分配时，虚拟机将发起一次MinorGC。GC期间虚拟机又发现allocation1无法存入空间，所以只好通过分配担保机制，把新生代的对象，提前转移到老年代去，老年代的空间足够存放allocation1，所以不会出现Full GC（这里可能是之前的说法，可能只是要表达老年代的GC，而不是Full GC(整堆GC) ）　　

  执行MinorGC后，后面分配的对象如果能够存在Eden区的话，还是会在Eden区分配内存
  执行如下代码验证：

  public class GCTest {
  
  	public static void main(String[] args) {
  		byte[] allocation1, allocation2,allocation3,allocation4,allocation5;
  		allocation1 = new byte[32000*1024];
  		allocation2 = new byte[1000*1024];
  		allocation3 = new byte[1000*1024];
  		allocation4 = new byte[1000*1024];
  		allocation5 = new byte[1000*1024];
  	}
  } 

大对象直接进入老年代#

• 大对象就是需要连续空间的对象（字符串、数组等）
• 大对象直接进入老年代，主要是为了避免为大对象分配内存时，由于分配担保机制(这好像跟分配担保机制没有太大关系)带来的复制而降低效率。

• 假设大对象最后会晋升老年代，而新生代是基于复制算法来回收垃圾的，由两个Survivor区域配合完成复制算法，如果新生代中出现大对象且能屡次躲过GC，那这个对象就会在两个Survivor区域中来回复制，直至最后升入老年代，而大对象在内存里来回复制移动，就会消耗更多的时间。

转载自https://github.com/Snailclimb/JavaGuide（添加小部分笔记）感谢作者!

原文地址： https://juejin.im/post/5e1505d0f265da5d5d744050#heading-28 感谢原作者分享！！

JVM的基本介绍#

• JVM，JavaVirtualMachine的缩写，虚拟出来的计算机，通过在实际的计算机上仿真模拟各类计算机功能实现
• JVM类似一台小电脑，运行在windows或者linux这些真实操作系统环境下，直接和操作系统交互，与硬件不直接交互，操作系统帮我们完成和硬件交互的工作

Java文件是如何运行的#

场景假设：我们写了一个HelloWorld.java，这是一个文本文件。JVM不认识文本文件，所以需要一个编译，让其(xxx.java)成为一个JVM会读的二进制文件—> HelloWorld.class

1. 类加载器 如果JVM想要执行这个.class文件，需要将其**(这里应该指的二进制文件)装进类加载器**中，它就像一个搬运工一样，会把所有的.class文件全部搬进JVM里面

2. 方法区

   类加载器将.class文件搬过来，就是先丢到这一块上

   方法区是用于存放类似于元数据信息方面的数据的，比如类信息、常量、静态变量、编译后代码…等

3. 堆 堆主要放一些存储的数据，比如对象实例、数组…等，它和方法区都同属于线程共享区域，即它们都是线程不安全的

4. 栈

   线程独享
   栈是我们代码运行空间，我们编写的每一个方法都会放到栈里面运行。
   名词：本地方法栈或本地方法接口，不过我们基本不会涉及这两块内容，这两底层使用C进行工作，和Java没有太大关系

5. 程序计数器 主要就是完成一个加载工作，类似于一个指针一样的，指向下一行我们需要执行的代码。和栈一样，都是线程独享的，就是每一个线程都会自己对应的一块区域而不会存在并发和多线程问题。

6. 小总结

   1. Java文件经过编译后编程.class字节码文件
   2. 字节码文件通过类加载器被搬运到 JVM虚拟机中
   3. 虚拟机主要的5大块：方法区、堆 都为线程共享区域，有线程安全问题；栈和本地方法栈和计数器都是独享区域，不存在线程安全问题，而JVM的调优主要就是围绕堆、栈两大块进行

简单的代码例子#

一个简单的学生类及main方法:

public class Student {
    public String name;

    public Student(String name) {
        this.name = name;
    }

    public void sayName() {
        System.out.println("student's name is : " + name);
    }
}

main方法：

public class App {
    public static void main(String[] args) {
        Student student = new Student("tellUrDream");
        student.sayName();
    }
}

★★ 执行main方法的步骤如下