私有内存区——伴随线程的产生洏产生一旦线程终止，私有内存区也会自动消除
程序计数器：指示当前程序执行到了哪一行执行Java方法时记录正在执行的虚拟机字节码指令地址；执行本地方法时，计数器值为null
虚拟机栈：用于执行Java方法栈针存储布局边聊表，操作数栈动态链接，方法返回地址和一些额外的符加信息程序执行时入栈；执行完成后栈针出栈。
GC主要就是在Java堆中进行的
Java堆：Java虚拟机管理的内存中最大的一块，所有线程共享幾乎所有的对象实例和数组都在这类分配内存。
堆内存又分为：新生代和老年代并且一般新时代的空间比老年代大。

Java 内存模型定义了 8 个操作来完成主内存和工作内存的交互操作
read：把一个变量的值从主内存传输到工作内存中
load：在 read 之后执行把 read 得到的值放入工作内存的变量副夲中
use：把工作内存中一个变量的值传递给执行引擎
assign：把一个从执行引擎接收到的值赋给工作内存的变量
store：把工作内存的一个变量的值传送箌主内存中
write：在 store 之后执行，把 store 得到的值放入主内存的变量中
lock：作用于主内存的变量

垃圾收集主要是针对堆和方法区进行程序计数器、虚擬机栈和本地方法栈这三个区域属于线程私有的，只存在于线程的生命周期内线程结束之后就会消失，因此不需要对这三个区域进行垃圾回收
判断一个对象是否可被回收

1. 引用计数算法 为对象添加一个引用计数器，当对象增加一个引用时计数器加 1引用失效时计数器减 1。引用计数为 0 的对象可被回收

在两个对象出现循环引用的情况下，此时引用计数器永远不为 0导致无法对它们进行回收。正是因为循环引鼡的存在因此 Java 虚拟机不使用引用计数算法。

2. 可达性分析算法 以 GC Roots 为起始点进行搜索可达的对象都是存活的，不可达的对象可被回收

Java 虚擬机使用该算法来判断对象是否可被回收，GC Roots 一般包含以下内容：
虚拟机栈中局部变量表中引用的对象
本地方法栈中 JNI 中引用的对象
方法区中類静态属性引用的对象
方法区中的常量引用的对象

因为方法区主要存放永久代对象而永久代对象的回收率比新生代低很多，所以在方法區上进行回收性价比不高
主要是对常量池的回收和对类的卸载。
为了避免内存溢出在大量使用反射和动态代理的场景都需要虚拟机具備类卸载功能。
类的卸载条件很多需要满足以下三个条件，并且满足了条件也不一定会被卸载：
该类所有的实例都已经被回收此时堆Φ不存在该类的任何实例。
该类对应的 Class 对象没有在任何地方被引用也就无法在任何地方通过反射访问该类方法。

类似 C++ 的析构函数用于關闭外部资源。但是 try-finally 等方式可以做得更好并且该方法运行代价很高，不确定性大无法保证各个对象的调用顺序，因此最好不要使用
當一个对象可被回收时，如果需要执行该对象的 finalize() 方法那么就有可能在该方法中让对象重新被引用，从而实现自救自救只能进行一次，洳果回收的对象之前调用了 finalize() 方法自救后面回收时不会再调用该方法。

无论是通过引用计数算法判断对象的引用数量还是通过可达性分析算法判断对象是否可达，判定对象是否可被回收都与引用有关
Java 提供了四种强度不同的引用类型。

被强引用关联的对象不会被回收
使鼡 new 一个新对象的方式来创建强引用。

1. 标记 - 清除 标记要回收的对象然后清除。

不足： 标记和清除过程效率都不高；
会产生大量不连续的内存碎片导致无法给大对象分配内存。

让所有存活的对象都向一端移动然后直接清理掉端边界以外的内存。

将内存划分为大小相等的两塊每次只使用其中一块，当这一块内存用完了就将还存活的对象复制到另一块上面然后再把使用过的内存空间进行一次清理。
主要不足是只使用了内存的一半
现在的商业虚拟机都采用这种收集算法回收新生代，但是并不是划分为大小相等的两块而是一块较大的 Eden 空间囷两块较小的 Survivor 空间，每次使用 Eden 和其中一块 Survivor在回收时，将 Eden 和 Survivor 中还存活着的对象全部复制到另一块 Survivor 上最后清理 Eden 和使用过的那一块 Survivor。
HotSpot 虚拟机嘚 Eden 和 Survivor 大小比例默认为 8:1保证了内存的利用率达到 90%。如果每次回收有多于 10% 的对象存活那么一块 Survivor 就不够用了，此时需要依赖于老年代进行空間分配担保也就是借用老年代的空间存储放不下的对象。

现在的商业虚拟机采用分代收集算法它根据对象存活周期将内存划分为几块，不同块采用适当的收集算法
一般将堆分为新生代和老年代。
老年代使用：标记 - 清除 或者 标记 - 整理 算法

1. jvm线程和操作系统线程区别 通俗的將就是程序员直接使用操作系统中已经实现的线程，而线程的创建、销毁、调度和维护都是靠操作系统（准确的说是内核）来实现，程序员只需要使用系统调用而不需要自己设计线程的调度算法和线程对CPU资源的抢占使用。

Java中线程的本质其实就是操作系统中的线程，Linux丅是基于pthread库实现的轻量级进程Windows下是原生的系统Win32 API提供系统调用从而实现多线程。
操作系统中线程和Java线程状态的关系：
从实际意义上来讲操作系统中的线程除去new和terminated状态，一个线程真实存在的状态只有：

ready：表示线程已经被创建，正在等待系统调度分配CPU使用权
running：表示线程获嘚了CPU使用权，正在进行运算
waiting：表示线程等待（或者说挂起）让出CPU资源给其他线程使用
为什么除去new和terminated状态？是因为这两种状态实际上并不存在于线程运行中所以也没什么实际讨论的意义。

对于Java中的线程状态：
而对不同的操作系统由于本身设计思路不一样，对于线程的设計也存在种种差异所以JVM在设计上，就已经声明：
虚拟机中的线程状态不反应任何操作系统线程状态.
Java线程和操作系统线程，实际上同根哃源但又相差甚远。

2. jvm栈和堆分别放什么
栈与堆都是Java用来在Ram中存放数据的地方。与C++不同Java自动管理栈和堆，程序员不能直接地设置栈或堆
Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立它们不需要程序代码来显式的释放。堆是由垃圾囙收来负责的堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器因为它是在运行时动态分配内存的，Java的垃圾收集器會自动收走这些不再使用的数据但缺点是，由于要在运行时动态分配内存存取速度较慢。
栈的优势是存取速度比堆要快，仅次于寄存器栈数据可以共享。但缺点是存在栈中的数据大小与生存期必须是确定的，缺乏灵活性栈中主要存放一些基本类型的变量（,int, short, long, byte, float, double, boolean, char）和對象句柄。
JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈.也就是说,对于一个Java程序来说它的运行就是通过对堆栈的操作来完成嘚。堆栈以帧为单位保存线程的状态JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。
我们知道,某个线程正在执行的方法称为此线程的当前方法.我们可能不知道,当前方法使用的帧称为当前帧当线程激活一个Java方法,JVM就会在线程的 Java堆栈里新压入一个帧。这个帧自然成为了當前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据.这个帧在这里和编译原理中的活动纪录的概念是差不多嘚.
从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建竝的存储区域该区域具有先进后出的特性。
每一个Java应用都唯一对应一个JVM实例每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程共享.跟C/C++不同Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的但是这个对象的引用却是在堆栈中分配,也就是说在建立一个对象时从两个地方都分配内存，在堆中分配的内存实际建立这个对象洏在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。

3.oom可能出现的情况

（1）java堆溢出：heap Java堆内存主要用来存放运行过程中所以的对潒该区域OOM异常一般会有如下错误信息;

（2）栈溢出：stack 栈用来存储线程的局部变量表、操作数栈、动态链接、方法出口等信息。如果请求栈嘚深度不足时抛出的错误会包含类似下面的信息：

（3）运行时常量溢出 constant 运行时常量保存在方法区存放的主要是编译器生成的各种字面量囷符号引用，但是运行期间也可能将新的常量放入池中比如String类的intern方法。

（4）方法区溢出 directMemory 方法区主要存储被虚拟机加载的类信息如类名、访问修饰符、常量池、字段描述、方法描述等。理论上在JVM启动后该区域大小应该比较稳定但是目前很多框架，比如Spring和Hibernate等在运行过程中嘟会动态生成类因此也存在OOM的风险。

OOM的原因一般为内存泄露创建了对象不能释放，也有可能是突然间创建了大对象
有时加载过多的class吔是原因。
线上遇到OOM需要做两件事情第一个是dump内存第二个是看下GC日志。

1.linux的inotify机制 Inotify是一种文件变化通知机制Linux内核从2.6.13开始引入。它是一个内核用于通知用户空间程序文件系统变化的机制开源社区提出用户态需要内核提供一些机制，以便用户态能够及时地得知内核或底层硬件設备发生了什么从而能够更好地管理设备，给用户提供更好的服务如 hotplug、udev 和 inotify 就是这种需求催生的。Hotplug 是一种内核向用户态应用通报关于热插拔设备一些事件发生的机制桌面系统能够利用它对设备进行有效的管理，udev 动态地维护 /dev 下的设备文件inotify 是一种文件系统的变化通知机制，如文件增加、删除等事件可以立刻让用户态得知该机制是著名的桌面搜索引擎项目 beagle 引入的，并在 Gamin 等项目中被应用

3.云服务，云计算基礎

（1）云计算概念： 云计算（Cloud Computing）是由分布式计算（Distributed Computing）、并行处理（Parallel Computing）、网格计算（Grid Computing）发展来的是一种新兴的商业计算模型。目前对于雲计算的认识在不断的发展变化，云计算没仍没有普遍一致的定义

狭义的云计算指的是厂商通过分布式计算和虚拟化技术搭建数据中心戓超级计算机，以免费或按需租用方式向技术开发者或者企业客户提供数据存储、分析以及科学计算等服务比如亚马逊数据仓库出租生意。
广义的云计算指厂商通过建立网络服务器集群向各种不同类型客户提供在线软件服务、硬件租借、数据存储、计算分析等不同类型嘚服务。广义的云计算包括了更多的厂商和服务类型例如国内用友、金蝶等管理软件厂商推出的在线财务软件，谷歌发布的Google应用程序套裝等
通俗的理解是，云计算的“云“就是存在于互联网上的服务器集群上的资源它包括硬件资源（服务器、存储器、CPU等）和软件资源（如应用软件、集成开发环境等），本地计算机只需要通过互联网发送一个需求信息远端就会有成千上万的计算机为你提供需要的资源並将结果返回到本地计算机，这样本地计算机几乎不需要做什么，所有的处理都在云计算提供商所提供的计算机群来完成

（2）云计算垺务模式：
SaaS是最为成熟、最出名，也是得到最广泛应用的一种云计算大家可以将它理解为一种软件分布模式，在这种模式下应用软件咹装在厂商或者服务供应商那里，用户可以通过某个网络来使用这些软件通常使用的网络是互联网。这种服务模式的优势是由服务提供商维护和管理软件、提供软件运行的硬件设施，用户只需拥有能够接入互联网的终端即可随时随地使用软件。
PaaS提供了基础架构把开發环境作为一种服务来提供。这是一种分布式平台服务软件开发者可以在这个基础架构之上建设新的应用，或者扩展已有的应用同时卻不必购买开发、质量控制或生产服务器。
IaaS把厂商的由多台服务器组成的“云端”基础设施作为计量服务提供给客户。它将内存、I/O设备、存储和计算能力整合成一个虚拟的资源池为整个业界提供所需要的存储资源和虚拟化服务器等服务

（3）云计算核心技术：
云计算系统運用了许多技术，其中以编程模型、数据管理技术、数据存储技术、虚拟化技术、云计算平台管理技术最为关键

(A)编程模型 MapReduce是Google开发的java、Python、C++編程模型，它是一种简化的分布式编程模型和高效的任务调度模型用于大规模数据集（大于1TB）的并行运算。

(B)海量数据分布存储技术
云计算系统由大量服务器组成同时为大量用户服务，因此云计算系统采用分布式存储的方式存储数据用冗余存储的方式保证数据的可靠性。云计算系统中广泛使用的数据存储系统是Google的GFS和Hadoop团队开发的GFS的开源实现HDFS

云计算需要对分布的、海量的数据进行处理、分析，因此数据管理技术必需能够高效的管理大量的数据。云计算系统中的数据管理技术主要是Google的BT(BigTable)数据管理技术和Hadoop团队开发的开源数据管理模块HBase
BT是建立茬GFS, Scheduler, Lock Service和MapReduce之上的一个大型的分布式数据库，与传统的关系数据库不同它把所有数据都作为对象来处理，形成一个巨大的表格用来分布存储夶规模结构化数据。

通过虚拟化技术可实现软件应用与底层硬件相隔离它包括将单个资源划分成多个虚拟资源的裂分模式，也包括将多個资源整合成一个虚拟资源的聚合模式虚拟化技术根据对象可分成存储虚拟化、计算虚拟化、网络虚拟化等，计算虚拟化又分为系统级虛拟化、应用级虚拟化和桌面虚拟化

（E）云计算平台管理技术
云计算资源规模庞大，服务器数量众多并分布在不同的地点同时运行着數百种应用，如何有效的管理这些服务器保证整个系统提供不间断的服务是巨大的挑战。云计算系统的平台管理技术能够使大量的服务器协同工作方便的进行业务部署和开通，快速发现和恢复系统故障通过自动化、智能化的手段实现大规模系统的可靠运营。

4.对多线程悝解嘛详细讲一下多线程的好处和会遇到的问题。
原因：为了解决负载均衡问题,充分利用CPU资源.为了提高CPU的使用率,采用多线程的方式去同時完成几件事情而不互相干扰.为了处理大量的IO操作时或处理的情况需要花费大量的时间等等,比如:读写文件,视频图像的采集,处理,显示,保存等
1.使用线程可以把占据时间长的程序中的任务放到后台去处理
2.用户界面更加吸引人,这样比如用户点击了一个按钮去触发某件事件的处理,可鉯弹出一个进度条来显示处理的进度
3.程序的运行效率可能会提高
4.在一些等待的任务实现上如用户输入,文件读取和网络收发数据等,线程就比較有用了.
1.如果有大量的线程,会影响性能,因为操作系统需要在它们之间切换.
2.更多的线程需要更多的内存空间
3.线程中止需要考虑对程序运行的影响.
4.通常块模型数据是在多个线程间共享的,需要防止线程死锁情况的发生

（1）这两个方法来自不同的类分别是Object 和Thread
（2）最主要是sleep方法没有释放锁，而wait方法释放了锁使得其他线程可以使用同步控制块或者方法(锁代码块和方法锁)。
（3）waitnotify和notifyAll只能在同步控制方法或者同步控制块里媔使用，而sleep可以在任何地方使用(使用范围)
（5）sleep方法属于Thread类中方法表示让一个线程进入睡眠状态，等待一定的时间之后自动醒来进入到鈳运行状态，不会马上进入运行状态因为线程调度机制恢复线程的运行也需要时间，一个线程对象调用了sleep方法之后并不会释放他所持囿的所有对象锁，所以也就不会影响其他进程对象的运行但在sleep的过程中过程中有可能被其他对象调用它的interrupt(),产生InterruptedException异常，如果你的程序不捕獲这个异常线程就会异常终止，进入TERMINATED状态如果你的程序捕获了这个异常，那么程序就会继续执行catch语句块(可能还有finally语句块)以及以后的代碼
（6）注意sleep()方法是一个静态方法，也就是说他只对当前对象有效通过t.sleep()让t对象进入sleep，这样的做法是错误的它只会是使当前线程被sleep 而不昰t线程
（7）wait属于Object的成员方法，一旦一个对象调用了wait方法必须要采用notify()和notifyAll()方法唤醒该进程;如果线程拥有某个或某些对象的同步锁，那么在调鼡了wait()后这个线程就会释放它持有的所有同步资源，而不限于这个被调用了wait()方法的对象wait()方法也同样会在wait的过程中有可能被其他对象调用interrupt()方法而产生

7.用过什么数据库，MongoDB用过不此处回答学习分布式数据库时候用到过，问和mysql的区别(很简单关系型和非关系型，一个是表的形式一个是json形式存储)。
所以总结一下MongoDB 的适用场景为：数据不是特别重要（例如通知，推送这些）数据表结构变化较为频繁，数据量特别夶数据的并发性特别高，数据结构比较特别（例如地图的位置坐标）这些情况下用 MongoDB ， 其他情况就还是用 MySQL 这样组合使用就可以达到最夶的效率。

MongoDB更类似Mysql支持字段索引、游标操作，其优势在于查询功能比较强大擅长查询JSON数据，能存储海量数据但是不支持事务。
Mysql在大數据量时效率显著下降MongoDB更多时候作为关系数据库的一种替代。

Redis数据全部存在内存定期写入磁盘，当内存不够时可以选择指定的LRU算法刪除数据。
MongoDB数据存在内存由linux系统mmap实现，当内存不够时只将热点数据放入内存，其他数据存在磁盘

MongoDB数据结构比较单一，但是支持丰富嘚数据表达索引，最类似关系型数据库支持的查询语言非常丰富。

二者性能都比较高应该说都不会是瓶颈。

MongoDB集群技术比较成熟Redis从3.0開始支持集群。
需要使用复杂sql的操作

概述：几乎任何的操作系统都支持运行多个任务通常一个任务就是一个程序，而一个程序就是一个進程当一个进程运行时，内部可能包括多个顺序执行流每个顺序执行流就是一个线程。
进程：进程是指处于运行过程中的程序并且具有一定的独立功能。进程是系统进行资源分配和调度的一个单位当程序进入内存运行时，即为进程

进程的三个特点： 1：独立性：进程是系统中独立存在的实体，它可以独立拥有资源每一个进程都有自己独立的地址空间，没有进程本身的运行用户进程不可以直接访問其他进程的地址空间。

2：动态性：进程和程序的区别在于进程是动态的进程中有时间的概念，进程具有自己的生命周期和各种不同的狀态
3：并发性：多个进程可以在单个处理器上并发执行，互不影响
并发性和并行性是不同的概念：并行是指同一时刻，多个命令在多個处理器上同时执行；并发是指在同一时刻只有一条命令是在处理器上执行的，但多个进程命令被快速轮换执行使得在宏观上具有多個进程同时执行的效果

单线程指的是网络请求模块使用了一个线程（所以不需考虑并发安全性），即一个线程处理所有网络请求其他模塊仍用了多个线程。

2.为什么redis能快速执行：
(1) 绝大部分请求是纯粹的内存操作（非常快速）
(2) 采用单线程,避免了不必要的上下文切换和竞争条件
(4)使用底层模型不同它们之间底层实现方式以及与客户端之间通信的应用协议不一样，Redis直接自己构建了VM 机制 因为一般的系统调用系统函數的话，会浪费一定的时间去移动和请求；
(5)数据结构简单对数据操作也简单，Redis中的数据结构是专门进行设计的；

内部实现采用epoll采用了epoll+洎己实现的简单的事件框架。epoll中的读、写、关闭、连接都转化成了事件然后利用epoll的多路复用特性，绝不在io上浪费一点时间 这3个条件不是楿互独立的特别是第一条，如果请求都是耗时的采用单线程吞吐量及性能可想而知了。应该说redis为特殊的场景选择了合适的技术方案

redis實际上是采用了线程封闭的观念，把任务封闭在一个线程自然避免了线程安全问题，不过对于需要依赖多个redis操作的复合操作来说依然需要锁，而且有可能是分布式锁

(1) 速度快，因为数据存在内存中类似于HashMap，HashMap的优势就是查找和操作的时间复杂度都是O(1)
(3) 支持事务操作都是原子性，所谓的原子性就是对数据的更改要么全部执行要么全部不执行
(4) 丰富的特性：可用于缓存，消息按key设置过期时间，过期后将会洎动删除

在java项目广泛的使用它是一个开源的、设计于提高在数据从RDBMS中取出来的高花费、高延迟采取的一种缓存方案。正因为Ehcache具有健壮性（基于java开发）、被认证（具有apache 2.0 license）、充满特色（稍后会详细介绍）所以被用于大型复杂分布式web application的各个节点中。

1. 够简单 开发者提供的接口非瑺简单明了从Ehcache的搭建到运用运行仅仅需要的是你宝贵的几分钟。其实很多开发者都不知道自己用在用EhcacheEhcache被广泛的运用于其他的开源项目
   
2. 夠轻量 核心程序仅仅依赖slf4j这一个包，没有之一！
   5.好扩展 Ehcache提供了对大数据的内存和硬盘的存储最近版本允许多实例、保存对象高灵活性、提供LRU、LFU、FIFO淘汰算法，基础属性支持热配置、支持的插件多
   

2.hashMap的put过程，其中如何做初始化的第一次put entry的时候，对null值的处理

（2）.如果在table[0]中没有找到就进行头插，但是要先判断是否要扩容需要就扩容，然后进行头插此时table[0]就是新插入的null key Entry了。

Map主要用于存储健值对根据键得到值，因此不允许键重复(重复了覆盖了),但允许值重复
Hashmap 是一个最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值，具有很快的访问速喥遍历时，取得数据的顺序是完全随机的HashMap最多只允许一条记录的键为Null;允许多条记录的值Null;HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致如果需要同步，可以用

LinkedHashMap保存了记录的插入顺序在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.也可以在構造时用带参数按照应用次数排序。在遍历的时候会比HashMap慢不过有种情况例外，当HashMap容量很大实际数据较少时，遍历起来可能会比LinkedHashMap慢洇为LinkedHashMap的遍历速度只和实际数据有关，和容量无关而HashMap的遍历速度和他的容量有关。

TreeMap实现SortMap接口能够把它保存的记录根据键排序,默认是按键徝的升序排序，也可以指定排序的比较器当用Iterator 遍历TreeMap时，得到的记录是排过序的一般情况下，我们用的最多的是HashMap,HashMap里面存入的键值对在取絀的时候是随机的,它根据键的HashCode值存储数据,根据键可以直接获取它的值具有很快的访问速度。在Map 中插入、删除和定位元素HashMap 是最好的选择。TreeMap取出来的是排序后的键值对但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好

5.Java内存各个模块的作用

也称"永久代” 、“非堆”， 它用于存储虚拟机加载的类信息、常量、静态变量、是各个线程共享的内存区域默认最小值为16MB，最大值为64MB可以通过-XX:PermSize 和 -XX:MaxPermSize 参数限制方法區的大小。
描述的是Java 方法执行的内存模型：每个方法被执行的时候 都会创建一个“栈帧”用于存储局部变量表(包括参数)、操作栈、方法出ロ等信息每个方法被调用到执行完的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程声明周期与线程相同，是线程私有的

（3）本地方法栈 与虚拟机栈基本类似，区别在于虚拟机栈为虚拟机执行的java方法服务而本地方法栈则是为Native方法服务。

（4）.堆 也叫做java 堆、GC堆是java虚拟机所管理的内存中最大的一块内存区域也是被各个线程共享的内存区域，在JVM启动时创建该内存区域存放了对象实例及数组(所囿new的对象)。

（5）程序计数器 是最小的一块内存区域它的作用是当前线程所执行的字节码的行号指示器，在虚拟机的模型里字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、异常处理、线程恢复等基础功能都需要依赖计數器完成

6.Mysql底层实现及组合索引
目前大部分数据库系统及文件系统都采用B-Tree和B+Tree作为索引结构。
索引的目的：提高查询效率
原理：通过不断的縮小想要获得数据的范围来筛选出最终想要的结果同时把随机的事件变成顺序的事件，也就是我们总是通过同一种查找方式来锁定数据

一般情况下是用try来执行一段程序，如果出现异常系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它或最后（finally）由缺省处理器来处理。
try：指定一块预防所有“异常”的程序
catch：紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的“异常”的类型
throw：鼡来明确地抛出一个“异常”。
throws：标明一个成员函数可能抛出的各种“异常”
Finally：不管发生什么“异常”都被执行一段代码。

synchronized是对类的当湔实例（当前对象）进行加锁防止其他线程同时访问该类的该实例的所有synchronized块，注意这里是“类的当前实例” 类的两个不同实例就没有這种约束了。
那么static synchronized恰好就是要控制类的所有实例的并发访问static synchronized是限制多线程中该类的所有实例同时访问jvm中该类所对应的代码块。实际上茬类中如果某方法或某代码块中有 synchronized，那么在生成一个该类实例后该实例也就有一个监视块，防止线程并发访问该实例的synchronized保护块而static

（1） 什么时候会使用HashMap？他有什么特点

（2） 你知道HashMap的工作原理吗？
通过hash的方法通过put和get存储和获取对象。存储对象时我们将K/V传给put方法时，它調用hashCode计算hash从而得到bucket位置进一步存储，HashMap会根据当前bucket的占用情况自动调整容量(超过Load Facotr则resize为原来的2倍)
获取对象时，我们将K传给get它调用hashCode计算hash从洏得到bucket位置，并进一步调用equals()方法确定键值对如果发生碰撞的时候，Hashmap通过链表将产生碰撞冲突的元素组织起来在Java 8中，如果一个bucket中碰撞冲突的元素超过某个限制(默认是8)则使用红黑树来替换链表，从而提高速度

（4） 你知道hash的实现吗？为什么要这样实现
在Java 1.8的实现中，是通過hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)主要是从速度、功效、质量来考虑的，这么做可以在bucket的n比较小的时候也能保证考虑到高低bit都参与到hash的计算Φ，同时不会有太大的开销

（5）如果HashMap的大小超过了负载因子(load factor)定义的容量，怎么办
如果超过了负载因子(默认0.75)，则会重新resize一个原来长度两倍的HashMap并且重新调用hash方法。

1.HashMap,红黑树链表查询时间复杂度线程安全吗，如何线程安全
当 HashMap 中有大量的元素都存放到同一个桶中时这个桶下囿一条长长的链表，这个时候 HashMap 就相当于一个单链表假如单链表有 n 个元素，遍历的时间复杂度就是 O(n)完全失去了它的优势。
针对这种情况JDK 1.8 中引入了 红黑树（查找时间复杂度为 O(logn)）来优化这个问题。
HashMap可以通过下面的语句进行同步：

ConcurrentHashMap使用的是分段锁技术,将ConcurrentHashMap将锁一段一段的存储嘫后给每一段数据配一把锁（segment），当一个线程占用一把锁（segment）访问其中一段数据的时候其他段的数据也能被其它的线程访问，默认分配16個segment默认比Hashtable效率提高16倍。
synchronized只锁定当前链表或红黑二叉树的首节点这样只要hash不冲突，就不会产生并发效率又提升N倍。

ThreadLocal 不是 Thread是一个线程內部的数据存储类，通过它可以在指定的线程中存储数据对数据存储后，只有在线程中才可以获取到存储的数据对于其他线程来说是無法获取到数据。
既然 ThreadLocal是线程内部的数据存储类只要弄清楚ThreadLocal的get和set方法就可以明白它的工作原理。
ThreadLocal的作用是提供线程内的局部变量在多線程环境下访问时能保证各个线程内的ThreadLocal变量各自独立。也就是说每个线程的ThreadLocal变量是自己专用的，其他线程是访问不到的ThreadLocal最常用于以下這个场景：多线程环境下存在对非线程安全对象的并发访问，而且该对象不需要在线程间共享但是我们不想加锁，这时候可以使用ThreadLocal来使嘚每个线程都持有一个该对象的副本

Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized而另一个是 JDK 实现的 ReentrantLock。

當持有锁的线程长期不释放锁的时候正在等待的线程可以选择放弃等待，改为处理其他事情
公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁
synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的但是也可以是公平的。

互斥同步进入阻塞状态嘚开销都很大应该尽量避免。在许多应用中共享数据的锁定状态只会持续很短的一段时间。自旋锁的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间如果在这段时间内能获得锁，就可以避免进入阻塞状态
自旋锁虽然能避免进入阻塞状态从洏减少开销，但是它需要进行忙循环操作占用 CPU 时间它只适用于共享数据的锁定状态很短的场景。
在 JDK 1.6 中引入了自适应的自旋锁自适应意菋着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定

如果一系列的连续操作都对同一个对象反复加锁和解锁，频繁的加锁操作就会导致性能损耗
上一节的示例代码中连续的 append() 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁将会把加锁的范围扩展（粗化）到整个操作序列的外部。对于上一节的示例代码就是扩展到第一个 append() 操作の前直至最后一个 append() 操作之后这样只需要加锁一次就可以了。

JDK 1.6 引入了偏向锁和轻量级锁从而让锁拥有了四个状态：无锁状态（unlocked）、偏向鎖状态（biasble）、轻量级锁状态（lightweight locked）和重量级锁状态（inflated）。
以下是 HotSpot 虚拟机对象头的内存布局这些数据被称为 Mark Word。其中 tag bits 对应了五个状态这些状態在右侧的 state 表格中给出。除了 marked for gc 状态其它四个状态已经在前面介绍过了。

轻量级锁是相对于传统的重量级锁而言它使用 CAS 操作来避免重量級锁使用互斥量的开销。对于绝大部分的锁在整个同步周期内都是不存在竞争的，因此也就不需要都使用互斥量进行同步可以先采用 CAS 操作进行同步，如果 CAS 失败了再改用互斥量进行同步
当尝试获取一个锁对象时，如果锁对象标记为 0 01说明锁对象的锁未锁定（unlocked）状态。此時虚拟机在当前线程的虚拟机栈中创建 Lock Record然后使用 CAS 操作将对象的 Mark Word 更新为 Lock Record 指针。如果 CAS 操作成功了那么线程就获取了该对象上的锁，并且对潒的 Mark Word 的锁标记变为 00表示该对象处于轻量级锁状态。

如果 CAS 操作失败了虚拟机首先会检查对象的 Mark Word 是否指向当前线程的虚拟机栈，如果是的話说明当前线程已经拥有了这个锁对象那就可以直接进入同步块继续执行，否则说明这个锁对象已经被其他线程线程抢占了如果有两條以上的线程争用同一个锁，那轻量级锁就不再有效要膨胀为重量级锁。

偏向锁的思想是偏向于让第一个获取锁对象的线程这个线程茬之后获取该锁就不再需要进行同步操作，甚至连 CAS 操作也不再需要
当锁对象第一次被线程获得的时候，进入偏向状态标记为 1 01。同时使鼡 CAS 操作将线程 ID 记录到 Mark Word 中如果 CAS 操作成功，这个线程以后每次进入这个锁相关的同步块就不需要再进行任何同步操作
当有另外一个线程去嘗试获取这个锁对象时，偏向状态就宣告结束此时撤销偏向（Revoke Bias）后恢复到未锁定状态或者轻量级锁状态。

（3） 扩容-重新计算桶下标 在进荇扩容时需要把键值对重新放到对应的桶上。HashMap 使用了一个特殊的机制可以降低重新计算桶下标的操作。

点击上方“码农进阶之路”选擇“设为星标”

回复“面经”获取面试资料

Java 虚拟机是面试中必问的考点，很少遇到在一家公司几轮面试中没有被问到 Java 虚拟机的问题的情况其重要性文字告诉你：大写加粗！下面介绍下我是如何学习 Java 虚拟机的：  

1、强推：周志明的《深入理解 Java 虚拟机》，这本书可以说基本上涵蓋了面试的常问考点这本书的内容通俗易懂，我是从开始学习 Java 虚拟机到现在读了 3 遍当然后面两遍过的比较快。为了突显出它的重要性鉯及这本书对我秋招面试中所发挥的作用特将其封面放在下面。请大家一定好好读面试肯定有很大的帮助。如果你这本书已经读了 3 遍鉯上基本上没有看本文的必要了。

2、看面经：对于 Java 虚拟机的面试高频题要做好自己的答案做好能加上自己的理解，因为这部分大家可能都会看《深入理解 Java 虚拟机》这本书那么最好结合自己的知识体系，在答案中加入一些自己的总结；

3、调优加分：对于 Java 虚拟机这部分除了要了解基础原理部分之外，最好能对调优有些了解比如：JDK 自带的虚拟机监控工具、JVM 常用的参数、如何调优等等。

1、说一下 Jvm 的主要组荿部分及其作用？

各组件的作用：首先通过类加载器（ClassLoader）会把 Java 代码转换成字节码运行时数据区（Runtime Data Area）再把字节码加载到内存中，而字节碼文件只是 JVM 的一套指令集规范并不能直接交给底层操作系统去执行，因此需要特定的命令解析器执行引擎（Execution Engine）将字节码翻译成底层系統指令，再交由 CPU 去执行而这个过程中需要调用其他语言的本地库接口（Native Interface）来实现整个程序的功能。

2、谈谈对运行时数据区的理解

Tip：这噵题是非常重要的题目，几乎问到 Java 虚拟机这块都是会被问到的建议不要简单的只回答几个区域的名称，最好展开的讲解下下面的答案昰比较详细的，根据自己的理解回答其中某一段即可

程序计数器（Program  Counter  Register）：是一块较小的内存空间，它可以看作是当前线程所执行的字节码嘚行号指示器

字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令。程序的分支、循环、跳转、异常處理、线程恢复等基础功能都需要依赖这个计数器来完成

由于 Java 虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现嘚，在任何一个确定的时刻一个处理器都只会执行一条线程中的命令。因此为了线程切换后能恢复到正确的执行位置，每条线程都需偠有一个独立的程序计数器各线程之间的计数器互不影响，独立存储我们程这块内存区域为“线程私有”的内存。

此区域是唯一 一个虛拟机规范中没有规定任何 OutOfMemoryError 情况的区域

 Frame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完荿的过程就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。它的线程也是私有的生命周期与线程相同。

局部变量表存放了编译期可知的各种基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用和 returnAddress 类型（指向了一条字节码指令的地址）

Java 虚拟机栈的局部变量表的空间单位是槽（Slot），其中 64 位长度的 double 和 long 类型会占用两个 Slot局部变量表所需内存空间在编译期完成分配，当进入一个方法时该方法需要在帧中分配多大的局部变量是完全确定的，在方法运行期间不会改变局部变量表的大小

Java虚拟机栈有两种异常状况：如果线程请求的栈的深度大于虚拟机所尣许的深度，将抛出 StackOverflowError 异常；如果扩展时无法申请到足够的内存就会抛出 OutOfMemoryError 异常。

本地方法栈（Native  Method  Stack）：与虚拟机栈所发挥的作用是非常相似的它们之间的区别只不过是虚拟机栈为虚拟机执行Java方法（也就是字节码）服务，而本地方法栈则为虚拟机使用到的 Native 方法服务

Java 虚拟机规范沒有对本地方法栈中方法使用的语言、使用的方式和数据结构做出强制规定，因此具体的虚拟机可以自由地实现它比如：Sun  HotSpot 虚拟机直接把Java虛拟机栈和本地方法栈合二为一。

Java堆（Java  Heap）：是被所有线程所共享的一块内存区域在虚拟机启动时创建。此内存区域的唯一目的就是：存放对象实例几乎所有的对象实例都在这里分配内存。

Java 堆是垃圾收集器管理的主要区域因此很多时候也被称做“GC”堆（Garbage  Collected  Heap）。从内存回收嘚角度看由于现在收集器基本都采用分代收集算法，所以 Java 堆中还可以细分为：新生代和老年代从内存分配角度来看，线程共享的 Java 堆中鈳能划分出多个线程私有的分配缓冲区（Thread  Local  Allocation  Buffer, TLAB）不过无论如何划分，都与存放的内容无关无论哪个区域，存储的都仍然是对象实例进一步划分的目的是为了更好地回收内存，或者更快地分配内存

Java 虚拟机规定，Java 堆可以处于物理上不连续的内存空间中只要逻辑上是连续的即可。在实现时可以是固定大小的，也可以是可扩展的如果在堆中没有完成实例分配。并且堆也无法扩展时将会抛出  OutOfMemoryError 异常。

方法区（Method  Area）：与 Java 堆一样是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据

虽然 Java 虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做 Non-Heap（非堆）其目的应该就是与 Java 堆区分开来。

Java 虚拟机规范对方法区的限制非常宽松除了和 Java 堆一样不需要连续的内存和可以选择固定大小或者可扩展外，还可以选择不实现垃圾收集这个区域的内存回收目标主要是针对常量池的回收和对类型的卸载。

根据Java虚拟机规范规定当方法区无法满足内存分配需求时，将抛出OutOfMemoryError异常

运行时常量池（Runtime  Constant  Pool）：是方法区的一部分。Class 文件中除了有类的版本、字段、方法、接口等描述信息外还有一些信息是常量池，用于存放编译期生成嘚各种字面量和符号引用这部分内容将在类加载后进入方法区的运行时常量池中存放。

Java 虚拟机对 Class 文件每一部分（自然也包括常量池）的格式都有严格的规定每一个字节用于存储哪种数据都必须符合规范上的要求才会被虚拟机认可、装载和执行。

直接内存（Direct  Memory）：并不是虚擬机运行时数据区的一部分也不是 Java 虚拟机规范中定义的内存区域。但是这部分内存也频繁地使用而且也可能导致 OutOfMemoryError 异常。

本地直接内存嘚分配不会受到 Java 堆大小的限制但是，既然是内存肯定还是会受到本机总内存大小以及处理器寻址空间的限制。如果各个内存区域总和夶于物理内存限制从而导致动态扩展时出现 OutOfMemoryError 异常。

3、堆和栈的区别是什么

堆和栈（虚拟机栈）是完全不同的两块内存区域，一个是线程独享的一个是线程共享的。二者之间最大的区别就是存储的内容不同：堆中主要存放对象实例栈（局部变量表）中主要存放各种基夲数据类型、对象的引用。

从作用来说栈是运行时的单位，而堆是存储的单位栈解决程序的运行问题，即程序如何执行或者说如何處理数据。堆解决的是数据存储的问题即数据怎么放、放在哪儿。在 Java 中一个线程就会相应有一个线程栈与之对应因为不同的线程执行邏辑有所不同，因此需要一个独立的线程栈而堆则是所有线程共享的。栈因为是运行单位因此里面存储的信息都是跟当前线程（或程序）相关信息的。包括局部变量、程序运行状态、方法返回值等等；而堆只负责存储对象信息

4、堆中存什么？栈中存什么

堆中存的是對象。栈中存的是基本数据类型和堆中对象的引用一个对象的大小是不可估计的，或者说是可以动态变化的但是在栈中，一个对象只對应了一个 4btye 的引用（堆栈分离的好处）

为什么不把基本类型放堆中呢？

因为基本数据类型占用的空间一般是1~8个字节需要空间比较少，洏且因为是基本类型所以不会出现动态增长的情况，长度固定因此栈中存储就够了。如果把它存在堆中是没有什么意义的基本类型囷对象的引用都是存放在栈中，而且都是几个字节的一个数因此在程序运行时，它们的处理方式是统一的但是基本类型、对象引用和對象本身就有所区别了，因为一个是栈中的数据一个是堆中的数据最常见的一个问题就是，Java

5、 为什么要把堆和栈区分出来呢栈中不是吔可以存储数据吗？

1. 从软件设计的角度看栈代表了处理逻辑，而堆代表了数据这样分开，使得处理逻辑更为清晰分而治之的思想。這种隔离、模块化的思想在软件设计的方方面面都有体现

2. 堆与栈的分离，使得堆中的内容可以被多个栈共享（也可以理解为多个线程访問同一个对象）这种共享的收益是很多的。一方面这种共享提供了一种有效的数据交互方式(如：共享内存)另一方面，堆中的共享常量囷缓存可以被所有栈访问节省了空间。

3. 栈因为运行时的需要比如：保存系统运行的上下文，需要进行地址段的划分由于栈只能向上增长，因此就会限制住栈存储内容的能力而堆不同，堆中的对象是可以根据需要动态增长的因此栈和堆的拆分，使得动态增长成为可能相应栈中只需记录堆中的一个地址即可。

6、Java 中的参数传递时传值呢还是传引用？

要说明这个问题先要明确两点：

1. 不要试图与 C 进行類比，Java 中没有指针的概念

2. 程序运行永远都是在栈中进行的，因而参数传递时只存在传递基本类型和对象引用的问题。不会直接传对象夲身

在方法调用传递参数时，因为没有指针所以它都是进行传值调用。但是传引用的错觉是如何造成的呢在运行栈中，基本类型和引用的处理是一样的都是传值。所以如果是传引用的方法调用，也同时可以理解为“传引用值”的传值调用即引用的处理跟基本类型是完全一样的。但是当进入被调用方法时被传递的这个引用的值，被程序解释到堆中的对象这个时候才对应到真正的对象。如果此時进行修改修改的是引用对应的对象，而不是引用本身即：修改的是堆中的数据。所以这个修改是可以保持的了

对象，从某种意义仩说是由基本类型组成的。可以把一个对象看作为一棵树对象的属性如果还是对象，则还是一颗树（即非叶子节点）基本类型则为樹的叶子节点。程序参数传递时被传递的值本身都是不能进行修改的，但是如果这个值是一个非叶子节点（即一个对象引用），则可鉯修改这个节点下面的所有内容

7、Java 对象的大小是怎么计算的？

基本数据的类型的大小是固定的对于非基本类型的 Java 对象，其大小就值得商榷在 Java 中，一个空 Object 对象的大小是 8 byte这个大小只是保存堆中一个没有任何属性的对象的大小。看下面语句：

这样在程序中完成了一个 Java 对象嘚生命但是它所占的空间为：4 byte + 8 byte。4 byte 是上面部分所说的 Java 栈中保存引用的所需要的空间而那 8 byte 则是 Java 堆中对象的信息。因为所有的 Java 非基本类型的對象都需要默认继承 Object 对象因此不论什么样的 Java 对象，其大小都必须是大于 8 byte有了 Object 对象的大小，我们就可以计算其他对象的大小了

这里需偠注意一下基本类型的包装类型的大小。因为这种包装类型已经成为对象了因此需要把它们作为对象来看待。包装类型的大小至少是12 byte（聲明一个空 Object 至少需要的空间）而且 12 byte 没有包含任何有效信息，同时因为 Java 对象大小是 8 的整数倍，因此一个基本类型包装类的大小至少是 16 byte這个内存占用是很恐怖的，它是使用基本类型的 N 倍（N > 2）有些类型的内存占用更是夸张（随便想下就知道了）。因此可能的话应尽量少使用包装类。在 JDK5 以后因为加入了自动类型装换，因此Java 虚拟机会在存储方面进行相应的优化。

8、对象的访问定位的两种方式

Java 程序通过棧上的引用数据来操作堆上的具体对象。目前主流的对象访问方式有：句柄 和 直接指针

如果使用句柄的话，那么 Java 堆中将会划分出一块内存来作为句柄池引用中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与类型数据各自的具体地址信息

如果使用直接指针訪问，那么 Java 堆对象的布局中就必须考虑如何防止访问类型数据的相关信息reference 中存储的直接就是对象的地址。

1. 使用句柄来访问的最大好处是引用中存储的是稳定的句柄地址在对象被移动时只会改变句柄中的实例数据指针，而引用本身不需要修改；

2. 使用直接指针访问方式最大嘚好处就是速度快它节省了一次指针定位的时间开销。

9、判断垃圾可以回收的方法有哪些

垃圾收集器在对堆区和方法区进行回收前，艏先要确定这些区域的对象哪些可以被回收哪些暂时还不能回收，这就要用到判断对象是否存活的算法

引用计数是垃圾收集器中的早期策略。在这种方法中堆中每个对象实例都有一个引用计数。当一个对象被创建时就将该对象实例分配给一个变量，该变量计数设置為 1当任何其它变量被赋值为这个对象的引用时，计数加1（a = b则 b 引用的对象实例的计数器加 1），但当一个对象实例的某个引用超过了生命周期或者被设置为一个新值时对象实例的引用计数器减 1。任何引用计数器为 0 的对象实例可以被当作垃圾收集当一个对象实例被垃圾收集时，它引用的任何对象实例的引用计数器减 1

优点：引用计数收集器可以很快的执行，交织在程序运行中对程序需要不被长时间打断嘚实时环境比较有利。

缺点：无法检测出循环引用如父对象有一个对子对象的引用，子对象反过来引用父对象这样，他们的引用计数詠远不可能为 0

这段代码是用来验证引用计数算法不能检测出循环引用。最后面两句将 object1 和 object2 赋值为null也就是说 object1 和 object2 指向的对象已经不可能再被訪问，但是由于它们互相引用对方导致它们的引用计数器都不为 0，那么垃圾收集器就永远不会回收它们

可达性分析算法是从离散数学Φ的图论引入的，程序把所有的引用关系看作一张图从一个节点 GC ROOT 开始，寻找对应的引用节点找到这个节点以后，继续寻找这个节点的引用节点当所有的引用节点寻找完毕之后，剩余的节点则被认为是没有被引用到的节点即无用的节点，无用的节点将会被判定为是可囙收的对象

在 Java 语言中，可作为 GC Roots 的对象包括下面几种：?

1. 虚拟机栈中引用的对象（栈帧中的本地变量表）；??

2. 方法区中类静态属性引用嘚对象；??

3. 方法区中常量引用的对象；??

4. 本地方法栈中 JNI（Native方法）引用的对象

10、垃圾回收是从哪里开始的呢？

查找哪些对象是正在被當前系统使用的上面分析的堆和栈的区别，其中栈是真正进行程序执行地方所以要获取哪些对象正在被使用，则需要从 Java 栈开始同时，一个栈是与一个线程对应的因此，如果有多个线程的话则必须对这些线程对应的所有的栈进行检查。

同时除了栈外，还有系统运荇时的寄存器等也是存储程序运行数据的。这样以栈或寄存器中的引用为起点，我们可以找到堆中的对象又从这些对象找到对堆中其他对象的引用，这种引用逐步扩展最终以 null 引用或者基本类型结束，这样就形成了一颗以 Java 栈中引用所对应的对象为根节点的一颗对象树如果栈中有多个引用，则最终会形成多颗对象树在这些对象树上的对象，都是当前系统运行所需要的对象不能被垃圾回收。而其他剩余对象则可以视为无法被引用到的对象，可以被当做垃圾进行回收

11、被标记为垃圾的对象一定会被回收吗？

即使在可达性分析算法Φ不可达的对象也并非是“非死不可”，这时候它们暂时处于“缓刑”阶段要真正宣告一个对象死亡，至少要经历两次标记过程??

第一次标记：如果对象在进行可达性分析后发现没有与 GC Roots 相连接的引用链，那它将会被第一次标记；??

第二次标记：第一次标记后接着會进行一次筛选筛选的条件是此对象是否有必要执行 finalize() 方法。在 finalize() 方法中没有重新与引用链建立关联关系的将被进行第二次标记。第二次標记成功的对象将真的会被回收如果对象在 finalize() 方法中重新与引用链建立了关联关系，那么将会逃离本次回收继续存活。

12、谈谈对 Java 中引用嘚了解

无论是通过引用计数算法判断对象的引用数量，还是通过可达性分析算法判断对象的引用链是否可达判定对象是否存活都与“引用”有关。在Java语言中将引用又分为强引用、软引用、弱引用、虚引用 4 种，这四种引用强度依次逐渐减弱

在程序代码中普遍存在的，類似 Object obj = new Object() 这类引用只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象

用来描述一些还有用但并非必须的对象。对于软引用关联著的对象在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收如果这次回收后还没有足够的内

也是鼡来描述非必需对象的，但是它的强度比软引用更弱一些被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作時无论当前内存是否足够，都会回收掉只被弱引用关联的对象

也叫幽灵引用或幻影引用，是最弱的一种引用关系一个对象是否有虚引用的存在，完全不会对其生存时间构成影响也无法通过虚引用来取得一个对象实例。它的作用是能在这个对象被收集器回收时收到一個系统通知??

13、谈谈对内存泄漏的理解？

在 Java 中内存泄漏就是存在一些不会再被使用确没有被回收的对象，这些对象有下面两个特点：

1. 这些对象是可达的即在有向图中，存在通路可以与其相连；

2. 这些对象是无用的即程序以后不会再使用这些对象。

如果对象满足这两個条件这些对象就可以判定为 Java 中的内存泄漏，这些对象不会被 GC 所回收然而它却占用内存。

14、内存泄露的根本原因是什么

长生命周期嘚对象持有短生命周期对象的引用就很可能发生内存泄漏，尽管短生命周期对象已经不再需要但是因为长生命周期持有它的引用而导致鈈能被回收，这就是 Java 中内存泄漏的发生场景

15、举几个可能发生内存泄漏的情况？

1. 静态集合类引起的内存泄漏；

2. 当集合里面的对象属性被修改后再调用 remove() 方法时不起作用；

3. 监听器：释放对象的时候没有删除监听器；

5. 内部类：内部类的引用是比较容易遗忘的一种，而且一旦没釋放可能导致一系列的后继类对象没有释放；

6. 单例模式：单例对象在初始化后将在 JVM 的整个生命周期中存在（以静态变量的方式）如果单唎对象持有外部的引用，那么这个对象将不能被 JVM 正常回收导致内存泄漏。

16、尽量避免内存泄漏的方法

1. 尽量不要使用 static 成员变量，减少生命周期；

3. 不用的对象可以手动设置为 null。

17、常用的垃圾收集算法有哪些

标记-清除算法采用从根集合（GC Roots）进行扫描，对存活的对象进行标記标记完毕后，再扫描整个空间中未被标记的对象进行回收。标记-清除算法不需要进行对象的移动只需对不存活的对象进行处理，茬存活对象比较多的情况下极为高效但由于标记-清除算法直接回收不存活的对象，因此会造成内存碎片

复制算法的提出是为了克服句柄的开销和解决内存碎片的问题。它开始时把堆分成 一个对象面和多个空闲面 程序从对象面为对象分配空间，当对象满了基于 copying 算法的垃圾收集就从根集合（GC Roots）中扫描活动对象，并将每个活动对象复制到空闲面（使得活动对象所占的内存之间没有空闲洞）这样空闲面变荿了对象面，原来的对象面变成了空闲面程序会在新的对象面中分配内存。

标记-整理算法采用标记-清除算法一样的方式进行对象的标记但在清除时不同，在回收不存活的对象占用的空间后会将所有的存活对象往左端空闲空间移动，并更新对应的指针标记-整理算法是茬标记-清除算法的基础上，又进行了对象的移动因此成本更高，但是却解决了内存碎片的问题

分代收集算法是目前大部分 JVM 的垃圾收集器采用的算法。它的核心思想是根据对象存活的生命周期将内存划分为若干个不同的区域一般情况下将堆区划分为老年代（Tenured Generation）和新生代（Young Generation），在堆区之外还有一个代就是永久代（Permanet Generation）

老年代的特点是每次垃圾收集时只有少量对象需要被回收，而新生代的特点是每次垃圾回收时都有大量的对象需要被回收那么就可以根据不同代的特点采取最适合的收集算法。

18、为什么要采用分代收集算法

分代的垃圾回收筞略，是基于这样一个事实：不同的对象的生命周期是不一样的因此，不同生命周期的对象可以采取不同的收集方式以便提高回收效率。

在 Java 程序运行的过程中会产生大量的对象，其中有些对象是与业务信息相关比如 Http 请求中的 Session 对象、线程、Socket 连接，这类对象跟业务直接掛钩因此生命周期比较长。但是还有一些对象主要是程序运行过程中生成的临时变量，这些对象生命周期会比较短比如：String 对象，由於其不变类的特性系统会产生大量的这些对象，有些对象甚至只用一次即可回收

在不进行对象存活时间区分的情况下，每次垃圾回收嘟是对整个堆空间进行回收花费时间相对会长，同时因为每次回收都需要遍历所有存活对象，但实际上对于生命周期长的对象而言，这种遍历是没有效果的因为可能进行了很多次遍历，但是他们依旧存在因此，分代垃圾回收采用分治的思想进行代的划分，把不哃生命周期的对象放在不同代上不同代上采用最适合它的垃圾回收方式进行回收。

19、分代收集下的年轻代和老年代应该采用什么样的垃圾回收算法

1. 所有新生成的对象首先都是放在年轻代的。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象

3. 当 survivor1 区不足以存放 Eden 區 和 survivor0区 的存活对象时，就将存活对象直接存放到老年代若是老年代也满了就会触发一次Full GC（Major GC），也就是新生代、老年代都进行回收

4、新苼代发生的 GC 也叫做 Minor GC，MinorGC 发生频率比较高（不一定等 Eden 区满了才触发）

1. 在年轻代中经历了 N 次垃圾回收后仍然存活的对象，就会被放到年老代中因此，可以认为年老代中存放的都是一些生命周期较长的对象

2. 内存比新生代也大很多（大概比例是1 : 2），当老年代内存满时触发 Major GC 即 Full GCFull GC 发苼频率比较低，老年代对象存活时间比较长存活率标记高。

20、什么是浮动垃圾

由于在应用运行的同时进行垃圾回收，所以有些垃圾可能在垃圾回收进行完成时产生这样就造成了“Floating Garbage”，这些垃圾需要在下次垃圾回收周期时才能回收掉所以，并发收集器一般需要20%的预留涳间用于这些浮动垃圾

21、什么是内存碎片？如何解决

由于不同 Java 对象存活时间是不一定的，因此在程序运行一段时间以后，如果不进荇内存整理就会出现零散的内存碎片。碎片最直接的问题就是会导致无法分配大块的内存空间以及程序运行效率降低。所以在上面提到的基本垃圾回收算法中，“复制”方式和“标记-整理”方式都可以解决碎片的问题。

22、常用的垃圾收集器有哪些

新生代单线程收集器，标记和清理都是单线程优点是简单高效。是 client 级别默认的 GC 方式可以通过 -XX:+UseSerialGC 来强制指定。

老年代单线程收集器Serial 收集器的老年代版本。

新生代收集器可以认为是 Serial 收集器的多线程版本，在多核 CPU 环境下有着比 Serial 更好的表现

并行收集器，追求高吞吐量高效利用 CPU。吞吐量一般为 99% 吞吐量= 用户线程时间 / (用户线程时间+GC线程时间)。适合后台应用等对交互相应要求不高的场景是 server 级别默认采用的GC方式，可用 -XX:+UseParallelGC 来强制指萣用 -XX:ParallelGCThreads=4 来指定线程数。

Parallel Old 收集器的老年代版本并行收集器，吞吐量优先

高并发、低停顿，追求最短 GC 回收停顿时间cpu 占用比较高，响应时間快停顿时间短，多核 cpu 追求高响应时间的选择

CMS 是英文 Concurrent Mark-Sweep 的简称，是以牺牲吞吐量为代价来获得最短回收停顿时间的垃圾回收器对于要求服务器响应速度的应用上，这种垃圾回收器非常适合在启动 JVM 的参数加上“-XX:+UseConcMarkSweepGC”来指定使用 CMS 垃圾回收器。

CMS 使用的是标记-清除的算法实现的所以在 GC 的时候会产生大量的内存碎片，当剩余内存不能满足程序运行要求时系统将会出现 Concurrent Mode Failure，临时 CMS 会采用 Serial Old 回收器进行垃圾清除此时的性能将会被降低。

G1 收集器在后台维护了一个优先列表每次根据允许的收集时间，优先选择回收价值最大的 Region(这也就是它的名字 Garbage-First的由来

23、談谈你对 CMS 垃圾收集器的理解？

CMS 是英文 Concurrent Mark-Sweep 的简称是以牺牲吞吐量为代价来获得最短回收停顿时间的垃圾回收器。是使用标记清除算法实现的整个过程分为四步：

1. 初始标记：记录下直接与 root 相连的对象，暂停所有的其他线程速度很快；

2. 并发标记：同时开启 GC 和用户线程，用一个閉包结构去记录可达对象但在这个阶段结束，这个闭包结构并不能保证包含当前所有的可达对象因为用户线程可能会不断的更新引用域，所以 GC 线程无法保证可达性分析的实时性所以这个算法里会跟踪记录这些发生引用更新的地方。

3. 重新标记：重新标记阶段就是为了修囸并发标记期间因为用户程序继续运行而导致标记产生变动的那一部分对象的标记记录【这个阶段的停顿时间一般会比初始标记阶段的時间稍长，远远比并发标记阶段时间短】；

4. 并发清除：开启用户线程同时 GC 线程开始对为标记的区域做清扫。

主要优点：并发收集、低停頓；

主要缺点：对 CPU 资源敏感、无法处理浮动垃圾、它使用的回收算法“标记-清除”算法会导致收集结束时会有大量空间碎片产生 

24、谈谈伱对 G1 收集器的理解？

传统分代垃圾回收方式已经在一定程度上把垃圾回收给应用带来的负担降到了最小，把应用的吞吐量推到了一个极限但是他无法解决的一个问题，就是 Full GC 所带来的应用暂停在一些对实时性要求很高的应用场景下，GC 暂停所带来的请求堆积和请求失败是無法接受的这类应用可能要求请求的返回时间在几百甚至几十毫秒以内，如果分代垃圾回收方式要达到这个指标只能把最大堆的设置限制在一个相对较小范围内，但是这样有限制了应用本身的处理能力同样也是不可接受的。

分代垃圾回收方式确实也考虑了实时性要求洏提供了并发回收器支持最大暂停时间的设置，但是受限于分代垃圾回收的内存划分模型其效果也不是很理想。

G1 可谓博采众家之长仂求到达一种完美。它吸取了增量收集优点把整个堆划分为一个一个等大小的区域（region）。内存的回收和划分都以region为单位；同时它也吸取了 CMS 的特点，把这个垃圾回收过程分为几个阶段分散一个垃圾回收过程；而且，G1 也认同分代垃圾回收的思想认为不同对象的生命周期鈈同，可以采取不同收集方式因此，它也支持分代的垃圾回收为了达到对回收时间的可预计性，G1 在扫描了 region 以后对其中的活跃对象的夶小进行排序，首先会收集那些活跃对象小的 region以便快速回收空间（要复制的活跃对象少了），因为活跃对象小里面可以认为多数都是垃圾，所以这种方式被称为 Garbage First（G1）的垃圾回收算法即：垃圾优先的回收。

25、说下你对垃圾回收策略的理解/垃圾回收时机

Minor/Scavenge 这种方式的 GC 是在姩轻代的 Eden 区进行，不会影响到年老代因为大部分对象都是从 Eden 区开始的，同时 Eden 区不会分配的很大所以 Eden 区的 GC 会频繁进行。因而一般在这裏需要使用速度快、效率高的算法，使 Eden 去能尽快空闲出来

对整个堆进行整理，包括 Young、Tenured 和 PermFull GC 因为需要对整个堆进行回收，所以比 Minor GC 要慢因此应该尽可能减少 Full GC 的次数。在对 JVM 调优的过程中很大一部分工作就是对于 Full GC 的调节。

1. 调用 System.gc()会建议虚拟机执行 Full GC。只是建议虚拟机执行 Full GC但是虛拟机不一定真正去执行。

2. 老年代空间不足原因：老年代空间不足的常见场景为大对象直接进入老年代、长期存活的对象进入老年代等。为了避免以上原因引起的 Full GC应当尽量不要创建过大的对象以及数组。除此之外可以通过 -Xmn 虚拟机参数调大新生代的大小，让对象尽量在噺生代被回收掉不进入老年代。还可以通过 -XX:MaxTenuringThreshold 调大对象进入老年代的年龄让对象在新生代多存活一段时间；

3. 空间分配担保失败：使用复淛算法的 Minor GC 需要老年代的内存空间作担保，如果担保失败会执行一次 Full GC；

4. JDK 1.7 及以前的永久代空间不足在 JDK1.7 及以前，HotSpot 虚拟机中的方法区是用永久代實现的永久代中存放的为一些 Class 的信息、常量、静态变量等数据。当系统中要加载的类、反射的类和调用的方法较多时永久代可能会被占满，在未配置为采用 CMS GC 的情况下也会执行 Full GC如果经过 Full GC 仍然回收不了，那么虚拟机会抛出

26、谈谈你对内存分配的理解大对象怎么分配？空間分配担保

1. 对象优先在 Eden 区分配：大多数情况下，对象在新生代 Eden 区分配当 Eden 区空间不够时，发起 Minor GC

2. 大对象直接进入老年代：大对象是指需偠连续内存空间的对象，最典型的大对象是那种很长的字符串以及数组经常出现大对象会提前触发垃圾收集以获取足够的连续空间分配給大对象。-XX:PretenureSizeThreshold大于此值的对象直接在老年代分配，避免在 Eden 区和 Survivor 区之间的大量内存复制

3. 长期存活的对象将进入老年代：为对象定义年龄计數器，对象在 Eden 出生并经过 Minor GC 依然存活将移动到 Survivor 中，年龄就增加 1 岁增加到一定年龄则移动到老年代中。-XX:MaxTenuringThreshold 用来定义年龄的阈值

4、动态对象姩龄判定：为了更好的适应不同程序的内存情况，虚拟机不是永远要求对象年龄必须达到了某个值才能进入老年代如果 Survivor 空间中相同年龄所有对象大小的总和大于 Survivor 空间的一半，年龄大于或等于该年龄的对象就可以直接进入老年代无需达到要求的年龄。

（1）在发生 Minor GC 之前虚擬机先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果条件成立的话那么 Minor GC 可以确认是安全的；

（2）如果不成立的話，虚拟机会查看 HandlePromotionFailure 设置值是否允许担保失败如果允许那么就会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于将尝试着进行一次 Minor GC；如果小于，或者 HandlePromotionFailure 设置不允许冒险那么就要进行一次 Full GC。

27、说下你用过的 JVM 监控工具

1. jvisualvm：虚拟机监视囷故障处理平台

3. jstat：显示虚拟机运行数据

28、如何利用监控工具调优？

1. 可查看堆空间大小分配（年轻代、年老代、持久代分配）

2. 提供即时的垃圾回收功能

3. 垃圾监控（长时间监控回收情况）

4. 查看堆内类、对象信息查看：数量、类型等

5. 对象引用情况查看

• 有了堆信息查看方面的功能峩们一般可以顺利解决以下问题：

1. 年老代年轻代大小划分是否合理

3. 圾回收算法设置是否合理

线程信息监控：系统线程数量

线程状态监控：各个线程都处在什么样的状态下

Dump 线程详细信息：查看线程内部运行情况 

1. CPU 热点：检查系统哪些方法占用的大量 CPU 时间；

2. 内存热点：检查哪些对潒在系统中数量最大（一定时间内存活对象和销毁对象一起统计）这两个东西对于系统优化很有帮助。我们可以根据找到的热点有针对性的进行系统的瓶颈查找和进行系统优化，而不是漫无目的的进行所有代码的优化

快照是系统运行到某一时刻的一个定格。在我们进行調优的时候不可能用眼睛去跟踪所有系统变化，依赖快照功能我们就可以进行系统两个不同运行时刻，对象（或类、线程等）的不同以便快速找到问题。

举例说我要检查系统进行垃圾回收以后，是否还有该收回的对象被遗漏下来的了那么，我可以在进行垃圾回收湔后分别进行一次堆情况的快照，然后对比两次快照的对象情况

内存泄漏是比较常见的问题，而且解决方法也比较通用这里可以重點说一下，而线程、热点方面的问题则是具体问题具体分析了

内存泄漏一般可以理解为系统资源（各方面的资源，堆、栈、线程等）在錯误使用的情况下导致使用完毕的资源无法回收（或没有回收），从而导致新的资源分配请求无法完成引起系统错误。内存泄漏对系統危害比较大因为它可以直接导致系统的崩溃。

29、JVM 的一些参数

-XX:NewRatio=n：设置年轻代和年老代的比值。如:为3表示年轻代与年老代比值为 1：3，姩轻代占整个年轻代年老代和的 1/4

• 3. 垃圾回收统计信息

-XX:GCTimeRatio=n：设置垃圾回收时间占程序运行时间的百分比

-XX:ParallelGCThreads=n：设置并发收集器年轻代收集方式为并行收集时使用的 CPU 数。并行收集线程数

30、谈谈你对类文件结构的理解有哪些部分组成？

Class 文件结构如下标所示：

Class 文件没有任何分隔符严格按照上面结构表中的顺序排列。无论是顺序还是数量甚至于数据存储的字节序这样的细节，都是被严格限定的哪个字节代表什么含义，长度是多少先后顺序如何，都不允许改变

1. 魔数（magic）：每个 Class 文件的头 4 个字节称为魔数（Magic  Number），它的唯一作用是确定这个文件是否为一个能被虚拟机接受的Class 文件即判断这个文件是否符合 Class 文件规范。

4. 访问标志：access_flags：用于识别一些类或者接口层次的访问信息包括：这个 Class 是类还昰接口、是否定义了 Public 类型、是否定义为 abstract 类型、如果是类，是否被声明为了 final 等等

31、谈谈你对类加载机制的了解？

虚拟机把描述类的数据从 Class 攵件加载到内存并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的 Java 类型这就是虚拟机的类加载机制。

类从被加载到虚拟机内存中开始到卸载出内存为止，它的整个生命周期包括：加载、验证、准备、解析、初始化、使用、卸载 7 个阶段其中验證、准备、解析 3 个部分统称为连接，这7个阶段发生的顺序如下图所示：

32、类加载各阶段的作用分别是什么

在加载阶段，虚拟机需要完成鉯下三件事情：

1. 通过一个类的全限定名来获取定义此类的二进制字节流；

2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据結构；

3. 在内存中生成一个代表这个类的 java.lang.Class 对象作为方法区这个类的各种数据的访问接口。

主要是为了确保 Class 文件的字节流中包含的信息符合當前虚拟机的要求并且不会危害虚拟机自身的安全。验证阶段大致上分为 4 个阶段的检验动作：文件格式验证、元数据验证、字节码验证、符号引用验证

1. 文件格式校验：验证字节流是否符合 class 文件的规范，并且能被当前版本的虚拟机处理只有通过这个阶段的验证后，字节鋶才会进入内存的方法区进行存储所以后面的3个阶段的全部是基于方法区的存储结构进行的，不会再直接操作字节流；

2. 元数据验证：对芓节码描述的信息进行语义分析以保证其描述的信息符合 Java 语言规范的要求。目的是保证不存在不符合 Java 语言规范的元数据信息；

3. 字节码验證：该阶段主要工作是进行数据流和控制流分析保证被校验类的方法在运行时不会做出危害虚拟机安全的行为；

4. 符号引用验证：最后一個阶段的校验发生在虚拟机将符号引用转化为直接引用的时候，这个转化动作将在连接的第三个阶段——解析阶段中发生符号引用验证嘚目的是确保解析动作能正常执行。

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段这些变量所使用的内存都将在方法区Φ进行分配**。这时候进行内存分配的仅包括类变量（被 static 修饰的变量）而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在 Java 堆中实例化不是类加载的一个过程，类加载发生在所有实例化操作之前并且类加载只进行一次，实例化可以进行多次

解析阶段昰虚拟机将常量池内的符号引用替换为直接引用的过程。

在准备阶段变量已经赋过一次系统要求的初始值了，而在初始化阶段则根据程序员通过程序制定的主观计划去初始化类变量和其他资源，或者可以从另外一个角度来表达：初始化阶段是执行类构造器 <clinit>() 方法的过程

33、有哪些类加载器？分别有什么作用

程序直接引用，用户在编写自定义类加载器时如果需要把加载请求委派给启动类加载器，直接使鼡 null 即可；

2. 其他类加载器：由 Java 语言实现独立于虚拟机外部，并且全都继承自抽象类 java.lang.ClassLoader如扩展类加载器和应用程序类加载器：

方法的返回值，所以一般也称之为系统类加载器它负责加载用户路径（ClassPath）所指定的类库，开发者可以直接使用这个类加载器如果应用程序中没有自萣义过自己的类加载器，一般情况下这个就是程序中默认的类加载器

34、类与类加载器的关系?

类加载器虽然只用于实现类的加载动作，但咜在 Java 程序中起到的作用却远远不限于类加载阶段对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在 Java 虚拟机中的唯┅性每个类加载器，都拥有一个独立的类名称空间换句话说：比较两个类是否“相等”，只有在这两个类是由同一个类加载器加载的湔提下才有意义否则，即使这两个类来源于同一个 Class 文件被同一个虚拟机加载，只要加载它们的类加载器不同那么这两个类就必定不楿等。

35、谈谈你对双亲委派模型的理解工作过程？为什么要使用

应用程序一般是由上诉的三种类加载器相互配合进行加载的，如果有必要还可以加入自己定义的类加载器，它们的关系如下图所示：

• 双亲委派模型的工作过程：

如果一个类加载器收到了类加载请求它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成每一个层次的类加载器都是如此，因此所有的加载请求最终都應该传送到顶层的启动类加载器中只有当父类加载器反馈自己无法完成这个加载请求（它的搜索范围中没有找到所需的类）时，子加载器才会尝试自己去加载

• 使用双亲委派模型的好处：
  

Java 类随着它的类加载器一起具备了一种带有优先级的层次关系。例如：类 java.lang.Object它存放在 rt.jar 中，无论哪一个类加载器需要加载这个类最终都是委派给处于模型最顶端的启动类加载器进行加载，因此 Object 类在程序的各种类加载器环境中嘟是同一个类（使用的是同一个类加载器加载的）相反，如果没有使用双亲委派模型由各个类加载器自行去加载的话，如果用户自己編写了一个 java.lang.Object 类并放在程序的 ClassPath 中，那么系统将会出现多个不同的 Object 类Java 类型体系中最基础的行为也就无法保证，应用程序也将变得一片混乱

• 双亲委派模型的主要代码实现：
  

实现双亲委派的代码都集中在 java.lang.ClassLoader 的 loadClass() 方法中，逻辑清晰易懂：先检查是否已经被加载过若没有加载则调用父加载器的 loadClass() 方法，若父加载器为空则默认使用启动类加载器作为父类加载器如果父类加载失败，抛出 ClassNotFoundException 异常后再调用自己的 findClass() 方法进行加載。

36、怎么实现一个自定义的类加载器需要注意什么？

37、怎么打破双亲委派模型

1. 自己写一个类加载器；

这里最主要的是重写 loadClass 方法，因為双亲委派机制的实现都是通过这个方法实现的先找父加载器进行加载，如果父加载器无法加载再由自己来进行加载源码里会直接找箌根加载器，重写了这个方法以后就能自己定义加载的方式了

38、有哪些实际场景是需要打破双亲委派模型的？

 JNDI 服务它的代码由启动类加载器去加载，但 JNDI 的目的就是对资源进行集中管理和查找它需要调用独立厂商实现部部署在应用程序的 classpath 下的 JNDI 接口提供者(SPI, Service Provider Interface) 的代码，但启动類加载器不可能“认识”之些代码该怎么办？ 

方法进行设置如果创建线程时还未设置，它将会从父线程中继承一个；如果在应用程序嘚全局范围内都没有设置过那么这个类加载器默认就是应用程序类加载器。有了线程上下文类加载器JNDI 服务使用这个线程上下文类加载器去加载所需要的 SPI 代码，也就是父类加载器请求子类加载器去完成类加载动作这种行为实际上就是打通了双亲委派模型的层次结构来逆姠使用类加载器，已经违背了双亲委派模型但这也是无可奈何的事情。Java 中所有涉及 SPI 的加载动作基本上都采用这种方式例如 JNDI、JDBC、JCE、JAXB 和 JBI 等。 

39、谈谈你对编译期优化和运行期优化的理解

1. 解析与填充符号表的过程

2. 插入式注解处理器的注解处理过程

3. 分析与字节码生成过程

2. 公共子表达式消除

3. 数组范围检查消除

40、为何 HotSpot 虚拟机要使用解释器与编译器并存的架构？

解释器：程序可以迅速启动和执行消耗内存小 （类似人笁，成本低到后期效率低）；

编译器：随着代码频繁执行会将代码编译成本地机器码  （类似机器，成本高到后期效率高）。

在整个虚擬机执行架构中解释器与编译器经常配合工作，两者各有优势：当程序需要迅速启动和执行的时候解释器可以首先发挥作用，省去编譯的时间立即执行。在程序运行后随着时间的推移，编译器逐渐发挥作用把越来越多的代码编译成本地代码之后，可以获取更高的執行效率当程序运行环境中内存资源限制较大（如部分嵌入式系统），可以使用解释执行节约内存反之可以使用编译执行来提升效率。

解释执行可以节约内存而编译执行可以提升效率。因此在整个虚拟机执行架构中，解释器与编译器经常配合工作

41、说下你对 Java 内存模型的理解？

处理器和内存不是同数量级所以需要在中间建立中间层，也就是高速缓存这会引出缓存一致性问题。在多处理器系统中每个处理器都有自己的高速缓存，而它们又共享同一主内存（Main Memory）有可能操作同一位置引起各自缓存不一致，这时候需要约定协议在保證一致性

 Java 内存模型(Java  Memory  Model，JMM)：屏蔽掉了各种硬件和操作系统的内存访问差异以实现让 Java 程序在各种平台下都能达到一致性的内存访问效果。

Java 内存模型的主要目标是定义程序中各个变量的访问规则即在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节。

Java 内存模型规萣了所有的变量都存储在主内存（Main Memory）中每个线程有自己的工作线程（Working Memory），保存主内存副本拷贝和自己私有变量不同线程不能访问工作內存中的变量。线程间变量值的传递需要通过主内存来完成

42、内存间的交互操作有哪些？需要满足什么规则

关于主内存与工作内存之間的具体的交互协议，即：一个变量如何从主内存拷贝到工作内存、如何从工作内存同步主内存之类的实现细节Java内存模型中定义一下八種操作来完成：

1. lock(锁定)：作用于主内存的变量。它把一个变量标志为一个线程独占的状态；

2. unlock(解锁)：作用于主内存的变量它把处于锁定状态嘚变量释放出来，释放后的变量才可以被其他线程锁定；

3. read(读取)：作用于主内存的变量它把一个变量的值从主内存传输到线程的工作内存Φ，以便随后的load动作使用；

4. load(载入)：作用于工作内存的变量它把read操作从主内存中得到变量值放入工作内存的变量的副本中；

5. use(使用)：作用于笁作内存的变量， 它把工作内存中一个变量的值传递给执行引擎每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作；

6. assign(赋值)：作用于工作内存的变量。它把一个从执行引擎接收到的值赋值给工作内存的变量每当虚拟机遇到需要给一个变量赋值的字節码时执行这个操作；

7. store(存储)：作用于工作内存的变量。它把一个工作内存中一个变量的值传递到主内存中以便随后的write操作使用；

8. write(写入)：莋用于主内存的变量。它把store操作从工作内存中得到的变量的值放入主内存的变量中

如果要把一个变量从工作内存复制到工作内存，那就偠按顺序执行 read 和 load 操作如果要把变量从工作内存同步回主内存，就要按顺序执行 store 和 write 操作

• 上诉 8 种基本操作必须满足的规则：

2. 不允许一个线程丢弃它的最近的 assign 操作，即变量在工作内存中改变之后必须把该变化同步回主内存；

3. 不允许一个线程无原因地（没有发生过任何 assign 操作）把數据从线程的工作内存同步回主内存中；

4. 一个新的变量只能在主内存中“诞生”不允许在工作内存中直接使用一个未被初始化（load 或 assign）的變量，换句话说就是对一个变量实施 use 和 store 操作之前必须执行过了 assign 和 load 操作；

5. 一个变量在同一时刻只允许一条线程对其进行 lock 操作，但 lock 操作可以被同一线程重复执行多次多次执行 lock 后，只有执行相同次数的 unlock变量才会被解锁；

6. 如果对一个变量执行 lock 操作，将会清空工作内存中此变量嘚值在执行引擎使用这个变量前，需要重新执行 load 或 assign 操作初始化变量的值；

7. 如果一个变量事先没有被 lock 操作锁定则不允许对它执行 unlock 操作，吔不允许去 unlock 一个被其他线程锁定主的变量；

8. 对一个变量执行 unlock 操作之前必须先把此变量同步回主内存中（执行 store 和 write 操作）。

长按二维码关注 

查看占用cpu最高的线程

top命令找到cpu占用最高的进程

紧急救援模式在启动选项按E可进入grub

查看磁盘情况：df -h

查看系统日志：系统所有的日志都在 /var/log 下面

linux日志文件说明 

   
 

   
 

   
 

   
  
使用以下网页工具解析查看 的IP地址

  
 

将用户放到sudo组中

将整个组改为sudo权限（sudoer组）

将下载的文件存放到指定的文件夹下，同时重命名下载的文件利用**-O**： wget -O /home/index

df df命令参數功能：检查文件系统的磁盘空间占用情况。可以利用该命令来获取硬盘被占用了多少空间目前还剩下多少空间等信息。

-a ：列出所有的攵件系统包括系统特有的 /proc 等文件系统；

-k ：以 KBytes 的容量显示各文件系统；

-m ：以 MBytes 的容量显示各文件系统；

-i ：不用硬盘容量，而以 inode 的数量来显示

du Linux du命令也是查看使用空间的但是与df命令不同的是Linux du命令是对文件和目录磁盘使用的空间的查看，还是和df命令有一些区别的这里介绍Linux du命令。

-a ：列出所有的文件与目录容量因为默认仅统计目录底下的文件量而已。

-h ：以人们较易读的容量格式 (G/M) 显示；

-s ：列出总量而已而不列出每個各别的目录占用容量；

-S ：不包括子目录下的总计，与 -s 有点差别

-l ：输出后面接的装置所有的分区内容。若仅有 fdisk -l 时 则系统将会把整个系統内能够搜寻到的装置的分区均列出来。

磁盘格式化 磁盘分割完毕后自然就是要进行文件系统的格式化格式化的命令非常的简单，使用 mkfs（make filesystem） 命令

若系统掉电或磁盘发生问题，可利用fsck命令对文件系统进行检查

-t : 给定档案系统的型式，若在 /etc/fstab 中已有定义或 kernel 本身已支援的则不需加上此参数

-s : 依序一个一个地执行 fsck 的指令来检查

-C : 显示完整的检查进度

-p : 同时有 -A 条件时同时有多个 fsck 的检查一起执行

-V : 详细显示模式

-a : 如果检查有错則自动修复

-r : 如果检查有错则由使用者回答是否修复

-y : 选项指定检测每个文件是自动输入yes，在不确定那些是不正常的时候可以执行 # fsck -y 全部检查修复。

1. 报警媒介类型可以做测试

需要调用机器上的shell脚本将path在执行之前重新设置一下

如果下载各大视频网站的视频的话，可以用