转载自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方法的步骤如下

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

如果没有特殊说明，针对的都是HotSpot虚拟机

前言#

• 对于Java程序员，虚拟机自动管理机制，不需要像C/C++程序员为每一个new 操作去写对应的delete/free 操作，不容易出现内存泄漏 和 内存溢出问题
• 但由于内存控制权交给Java虚拟机，一旦出现内存泄漏和溢出方面问题，如果不了解虚拟机是怎么样使用内存，那么很难排查任务

运行时数据区域#

Java虚拟机在执行Java程序的过程中，会把它管理的内存，划分成若干个不同的数据区域

JDK1.8之前：

1. 线程共享 堆，方法区【永久代】(包括运行时常量池)
2. 线程私有 虚拟机栈、本地方法栈、程序计数器
3. 本地内存(包括直接内存)

JDK1.8之后：
1.8之后整个永久代改名叫"元空间"，且移到了本地内存中

规范（概括）：
线程私有：程序计数器，虚拟机栈，本地方法栈

线程共享：堆，方法区，直接内存（非运行时数据区的一部分）

Java虚拟机规范对于运行时数据区域的规定是相当宽松的，以堆为例：

1. 堆可以是连续，也可以不连续
2. 大小可以固定，也可以运行时按需扩展
3. 虚拟机实现者可以使用任何垃圾回收算法管理堆，设置不进行垃圾收集

程序计数器#

• 是一块较小内存空间，看作是当前线程所执行的字节码的行号指示器

• java程序流程
  

• 字节码解释器，工作时通过改变这个计数器的值来选取下一条需要执行的字节码指令

  分支、循环、跳转、异常处理、线程恢复等功能都需要依赖这个计数器

• 而且，为了线程切换后恢复到正确执行位置，每条线程需要一个独立程序计数器，各线程计数器互不影响，独立存储，我们称这类内存区域为**“线程私有”**的内存

• 总结，程序计数器的作用

  • 字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制
  • 多线程情况下，程序计数器用于记录当前线程执行的位置，从而当线程被切回来的时候能够知道该线程上次运行到哪

  程序计数器是唯一一个不会出现OutOfMemoryError的内存区域，它的生命周期随线程创建而创建，线程结束而死亡

Java虚拟机栈#

• Java虚拟机栈，简称"栈"，也是线程私有的，生命周期和线程相同，随线程创建而创建，线程死亡而死亡
• 除了Native方法调用的是通过本地方法栈实现的，其他所有的Java方法调用都是通过栈来实现的（需要和其他运行时数据区域比如程序计数器配合）
• 方法调用的数据需要通过栈进行传递，每一次方法调用都会有一个对应的栈帧被压入栈，每一个方法调用结束后，都会有一个栈帧被弹出。
• 栈由一个个栈帧组成，每个栈帧包括局部变量表、操作数栈、动态链接、方法返回地址。 栈为先进后出，且只支持出栈和入栈

• 局部变量表：存放编译器可知的各种数据类型(boolean、byte、char、short、int、float、long、double)、对象引用(reference 类型，不同于对象本身，可能是一个指向对象起始地址的引用指针，也可能是一个指向一个代表对象的句柄或其他与此对象相关的位置)

• 操作数栈 作为方法调用的中转站使用，用于存放方法执行过程中产生的中间计算结果。计算过程中产生的临时变量也放在操作数栈中

• 动态链接 主要服务一个方法需要调用其他方法的场景。

  在 Java 源文件被编译成字节码文件时，所有的变量和方法引用都作为符号引用（Symbilic Reference）保存在 Class 文件的常量池里。当一个方法要调用其他方法，需要将常量池中指向方法的符号引用转化为其在内存地址中的直接引用。动态链接的作用就是为了将符号引用转换为调用方法的直接引用。