Java面试题（基础、mysql、spring、jvm）

目录

Java基础知识

1.回话跟踪技术

会话跟踪是一种灵活、轻便的机制，它使Web上的状态编程变为可能。 HTTP是一种无状态协议，每当用户发出请求时，服务器就会做出响应，客户端与服务器之间的联系是离散的、非连续的。当用户在同一网站的多个页面之间转换时，根本无法确定是否是同一个客户，会话跟踪技术就可以解决这个问题。当一个客户在多个页面间切换时，服务器会保存该用户的信息。 有四种方法可以实现会话跟踪技术：URL重写、隐藏表单域、Cookie、Session。

1）.隐藏表单域：，非常适合步需要大量数据存储的会话应用。

2）.URL 重写:URL 可以在后面附加参数，和服务器的请求一起发送，这些参数为名字/值对。 3）.Cookie:一个 Cookie 是一个小的，已命名数据元素。服务器使用 SET-Cookie 头标将它作为 HTTP 响应的一部分传送到客户端，客户端被请求保存 Cookie 值，在对同一服务器的后续请求使用一个 Cookie 头标将之返回到服务器。与其它技术比较，Cookie 的一个优点是在浏览器会话结束后，甚至 在客户端计算机重启后它仍可以保留其值

4）.Session：使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话

2.Hash与线程

hashMap在单线程中使用大大提高效率，在多线程的情况下使用hashTable来确保安全。hashTable中使用synchronized关键字来实现安全机制，但是synchronized是对整张hash表进行锁定即让线程独享整张hash表，在安全同时造成了浪费。concurrentHashMap采用分段加锁的机制来确保安全

3.创建线程对象两种方式：

1.继承Thread类，重载run方法；

2.实现Runnable接口，实现run方法

4.全局变量和静态变量

类变量（静态变量）在类加载过程的准备阶段会进行一次赋值，一般是空值或constantValue属性值，同时在初始化阶段会调用类构造器再进行一次赋值。而实例变量在创建对象时会调用实例构造器进行一次赋值。因此无论是类变量还是实例变量，在使用前都是非空的。而局部变量没有初始化过程，在使用前必须赋值。

6.”|”与”||”的区别

用法：condition 1 | condition 2、condition 1 || condition 2

“|”是按位或：先判断条件1，不管条件1是否可以决定结果（这里决定结果为true)，都会执行条件2

“||”是逻辑或：先判断条件1，如果条件1可以决定结果（这里决定结果为true)，那么就不会执行条件2

7.servlet与CGI的比较

和CGI程序一样，Servlet可以响应用户的指令(提交一个FORM等等)，也可以象CGI程序一样，收集用户表单的信息并给予动态反馈(简单的注册信息录入和检查错误)。
然而，Servlet的机制并不仅仅是这样简单的与用户表单进行交互。传统技术中，动态的网页建立和显示都是通过CGI来实现的，但是，有了Servlet,您可以大胆的放弃所有CGI(perl?php?甚至asp!)，利用Servlet代替CGI,进行程序编写。
对比一：当用户浏览器发出一个Http/CGI的请求，或者说 调用一个CGI程序的时候，服务器端就要新启用一个进程 (而且是每次都要调用)，调用CGI程序越多(特别是访问量高的时候)，就要消耗系统越多的处理时间，只剩下越来越少的系统资源，对于用户来说，只能是漫长的等待服务器端的返回页面了，这对于电子商务激烈发展的今天来说，不能不说是一种技术上的遗憾。
而Servlet充分发挥了服务器端的资源并高效的利用。每次调用Servlet时并不是新启用一个进程 ，而是在一个Web服务器的进程敏感词享和分离线程，而线程最大的好处在于可以共享一个数据源，使系统资源被有效利用。
对比二：传统的CGI程序，不具备平台无关性特征，系统环境发生变化，CGI程序就要瘫痪，而Servlet具备Java的平台无关性，在系统开发过程中保持了系统的可扩展性、高效性。
对比三：传统技术中，一般大都为二层的系统架构，即Web服务器+数据库服务器，导致网站访问量大的时候，无法克服CGI程序与数据库建立连接时速度慢的瓶颈，从而死机、数据库死锁现象频繁发生。而我们的Servlet有连接池的概念，它可以利用多线程的优点，在系统缓存中事先建立好若干与数据库的连接，到时候若想和数据库打交道可以随时跟系统”要”一个连接即可，反应速度可想而知。

8.servletContext和servletConfig区别

ServletContext对象：servlet容器在启动时会加载web应用，并为每个web应用创建唯一的servlet context对象，可以把ServletContext看成是一个Web应用的服务器端组件的共享内存，在ServletContext中可以存放共享数据。ServletContext对象是真正的一个全局对象，凡是web容器中的Servlet都可以访问。

整个web应用只有唯一的一个ServletContext对象

servletConfig对象：用于封装servlet的配置信息。从一个servlet被实例化后，对任何客户端在任何时候访问有效，但仅对servlet自身有效，一个servlet的ServletConfig对象不能被另一个servlet访问。

9.类加载时候的初始化问题，

执行类的 main方法，会导致类进行加载，而类加载的属性如下

1、虚拟机在首次加载Java类时，会对静态初始化块、静态成员变量、静态方法进行一次初始化。我们不要去纠结这里的顺序，一般来说我们只需要知道，静态方法一般在最后。

2、只有在调用new方法时才会创建类的实例

3、类实例创建过程：按照父子继承关系进行初始化，首先执行父类的初始化块部分，然后是父类的构造方法；再执行本类继承的子类的初始化块，最后是子类的构造方法

4、类实例销毁时候，首先销毁子类部分，再销毁父类部分

10.证明String值是final

public class StringTest {
    public static void main(String[] args) {
        StringTest st = new StringTest();
        //验证String如何指向
        String a = new String("aaa");
        StringBuffer sb = new StringBuffer("111");
        st.changeStr(a,sb);
        System.out.println(a+","+sb);//结果:aaa,111333
    }

    public void changeStr(String str,StringBuffer sb) {
        str = str + "ccc";
        sb.append("333");
    }
}

11.线程两种实现方式

//1、继承Thread类创建线程
public class MyThread extends Thread {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  

MyThread myThread1 = new MyThread();  
MyThread myThread2 = new MyThread();  
myThread1.start();  
myThread2.start();

//2、实现Runnable接口创建线程
public class MyThread extends OtherClass implements Runnable {  
　　public void run() {  
　　 System.out.println("MyThread.run()");  
　　}  
}  

12.java虚拟机功能（不全面）

1.通过 ClassLoader 寻找和装载 class 文件
2.解释字节码成为指令并执行，提供 class 文件的运行环境

(Jvm跨平台性：我们编译好的文件是以.java后缀保存的，编译器会自动帮我们生成一个标准的.class字节码文件，JVM运行该文件。JVM也是一个软件，不同的系统平台JVM不同，但都可以实现标准的.class字节码文件。 )

3.进行运行期间垃圾回收

13.ArrayList和LinkedList的大致区别和共同点：

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于双向链表的数据结构。

2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

4.ArrayList和LinkedList都不是线程安全

14.线程方法

//锁：锁住其他线程，不能动弹
synchronized (obj) {
    try {
        //此线程等候，并且其他线程解锁
        obj.wait();
        //唤醒所有wait的线程
        obj.notifyAll();
    } catch (InterruptedException e) {
    }
}

15.finally语法

1、不管有木有出现异常，finally块中代码都会执行；

2、当try和catch中有return时，finally仍然会执行；

3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；

4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

16.自动装箱

1、基本型和基本型封装型进行“==”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true； 2、两个Integer类型进行’/=比较，如果其值在-128至127，那么返回true，否则返回false, 这跟Integer.valueOf()的缓冲对象有关，这里不进行赘述。 3、两个基本型的封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true 4、基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行3中的比较。

17.ArrayList源码分析

https://www.cnblogs.com/lewis0077/p/5275061.html

1.transient Object[] elementData：本质数组，且不可序列化

2.ArrayList(int initialCapacity)、ArrayList()、ArrayList(Collection< ? extends E> c)：构造函数参数，传入整型，初始化对应大小Object数组；空，初始化大小为数组；Collection，把集合通过toArray变成Object[]类型赋给elementData

3.add(E e)：插入，调用ensureCapacity(size + 1)动态扩容数组，把新元素e放在size+1位置

4.ensureCapacity(int minCapacity)：扩容，首先将modCount+1,modeCount表示修改数组结构的次数，如果入参minCapacity大于目前数组elementData的容量,则将容量扩展到 (oldCapacity * 3)/2 + 1,若此时容量仍然小于 minCapacity,则直接将minCapacity设置为最新的容量，最后把新容量的数组覆盖原数组

5.add(int index, E element)：插入（带参），与插入不同在于，需要把index后面所有数copy往后移动一位（代价高昂）

6.addAll(Collection< ? extends E> c)：尾插一个集合：与插入不同在于，插入的不是单一元素是集合

7.remove(Object o)：删除（对象）：若指定元素o为 null/not null ,则遍历当前的elementData数组,如果某一个下标index上面的值为null(==)/指定元素o(equals ),则调用fastRemove(int)快速删除该元素，同时copy移动数组（代价高昂），源码可知，只能删除第一个匹配的元素

8.remove(int index)：删除（下标）：相比remove(Object o)方法，多了一个边界检查，但是少了元素的查找过程，因此性能更好一些

9.class Itr implements Iterator：迭代器：Itr是AbstractList中的一个内部类

1. int cursor = 0：当前迭代器指向的数组中元素的下一个元素的位置

2. hasNext()：判断当前数组是否迭代到尾部

3. next()：先调用checkForComodification()判断是否有其他线程对集合大小做出了有影响的动作；返回cursor 的值

4. checkForComodification()：检测modcount若== expectedModCount（没有其他线程对集合大小做 出了有影响的操作）；否则抛出线程修改异常

18.LinkedList源码分析

https://www.cnblogs.com/lewis0077/p/5275061.html

1.class Entry：本质链表，通过操作Entry节点来实现

2.transient Entry header = new Entry(null, null, null)：头节点，不储存数据

3.LinkedList()：构造函数，空方法

4.add(E e)：插入，调用linkLast(e)，追加指定的元素e到集合尾部

5.linkLast(e)：尾插，如果当前集合没有元素，则为头元素，first和last指向自己，形成环形链表；如果当前集合有元素，则插入到最后

6.addAll(int index, Collection

Mysql知识

1.ER图转关系模型

实例1：将教学管理ER图转换为关系模式**

(1)把三个实体类型转换成三个模式：
　　 ①系（系编号，系名，电话）
　　 ②教师（教工号，姓名，性别，职称）
　　 ③课程（课程号，课程名，学分）
(2)对于1:1联系“主管”，可以在“系”模式中加入教工号（教工号为外键）。对于1:N联系“聘用”，可以在“教师”模式中加入系编号和聘期两个属性（系编号为外键）:
　　 ①系（系编号，系名，电话，主管人的教工号）
　　 ②教师（教工号，姓名，性别，职称，系编号，聘期）
(3)第三步：对于M:N联系“任教”，则生成一个新的关系模式：
　　 ①任教（教工号，课程号，教材）
(4)这样，转换成的四个关系模式如下：
　　 ①系（系编号，系名，电话，主管人的教工号）
　　 ②教师（教工号，姓名，性别，职称，系编号，聘期）
　　 ③课程（课程号，课程名，学分）
　　 ④任教（教工号，课程号，学分）

2.数据库原子性知识点

1.脏读： （改数）
指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。

2.不可重复读： （）
指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。

3.幻读:
指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。

6.外模式&内模式&模式

外模式

外模式又称子模式或用户模式，对应于用户级。它是某个或某几个用户所看到的数据库的数据视图，是与某一应用有关的数据的逻辑表示。外模式是从模式导出的一个子集，包含模式中允许特定用户使用的那部分数据。用户可以通过外模式描述语言来描述、定义对应于用户的数据记录(外模式)，也可以利用数据操纵语言(Data Manipulation Language，DML)对这些数据记录进行操作。外模式反映了数据库的用户观。

概念模式

模式又称概念模式或逻辑模式，对应于概念级。它是由数据库设计者综合所有用户的数据，按照统一的观点构造的全局逻辑结构，是对数据库中全部数据的逻辑结构和特征的总体描述，是所有用户的公共数据视图(全局视图)。它是由数据库管理系统提供的数据模式描述语言(Data Description Language，DDL)来描述、定义的，体现、反映了数据库系统的整体观。

内模式

内模式又称存储模式，对应于物理级，它是数据库中全体数据的内部表示或底层描述，是数据库最低一级的逻辑描述，它描述了数据在存储介质上的存储方式和物理结构，对应着实际存储在外存储介质上的数据库。内模式由内模式描述语言来描述、定义，它是数据库的存储观。 在一个数据库系统中，只有唯一的数据库， 因而作为定义 、描述数据库存储结构的内模式和定义、描述数据库逻辑结构的模式，也是唯一的，但建立在数据库系统之上的应用则是非常广泛、多样的，所以对应的外模式不是唯一的，也不可能是唯一的。

Spring面试题

1.依赖注入和控制反转是同一概念：

依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。

​

JVM面试题

1.描述执行引擎的架构设计

创建新线程时，JVM会为这个线程创建一个栈，同时分配一个PC寄存器（指向第一行可执行的代码）。调用新方法时会在这个栈上创建新的栈帧数据结构。执行完成后方法对应的栈帧将消失，PC寄存器被销毁，局部变量区所有值被释放，被JVM回收。

2.描述JVM体系结构

(1)类加载器：JVM启动时或者类运行时将需要的class加载到JVM中。每个被装载的类的类型对应一个Class实例，唯一表示该类，存于堆中。

(2)执行引擎：负责执行JVM的字节码指令（CPU）。执行引擎是JVM的核心部分，作用是解析字节码指令，得到执行结果（实现方式：直接执行，JIT(just in time)即时编译转成本地代码执行，寄存器芯片模式执行，基于栈执行）。本质上就是一个个方法串起来的流程。每个Java线程就是一个执行引擎的实例，一个JVM实例中会有多个执行引擎在工作，有的执行用户程序，有的执行JVM内部程序（GC）.

(3)内存区:模拟物理机的存储、记录和调度等功能模块，如寄存器或者PC指针记录器。存储执行引擎执行时所需要存储的数据。

(4)本地方法接口：调用操作系统本地方法返回结果

3.描述JVM编译优化

早期（编译器）：

很少；编译时，为节省常量池空间，能确定的相同常量只用一个引用地址。

晚期（运行期）：

方法内联：去除方法调用的成本；为其他优化建立良好基础，便于在更大范围采取连续优化的手段。

冗余访问消除：公共子表达式消除

复写传播：完全相等的变量可替代

无用代码消除：清除永远不会执行的代码

(1)公共子表达式消除（语言无关）：如果公共子表达式已经计算过了，并且没有变化，那就没有必要再次计算，可用结果替换。

(2)数组边界检查消除（语言相关）：限定循环变量在取值范围之间，可节省多次条件判断。

(3)方法内联（最重要）：去除方法调用的成本；为其他优化建立良好基础，便于在更大范围采取连续优化的手段。

(4)逃逸分析（最前沿）：分析对象的动态作用域；变量作为调用参数传递到其他方法中-方法逃逸；被外部线程访问-线程逃逸。

栈上分配-减少垃圾系统收集压力

同步消除-如果无法逃逸出线程，则可以消除同步

标量替换-将变量恢复原始类型来访问

小抄：final修饰的局部变量和参数，在常量池中没有符号引用，没有访问标识，对运行期是没有任何影响的，仅仅保证其编译期间的不变性。

4.什么是类加载器，ClassLoader（类加载器）有哪些

实现通过类的权限定名获取该类的二进制字节流的代码块叫做类加载器。

(1)Bootstrap ClassLoader(启动类加载器)：完全由JVM控制，加载JVM自身工作需要的类（JAVA_HOME/lib）

(2)Extension ClassLoader(扩展类加载器)：属于JVM自身一部分，不是JVM自身实现的(JAVA_HOME/lib/ext)

(3)Appclication ClassLoader(应用程序类加载器)：父类是Extension ClassLoader，加载Classpath（用户类路径）上的类库

5.描述ClassLoader的作用（什么是类加载器）和加载过程

将Class文件加载到JVM中、审查每个类由谁加载（父优先的等级加载机制）、将Class字节码重新解析成JVM统一要求的对象（Class对象）格式。

.class->findclass->Liking：Class规范验证、准备、解析->类属性初始化赋值(static块的执行)->Class对象（这也就是为什么静态块只执行一次）

5.描述JVM类加载机制

ClassLoader首先不会自己尝试去加载类，而是把这个请求委托给父类加载器完成，每一个层次都是。只有当父加载器反馈无法完成请求时（在搜索范围内没有找到所需的类），子加载器才会尝试加载（等级加载机制、父优先、双亲委派）。

好处：类随着它的加载器一起具有一种带有优先级的层次关系；保证同一个类只能被一个加载器加载。

6.JVM加载class文件到内存的两种方式

(1)隐式加载：继承或者引用的类不在内存中

(2)显式加载：代码中通过调用ClassLoader加载

7.加载类错误分析及其解决

(1)ClassNotFoundException：没有找到对应的字节码(.class)文件;检查classpath下有无对应文件

(2)NoClassDefFoundError：隐式加载时没有找到，ClassNotFoundException引发NoClassDefFoundError；确保每个类引用的类都在classpath下

(3)UnsatisfiedLinkError：（未满足链接错误）删除了JVM的某个lib文件或者解析native标识的方法时找不到对应的本地库文件

(4)ClassCastException：强制类型转换时出现这个错误；容器类型最好显示指明其所包含对象类型、先instanceof检查是不是目标类型，再类型转换

(5)ExceptionInitializerError：给类的静态属性赋值时

8.Java应不应该动态加载类（JVM能不能动态加载类）

JVM中对象只有一份，不能被替换，对象的引用关系只有对象的创建者持有和使用，JVM不可干预对象的引用关系，因为JVM不知道对象是怎么被使用的，JVM不知道对象的运行时类型，只知道编译时类型。

但是可以不保存对象的状态，对象创建和使用后就被释放掉，下次修改后，对象就是新的了（JSP）。

9.Java中哪些组件需要使用内存

(1)Java堆：存储Java对象

(2)线程：Java运行程序的实体

(3)类和类加载器：存储在堆中，这部分区域叫永久代（PermGen区）

(4)NIO：基于通道和缓冲区来执行I/O的新方式。

(5)JNI：本地代码可以调用Java方法，Java方法也可以调用本地代码

10.描述JVM内存结构及内存溢出。

JVM是按照运行时数据的存储结构来划分内存结构的。

PC寄存器数据：严格来说是一个数据结构，保存当前正在执行的程序的内存地址。为了线程切换后能恢复到正确的执行位置，线程私有。不会内存溢出。

(1)Java栈：方法执行的内存模型，存储线程执行所需要的数据。线程私有。

–OutOfMemoryError:JVM扩展栈时无法申请到足够的空间。一个不断调用自身而不会终止的方法。

–StackOverflowError:请求的栈深度大于JVM所允许的栈深度。创建足够多的线程。

(2)堆：存储对象，每一个存在堆中Java对象都是这个对象的类的副本，复制包括继承自他父类的所有非静态属性。线程共享。

–OutOfMemoryError:对象数量到达堆容量限制。可通过不断向ArrayList中添加对象实现。

(3)方法区：存储类结构信息。包括常量池（编译期生产的各种字面量和符号引用）和运行时常量池。线程共享。

–OutOfMemoryError:同运行时常量池。

(4)本地方法栈：与Java栈类似，为JVM运行Native方法准备的空间。线程私有。（C栈）OutOfMemoryError和StackOverflowError同JVM栈。

(5)运行时常量池：代表运行时每个class文件中的常量表。运行期间产生的新的常量放入运行时常量池。

–OutOfMemoryError:不断向List中添加字符串，然后String.inern()，PermGen Space(运行时常量池属于方法区)。

(6)本地直接内存：即NIO。

–OutOfMemoryError:通过直接向操作系统申请分配内存。

11.描述JVM内存分配策略

（1）对象优先分配在Eden，如果Eden区没有足够的空间时，虚拟机执行一次Minor GC。

（2）大对象（比如很长的字符串、数组）直接进入老年代，这样做的目的是避免在Eden区和两个Survivor区之间发生大量的内存拷贝（新生代采用复制算法收集内存） （提醒一句，编程时少创建“短命大对象”，大对象容易让内存还有不少的时候触发GC来安置他们）

（3）长期存活的对象进入老年代。虚拟机为每个对象定义了一个年龄计数器，如果对象经过了1次Minor GC那么对象会进入Survivor区，之后每经过一次Minor GC那么对象的年龄加1，知道达到阀值对象进入老年区。

（4）幸存区相同年龄对象的占幸存区空间的多于其一半，将进入老年代

（5）空间分配担保。每次进行Minor GC时，JVM会计算Survivor区移至老年区的对象的平均大小，如果这个值大于老年区的剩余值大小则进行一次Full GC，如果小于检查HandlePromotionFailure设置，如果true则只进行Monitor GC,如果false则进行Full GC。

12.描述JVM如何检测垃圾

通过可达性分析算法，通过一些列称为GC Roots的对象作为起始点，从这些起始点向下搜索，搜索所走过的路径称为引用链，当一个对象到GC Roots没有任何引用链相连（GC Roots到这个对象不可达），则证明这个对象是不可用的。

使用可达性分析算法而不是引用计数算法。因为引用计数算法很难解决对象之间相互循环引用的问题。

13.哪些元素可作为GC Roots

（1）JVM栈（栈帧中的本地变量表）中的引用

（2）方法区中类静态属性引用

（3）方法区中常量引用

（4）本地方法栈中JNI(一般的Native方法)引用

14.描述分代垃圾收集算法的思路

把对象按照寿命长短来分组，分为年轻代和老年代，新创建的在老年代，经历几次回收后仍然存活的对象进入老年代，老年代的垃圾频率不像年轻代那样频繁，减少每次收集都去扫描所有对象的数量，提高垃圾回收效率。

15.描述基于分代的堆结构及其比例。

(1)年轻代（Young区-1/4）:Eden+Survior(From+To)（1/8，这个比例保证只有10%的空间被浪费，保证每次回收都只有不多于10%的对象存活）

(2)老年代（Old区 ）：存放几次垃圾收集后存活的对象

(3)永久区（Perm区）：存放类的Class对象

16.描述垃圾收集算法

(1)标记-清除算法：首先标记处所要回收的对象，标记完成后统一清除。缺点：标记效率低，清除效率低，回收结束后会产生大量不连续的内存碎片（没有足够连续空间分配内存，提前触发另一次垃圾回收）。适用于对象存活率高的老年代。

(2)复制算法(Survivor的from和to区，from和to会互换角色)：

将内存容量划分大小相等的两块，每次只使用其中一块。一块用完，就将存活的对象复制到另一块，然后把使用过的一块一次清除。不用考虑内存碎片，每次只要移动顶端指针，按顺序分配内存即可，实现简单运行高效。适用于新生代。

缺点：内存缩小为原来的一般，代价高。浪费50%的空间。

(3)标记-整理算法：

标记完成后，将存活的对象移动到一端，然后清除边界以外的内存。适用于对象存活率高的老年代。

(4)分代收集算法

根据对象存活周期不同把内存分为新生代和老年代，根据各个年代的特征采用最适当的收集算法；新生代有大批对象死去，少量存活采用复制算法；老年代存活率高，用标记整理/标记清除

17.描述新生代和老年代的回收策略

18.描述CMS垃圾收集器

CMS 收集器：Concurrent Mark Sweep 并发标记-清除。重视响应速度，适用于互联网和B/S系统的服务端上。初始标记还是需要Stop the world 但是速度很快。缺点：CPU资源敏感，无法浮动处理垃圾，会有大量空间碎片产生。

19.对象创建方法，对象的内存分配，对象的访问定位。

创建：

\1. 类加载检查

JVM遇到一条new指令时，首先检查这个指令的参数是否能在常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有，那必须先执行相应的类的加载过程。

\2. 对象分配内存

对象所需内存的大小在类加载完成后便完全确定（对象内存布局），为对象分配空间的任务等同于把一块确定大小的内存从Java堆中划分出来。

根据Java堆中是否规整有两种内存的分配方式：（Java堆是否规整由所采用的垃圾收集器是否带有压缩整理功能决定）

指针碰撞(Bump the pointer)

Java堆中的内存是规整的，所有用过的内存都放在一边，空闲的内存放在另一边，中间放着一个指针作为分界点的指示器，分配内存也就是把指针向空闲空间那边移动一段与内存大小相等的距离。例如：Serial、ParNew等收集器。

空闲列表(Free List)

Java堆中的内存不是规整的，已使用的内存和空闲的内存相互交错，就没有办法简单的进行指针碰撞了。虚拟机必须维护一张列表，记录哪些内存块是可用的，在分配的时候从列表中找到一块足够大的空间划分给对象实例，并更新列表上的记录。例如：CMS这种基于Mark-Sweep算法的收集器。

\3. 并发处理

对象创建在虚拟机中时非常频繁的行为，即使是仅仅修改一个指针指向的位置，在并发情况下也并不是线程安全的，可能出现正在给对象A分配内存，指针还没来得及修改，对象B又同时使用了原来的指针来分配内存的情况。

同步

虚拟机采用CAS配上失败重试的方式保证更新操作的原子性

本地线程分配缓冲（Thread Local Allocation Buffer, TLAB）

把内存分配的动作按照线程划分为在不同的空间之中进行，即每个线程在Java堆中预先分配一小块内存（TLAB）。哪个线程要分配内存，就在哪个线程的TLAB上分配。只有TLAB用完并分配新的TLAB时，才需要同步锁定。

\4. 内存空间初始化

虚拟机将分配到的内存空间都初始化为零值（不包括对象头）,如果使用了TLAB，这一工作过程也可以提前至TLAB分配时进行。

内存空间初始化保证了对象的实例字段在Java代码中可以不赋初始值就直接使用，程序能访问到这些字段的数据类型所对应的零值。

注意：类的成员变量可以不显示地初始化（Java虚拟机都会先自动给它初始化为默认值）。方法中的局部变量如果只负责接收一个表达式的值，可以不初始化，但是参与运算和直接输出等其它情况的局部变量需要初始化。

\5. 对象设置

虚拟机对对象进行必要的设置，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象的对象头之中。

\6. 执行init( )

在上面的工作都完成之后，从虚拟机的角度看，一个新的对象已经产生了。但是从Java程序的角度看，对象的创建才刚刚开始init()方法还没有执行，所有的字段都还是零。

所以，一般来说（由字节码中是否跟随invokespecial指令所决定），执行new指令之后会接着执行init()方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算产生出来。

访问定位：句柄或者直接指针。

20.GC收集器有哪些？CMS收集器与G1收集器的特点

串行垃圾回收器（Serial Garbage Collector）

并行垃圾回收器（Parallel Garbage Collector）

并发标记扫描垃圾回收器（CMS Garbage Collector）

G1垃圾回收器（G1 GarbageCollector）

并发标记垃圾回收使用多线程扫描堆内存，标记需要清理的实例并且清理被标记过的实例。并发标记垃圾回收器只会在下面两种情况持有应用程序所有线程。

当标记的引用对象在tenured区域；

在进行垃圾回收的时候，堆内存的数据被并发的改变。

相比并行垃圾回收器，并发标记扫描垃圾回收器使用更多的CPU来确保程序的吞吐量。如果我们可以为了更好的程序性能分配更多的CPU，那么并发标记上扫描垃圾回收器是更好的选择相比并发垃圾回收器。

通过JVM参数 XX:+USeParNewGC 打开并发标记扫描垃圾回收器。

G1垃圾回收器适用于堆内存很大的情况，他将堆内存分割成不同的区域，并且并发的对其进行垃圾回收。G1也可以在回收内存之后对剩余的堆内存空间进行压缩。并发扫描标记垃圾回收器在STW情况下压缩内存。G1垃圾回收会优先选择第一块垃圾最多的区域

21.几种常用的内存调试工具

jmap、jstack、jconsole。

22.类加载的五个过程：加载、验证、准备、解析、初始化。

加载：

​ 在加载阶段，虚拟机主要完成三件事：

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

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

3.在Java堆中生成一个代表这个类的java.lang.Class对象，作为方法区域数据的访问入口。

验证：

​ 验证阶段作用是保证Class文件的字节流包含的信息符合JVM规范，不会给JVM造成危害。如果验证失败，就会抛出一个java.lang.VerifyError异常或其子类异常。验证过程分为四个阶段：

1.文件格式验证：验证字节流文件是否符合Class文件格式的规范，并且能被当前虚拟机正确的处理。

2.元数据验证：是对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言的规范。

3.字节码验证：主要是进行数据流和控制流的分析，保证被校验类的方法在运行时不会危害虚拟机。

4.符号引用验证：符号引用验证发生在虚拟机将符号引用转化为直接引用的时候，这个转化动作将在解析阶段中发生。

准备：

​ 准备阶段为变量分配内存并设置类变量的初始化。在这个阶段分配的仅为类的变量（static修饰的变量），而不包括类的实例变量。对已非final的变量，JVM会将其设置成“零值”，而不是其赋值语句的值：

pirvate static int size = 12;

​ 那么在这个阶段，size的值为0，而不是12。 final修饰的类变量将会赋值成真实的值。

解析：

​ 解析过程是将常量池内的符号引用替换成直接引用。主要包括四种类型引用的解析。类或接口的解析、字段解析、方法解析、接口方法解析。

初始化：

​ 在准备阶段，类变量已经经过一次初始化了，在这个阶段，则是根据程序员通过程序制定的计划去初始化类的变量和其他资源。这些资源有static{}块，构造函数，父类的初始化等。

​ 至于使用和卸载阶段阶段，这里不再过多说明，使用过程就是根据程序定义的行为执行，卸载由GC完成。

23.“地球人都知道，Java有个东西叫垃圾收集器，它让创建的对象不需要像c/cpp那样delete、free掉，你能不能谈谈，GC是在什么时候，对什么东西，做了什么事情？”

什么时候 ：eden满了minor gc，升到老年代的对象大于老年代剩余空间full gc，或者小于时被HandlePromotionFailure参数强制full gc；gc与非gc时间耗时超过了GCTimeRatio的限制引发OOM，调优诸如通过NewRatio控制新生代老年代比例，通过MaxTenuringThreshold控制进入老年前生存次数等

对什么东西：从root搜索不到，而且经过第一次标记、清理后，仍然没有复活的对象

做什么事情：能说出诸如新生代做的是复制清理、from survivor、to survivor是干啥用的、老年代做的是标记清理、标记清理后碎片要不要整理、复制清理和标记清理有有什么优劣势等；还能讲清楚串行、并行（整理/不整理碎片）、CMS等搜集器可作用的年代、特点、优劣势，并且能说明控制/调整收集器选择的方式

24.jvm中一次完整的GC流程（从ygc到fgc）是怎样的，重点讲讲对象如何晋升到老年代等

答：对象优先在新生代区中分配，若没有足够空间，Minor GC；
大对象（需要大量连续内存空间）直接进入老年态；长期存活的对象进入老年态。如果对象在新生代出生并经过第一次MGC后仍然存活，年龄+1，若年龄超过一定限制（15），则被晋升到老年态。

25.java内存模型

java内存模型(JMM)是线程间通信的控制机制.JMM定义了主内存和线程之间抽象关系。线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。Java内存模型的抽象示意图如下：

从上图来看，线程A与线程B之间如要通信的话，必须要经历下面2个步骤：
\1. 首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。
\2. 然后，线程B到主内存中去读取线程A之前已更新过的共享变量。**

26.类加载器双亲委派模型机制？

当一个类收到了类加载请求时，不会自己先去加载这个类，而是将其委派给父类，由父类去加载，如果此时父类不能加载，反馈给子类，由子类去完成类的加载。