【Java】 面试总结&面经学习记录（2.1更新）

【Java】 面试总结&面经学习记录

此系列博客供自己复习所用，如有错误还忘指出

一、Java同步机制

参考链接：https://www.cnblogs.com/zeroingToOne/p/9554560.html

1.1 Java做到线程同步方法

• 在需要同步的方法的方法签名中加上synchronized关键字（锁方法）

• 使用synchronized关键字对需要进行同步的代码块进行同步 (锁代码块)

• 使用java.util.concurrent.lock包中Lock对象（JDK1.8）—JDK 1.5出现

• 使用volatile关键字(不能替代synchronized)

  a. volatile关键字为域变量的访问提供了一种免锁机制
  b. 使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新
  c. 因此每次使用该域就要重新计算，而不是使用寄存器中的值
  d. volatile不会提供任何原子操作（因此不能替换synchronized），它也不能用来修饰final类型的变量

1.2 synchronized使用时需要注意的一些地方：

被synchronized关键字修饰的代码块在被线程执行之前，首先要拿到被同步对象的锁，并且一个对象仅仅是只有一个锁，比如上面被synchronized代码，首先那个方法需要拿到当前对象的锁，如果当前的锁已经被其它线程拿走了，那么还没抢到锁的线程将从可运行状态转变为阻塞状态，只有当拿到锁的线程执行完同步块的代码后，就释放锁，让给别的线程的、这样就可以保证数据的完整性！

1.3 关于Lock对象和synchronized关键字的选择：

（1）最好两个都不用，使用一种java.util.concurrent包提供的机制，能够帮助用户处理所有与锁相关的代码。 ？？
（2）如果synchronized关键字能够满足用户的需求，就用synchronized，他能简化代码。
（3）如果需要使用更高级的功能，就用ReentrantLock类，此时要注意及时释放锁，否则会出现死锁，通常在finally中释放锁。

1.4 volatile与synchronized的区别：

参考链接：https://blog.csdn.net/suifeng3051/article/details/52611233

全面了解推荐链接：https://blog.csdn.net/suifeng3051/article/details/52611310 JMMJava内存模型

1. volatile本质是在告诉jvm当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取； synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
2. volatile仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的
3. volatile仅能实现变量的修改可见性，不能保证原子性；而synchronized则可以保证变量的修改可见性和原子性
4. volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。
5. volatile标记的变量不会被编译器优化；synchronized标记的变量可以被编译器优化

volatile就是基于内存屏障实现

1.5 happens-before

参考链接：https://www.cnblogs.com/chenssy/p/6393321.html

从jdk5开始，java使用新的JSR-133内存模型，基于happens-before的概念来阐述操作之间的内存可见性。

在JMM中，如果一个操作的执行结果需要对另一个操作可见，那么这两个操作之间必须存在happens-before关系，这两个操作即可以在同一个线程，也可以在不同的线程中。

• happens-before原则定义

1. 如果一个操作happens-before另一个操作，那么第一个操作的结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前
2. 两个操作之间存在happens-before关系，并不意味着一定要按照happens-before原则制定的顺序来执行。如果重排序之后的执行结果与按照happens-before关系来执行的结果一致，那么这种重排序并不非法。

• happens-before原则规则

1. 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；
2. 锁定规则：一个unLock操作先行发生于后面对同一个锁的lock操作；
3. volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；
4. 传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；
5. 线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；
6. 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；
7. 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；
8. 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；

happens-before与JMM的关系图（摘自《Java并发编程的艺术》）

二、HashMap (Java 8系列)

参考链接：https://tech.meituan.com/2016/06/24/java-hashmap.html

2.1 Map家族

• HashMap：根据键的hashCode值存储数据。非线程安全，可以用synchronizedMap方法使HashMap具有线程安全的能力，或者使用ConcurrentHashMap
• Hashtable：遗留类，线程安全，但是不建议使用
• LinkedHashMap：保存了记录的插入顺序
• TreeMap：实现了SortedMap接口，能够把它保存的记录根据键排序，默认是升序排序

2.2 HashMap存储结构

数组+链表+红黑树

当put一个键值对时，首先获取key值的hashCode值，在通过hash算法（高位运算和取模运算）来定位该剪值对对对应的数组下标，然后再找链表或红黑树值（具体见下面）。

在理解Hash和扩容流程之前，我们得先了解下HashMap的几个字段。从HashMap的默认构造函数源码可知，构造函数就是对下面几个字段进行初始化，源码如下：

int threshold;             // 所能容纳的key-value对极限 
final float loadFactor;    // 负载因子
int modCount;  
int size;  

• Load factor为负载因子(默认值是0.75)

• threshold是HashMap所能容纳的最大数据量的Node(键值对)个数，threshold = length * Load factor。也就是说，在数组定义好长度之后，负载因子越大，所能容纳的键值对个数越多。

• modCount字段主要用来记录HashMap内部结构发生变化的次数

• size：HashMap中实际存在的键值对数量

哈希桶数组table的长度length大小必须为2的n次方(一定是合数)，这是一种非常规的设计，常规的设计是把桶的大小设计为素数。HashMap采用这种非常规设计，主要是为了在取模和扩容时做优化，同时为了减少冲突，HashMap定位哈希桶索引位置时，也加入了高位参与运算的过程。

2.3 HashMap的put方法

（具体见链接）

三、ArrayList和LinkedList区别

参考链接：https://blog.csdn.net/eson_15/article/details/51145788

1. List概括

2. ArrayList和LinkedList区别

1. ArrayList实现了基于动态数组的数据结构，而LinkedList是基于链表的数据结构（双向链表，它同样可以被当做栈，队列或双端队列来使用）；
2. 对于随机访问get和set，ArrayList要优于LinkedList，因为LinkedList要移动指针；
3. 对于添加和删除操作add和remove，一般大家都会说LinkedList要比ArrayList快，因为ArrayList要移动数据。但是实际情况并非这样，对于添加或删除，LinkedList和ArrayList并不能明确说明谁快谁慢；

• 从源码可以看出，ArrayList想要get(int index)元素时，直接返回index位置上的元素，而LinkedList需要通过for循环进行查找，虽然LinkedList已经在查找方法上做了优化，比如index < size / 2，则从左边开始查找，反之从右边开始查找，但是还是比ArrayList要慢。这点是毋庸置疑的。
• ArrayList想要在指定位置插入或删除元素时，主要耗时的是System.arraycopy动作，会移动index后面所有的元素；LinkedList主耗时的是要先通过for循环找到index，然后直接插入或删除。(这就导致了两者并非一定谁快谁慢)

所以当插入的数据量很小时，两者区别不太大，当插入的数据量大时，大约在容量的1/10之前，LinkedList会优于ArrayList，在其后就劣与ArrayList，且越靠近后面越差。所以个人觉得，一般首选用ArrayList，由于LinkedList可以实现栈、队列以及双端队列等数据结构，所以当特定需要时候，使用LinkedList。当然咯，数据量小的时候，两者差不多，视具体情况去选择使用；当数据量大的时候，如果只需要在靠前的部分插入或删除数据，那也可以选用LinkedList，反之选择ArrayList反而效率更高。

四、JVM基础

参考链接：https://www.cnblogs.com/aspirant/p/6841955.html

1. 什么是JVM

• jvm是一种用于计算设备的规范，它是一个虚构出来的机器，是通过在实际的计算机上仿真模拟各种功能实现的。
• jvm包含一套字节码指令集，一组寄存器，一个栈，一个垃圾回收堆和一个存储方法域。
• VM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台上不加修改地运行。

2. JVM原理

java编译器只要面向jvm，生成jvm能理解的字节码文件。java源文件经编译成字节码程序，通过jvm将每条指令翻译成不同的机器码，通过特定平台运行。(JIT即时编译器Just-In-Time Compiler)

3. JVM执行程序的过程

1. 加载class文件
2. 管理并分配内存
3. 执行垃圾收集

4. JVM生命周期

1. JVM实例对应了一个独立运行的Java程序。它是进程级别

   • 启动。启动一个Java程序时，一个JVM实例就产生了
   • 运行。main()作为该程序初始线程的起点，任何其他线程均由该线程启动。JVM内部有两种线程：守护线程和非守护线程，main()属于非守护线程，守护线程通常由JVM自己使用，java程序也可以表明自己创建的线程是守护线程
   • 消亡。当程序中的所有非守护线程都终止时，JVM才退出；若安全管理器允许，程序也可以使用Runtime类或者System.exit()来退出

2. JVM执行引擎实例则对应了属于用户运行程序的线程。它是线程级别的

5. JVM内存模型

1. 运行时数据区，即jvm内存结构如下图。

2. 运行是数据区存储了哪些数据

   • 程序计数器（PC寄存器）

   每个线程都需要有自己独立的程序计数器,程序计数器是每个线程所私有的。由于程序计数器中存储的数据所占空间的大小不会随程序的执行而发生改变，因此，对于程序计数器是不会发生内存溢出现象(OutOfMemory)的。

   • Java栈

   Java栈中存放的是一个个的栈帧，每个栈帧对应一个被调用的方法，在栈帧中包括局部变量表(Local Variables)、操作数栈(Operand Stack)、指向当前方法所属的类的运行时常量池（运行时常量池的概念在方法区部分会谈到）的引用(Reference to runtime constant pool)、**方法返回地址(Return Address)**和一些额外的附加信息

   

   • 本地方法栈

   本地方法栈与Java栈的作用和原理非常相似。区别只不过是Java栈是为执行Java方法服务的，而本地方法栈则是为执行本地方法（Native Method）服务的

   • 堆

   Java中的堆是用来存储对象本身的以及数组（数组引用是存放在Java栈中的）。堆是被所有线程共享的，在JVM中只有一个堆。

   • 方法区

   与堆一样，是被线程共享的区域。在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。

五、JVM的垃圾回收机制

参考链接：https://www.cnblogs.com/aspirant/p/8662690.html

1. 哪些内存需要回收

JVM的内存结构包括五大区域：程序计数器、虚拟机栈、本地方法栈、堆区、方法区。其中程序计数器、虚拟机栈、本地方法栈3个区域随线程而生、随线程而灭，因此这几个区域的内存分配和回收都具备确定性，就不需要过多考虑回收的问题，因为方法结束或者线程结束时，内存自然就跟随着回收了。而Java堆区和方法区则不一样、不一样!(怎么不一样说的朗朗上口)，这部分内存的分配和回收是动态的，正是垃圾收集器所需关注的部分。

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

2. 判断对象是否存活相关算法

（1）引用计数算法

算法分析

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

优缺点

• 优点：引用计数收集器可以很快的执行，交织在程序运行中。对程序需要不被长时间打断的实时环境比较有利。
• 缺点：无法检测出循环引用。如父对象有一个对子对象的引用，子对象反过来引用父对象。这样，他们的引用计数永远不可能为0。

（2）可达性分析算法

算法分析

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

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

• 虚拟机栈中引用的对象（栈帧中的本地变量表）
• 方法区中类静态属性引用的对象
• 方法区中常量引用的对象
• 本地方法栈中JNI（Native方法）引用的对象

**现在问题来了，可达性分析算法会不会出现对象间循环引用问题呢？答案是肯定的，那就是不会出现对象间循环引用问题。**GC Root在对象图之外，是特别定义的“起点”，不可能被对象图内的对象所引用。

3. 对象死亡（被回收）前的最后一次挣扎

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

• 第一次标记：如果对象在进行可达性分析后发现没有与GC Roots相连接的引用链，那它将会被第一次标记；
• 第二次标记：第一次标记后接着会进行一次筛选，筛选的条件是此对象是否有必要执行finalize()方法。在finalize()方法中没有重新与引用链建立关联关系的，将被进行第二次标记。

第二次标记成功的对象将真的会被回收，如果对象在finalize()方法中重新与引用链建立了关联关系，那么将会逃离本次回收，继续存活。

4. Java引用

• 强引用

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

• 软引用(SoftReference)

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

• 弱引用

  也是用来描述非必需对象的，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在JDK 1.2之后，提供了WeakReference类来实现弱引用。比如 threadlocal

• 虚引用

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

5. 方法区如何判断是否需要回收

主要回收内容为：废弃常量和无用的类。对于废弃常量也可通过引用的可达性来判断，但是对于无用的类则需要同时满足下面3个条件：

• 该类所有的实例都已经被回收，也就是Java堆中不存在该类的任何实例；
• 加载该类的ClassLoader已经被回收；
• 该类对应的java.lang.Class对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

6. 常见的垃圾收集算法

（1）引用计数法（同上）

（2）标记-清除算法（Mark-Sweep）

最基础的垃圾回收算法，最容易实现，思想也是最简单的。

分为两个阶段：标记阶段和清除阶段。

标记阶段的任务是标记出所有需要被回收的对象，清除阶段就是回收被标记的对象所占用的空间。

标记-清除算法采用从根集合（GC Roots）进行扫描，对存活的对象进行标记，标记完毕后，再扫描整个空间中未被标记的对象，进行回收，如下图所示。

（3）复制算法（Copying）

（明天接着看。。。）