Java

JVM 可以理解的代码就叫做字节码（即扩展名为 .class 的文件），它不面向任何特定的处理器，只面向虚拟机。

Java 语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。

JVM 类加载器首先加载字节码文件，然后通过解释器逐行解释执行，这种方式的执行速度会相对比较慢。

编译模式

通过编译器将源代码一次性翻译成可被该平台执行的机器码。

编译语言的执行速度比较快，开发效率比较低。

常见的编译性语言有 C、C++、Go、Rust 等等。

通过解释器一句一句的将代码解释（interpret）为机器代码后再执行。

解释型语言开发效率比较快，执行速度比较慢。

常见的解释性语言有 Python、JavaScript、PHP 等等。

为了改善编译语言的效率而发展出的即时编译技术，已经缩小了编译型和解释型语言间的差距。

这种技术混合了编译语言与解释型语言的优点，它像编译语言一样，先把程序源代码编译成字节码。到执行期时，再将字节码直译，之后执行。

Java 与 LLVM 是这种技术的代表产物。

被赋予特殊含义的标识符，Java 语言已经赋予了其特殊的含义，只能用于特定的地方。

continue、break 和 return

注意

自增运算符（++)、自减运算符（--）

++ 和 -- 运算符可以放在变量之前或变量之后，当运算符放在变量之前时(前缀)，先自增/减，再赋值；当运算符放在变量之后时(后缀)，先赋值，再自增/减。

移位运算符是最基本的运算符之一，几乎每种编程语言都包含这一运算符。

移位操作中，被操作的数据被视为二进制数，移位就是将其向左或向右移动若干位的运算。

在 Java 代码里使用 <<、 >> 和 >>> 转换成的指令码运行起来会更高效些。

分类

注意

new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。

整数型

浮点型

char

boolean

字节 vs 位数

Byte、Short、Integer、Long、Float、Double、Character、Boolean 。

Java 基本数据类型的包装类型的大部分都用到了缓存机制来提升性能。

缓存范围

两种浮点数类型的包装类 Float，Double 并没有实现缓存机制。

比较

装箱

拆箱

注意

在外部调用静态方法时，可以使用 类名.方法名 的方式，也可以使用 对象.方法名 的方式（不推荐），而实例方法只有 对象.方法名 这种方式。

静态方法在访问本类的成员时，只允许访问静态成员，不允许访问实例成员，而实例方法不存在这个限制。

发生在同一个类中（或者父类和子类之间），方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同。

重写发生在运行期，是子类对父类的允许访问的方法的实现过程进行重新编写。

规则

名字与类名相同。

没有返回值，但不能用 void 声明构造函数。

生成类的对象时自动执行，无需调用。

不能被 override（重写），但可以 overload（重载）。

实参（实际参数，Arguments）

形参（形式参数，Parameters）

值传递

引用传递

很多程序设计语言（比如 C++、 Pascal )提供了两种参数传递的方式，不过，在 Java 中只有值传递（创建地址副本）。

从 Java5 开始，Java 支持定义可变长参数，所谓可变长参数就是允许在调用方法时传入不定长度的参数。

格式

原理

注意

把一个对象的状态信息（也就是属性）隐藏在对象内部，不允许外部对象直接访问对象的内部信息，但提供一些可以被外界访问的方法来操作属性。

使用已存在的类的定义作为基础建立新类，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。

可以快速地创建新的类，可以提高代码的重用，程序的可维护性，节省大量创建新类的时间 ，提高我们的开发效率。

特点

一个对象具有多种的状态，具体表现为父类的引用指向子类的实例。

特点

都不能被实例化。

都可以包含抽象方法。

都可以有默认实现的方法（Java 8 可以用 default 关键字在接口中定义默认方法）。

接口主要用于对类的行为进行约束，实现了某个接口就具有了对应的行为。抽象类主要用于代码复用，强调的是所属关系。

一个类只能继承一个类，但是可以实现多个接口。

接口中的成员变量只能是 public static final 类型的，不能被修改且必须有初始值，而抽象类的成员变量默认 default，可在子类中被重新定义或被重新赋值。

浅拷贝会在堆上创建一个新对象，但原对象内部的属性是引用类型，浅拷贝会直接复制内部对象的引用地址，也就是拷贝对象和原对象共用同一个内部对象。

深拷贝会完全复制整个对象，包括这个对象所包含的内部对象。

public final native Class<?> getClass();
native 方法，用于返回当前运行时对象的 Class 对象，使用了 final 关键字修饰，故不允许子类重写。

public native int hashCode();
native 方法，用于返回对象的哈希码，主要使用在哈希表中，比如 JDK 中的HashMap。

public boolean equals(Object obj);
用于比较 2 个对象的内存地址是否相等，String 类对该方法进行了重写以用于比较字符串的值是否相等。

protected native Object clone() throws CloneNotSupportedException;
native 方法，用于创建并返回当前对象的一份拷贝。

public String toString();
返回类的名字实例的哈希码的 16 进制的字符串。建议 Object 所有的子类都重写这个方法。

public final native void notify();
native 方法，并且不能重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。

public final native void notifyAll();
native 方法，并且不能重写。跟 notify 一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。

public final native void wait(long timeout) throws InterruptedException;
native方法，并且不能重写。暂停线程的执行。注意：sleep 方法没有释放锁，而 wait 方法释放了锁 ，timeout 是等待时间。

public final void wait(long timeout, int nanos) throws InterruptedException;
多了 nanos 参数，这个参数表示额外时间（以纳秒为单位，范围是 0-999999）。 所以超时的时间还需要加上 nanos 纳秒。

public final void wait() throws InterruptedException;
跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间这个概念。

protected void finalize() throws Throwable { }
实例被垃圾回收器回收的时候触发的操作。

基本数据类型比较的是值。

引用数据类型比较的是对象的内存地址。

不能用于判断基本数据类型的变量，只能用来判断两个对象是否相等。

没重写：比较的是对象的内存地址。重写：比较属性或自定义内容。自定义类推荐重写此方法。

如果两个对象的hashCode 值相等，那这两个对象不一定相等（哈希碰撞）。

如果两个对象的hashCode 值相等并且 equals() 方法也返回 true，我们才认为这两个对象相等。

如果两个对象的hashCode 值不相等，我们就可以直接认为这两个对象不相等。

Latin-1 编码方案下，byte 占一个字节(8 位)，char 占用 2 个字节（16），byte 相较 char 节省一半的内存空间。

基本数据类型（byte、boolean、short、char、int、float、long、double）以及字符串常量。

final 修饰的基本数据类型和字符串变量。

字符串通过 “+”拼接得到的字符串、基本数据类型之间算数运算（加减乘除）、基本数据类型的位运算（<<、>>、>>> ）

String getMessage()：返回异常发生时的简要描述。

String toString()：返回异常发生时的详细信息。

String getLocalizedMessage()：返回异常对象的本地化信息。
使用 Throwable 的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与 getMessage()返回的结果相同。

void printStackTrace()：在控制台上打印 Throwable 对象封装的异常信息。

Checked Exception

Unchecked Exception

try块：用于捕获异常。其后可接零个或多个 catch 块，如果没有 catch 块，则必须跟一个 finally 块。

catch块：用于处理 try 捕获到的异常。

finally 块：无论是否捕获或处理异常，finally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行。

注意

适用

关闭资源和 finally 块的执行顺序

public class Generic<T> { private T key; }
此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
在实例化泛型类时，必须指定T的具体类型。

public interface Generator<T> { public T method(); }

public static <E> void printArray( E[] inputArray ) { }

只能声明不能实例化 T 类型变量。

泛型参数不能是基本类型。因为基本类型不是 Object ⼦类，应该⽤基本类型对应的引⽤类型代替。

不能实例化泛型参数的数组。擦除后为 Object 后⽆法进⾏类型判断。

不能实例化泛型数组。

泛型⽆法使⽤ Instance of 和 getClass() 进⾏类型判断。

不能实现两个不同泛型参数的同⼀接⼝，擦除后多个⽗类的桥⽅法将冲突。

不能使⽤ static 修饰泛型变量。

⽆界通配符可以接收任何泛型类型数据，⽤于实现不依赖于具体类型参数的简单⽅法，可以捕获参数类型并交由泛型⽅法进⾏处理。

通配符 ？和通配符 T

上边界通配符 extends 可以实现泛型的向上转型即传⼊的类型实参必须是指定类型的⼦类型。

下边界通配符 super 与上边界通配符 extends 刚好相反，它可以实现泛型的向下转型即传⼊的类型实参必须是指定类型的⽗类型。

? extends xxx 和 ? super xxx

T extends xxx 和 ? extends xxx

Class<?> 和 Class

META-INF/services/

能够大大地提高接口设计的灵活性。

需要遍历加载所有的实现类，不能做到按需加载，这样效率还是相对较低的。

当多个 ServiceLoader 同时 load 时，会有并发问题。

Spring 框架、数据库加载驱动、日志接口SLF4J （Simple Logging Facade for Java）、以及 Dubbo 的扩展实现等等。

Hessian、Kryo、Protobuf、ProtoStuff，不推荐JDK自带（不支持跨语言调用、性能差、存在安全问题）。

像 JSON 和 XML 这种属于文本类序列化方式。虽然可读性比较好，但是性能较差，一般不会选择。

阻止实例中那些用此关键字修饰的的变量序列化；当对象被反序列化时，被 transient 修饰的变量值不会被持久化和恢复。

transient 只能修饰变量，不能修饰类和方法。

transient 修饰的变量，在反序列化后变量值将会被置成类型的默认值。

static 变量因为不属于任何对象（Object），所以无论有没有 transient 关键字修饰，均不会被序列化。

实现和应用角度

JVM 角度

定义一个接口及其实现类。

创建一个代理类同样实现这个接口。

将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。
这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

实现和应用角度

JVM角度

日常开发使用较少，但在框架中使用非常多。

JDK 动态代理的目标对象必须要有接口实现，也就是说：委托类必须要继承接口。

核心

步骤

CGLIB（Code Generation Library）是一个基于 ASM 的字节码生成库，允许在运行时对字节码进行修改和动态生成。

原理

核心

步骤

应用

JDK 动态代理只能代理实现了接口的类或者直接代理接口，而 CGLIB 可以代理未实现任何接口的类。

效率上，JDK 动态代理更优秀，随着 JDK 版本的升级，这个优势更加明显。

这种方式分配的内存属于堆外内存 ，是无法进行垃圾回收的，需要把这些内存当做一种资源去手动调用 freeMemory 方法进行释放，否则会产生内存泄漏。

通用的操作内存方式是在 try 中执行对内存的操作，最终在 finally 块中进行内存的释放。

put、get

常规对象实例化方式

非常规的实例化方式

List、Set 和 Queue。

（Least Recently Used，最近最少使用） 缓存，确保当存放的元素超过容器容量时，将最近最少访问的元素移除。

accessOrder 设置为 true 并重写 removeEldestEntry 方法（移除规则）。

实现 Comparable 接口并重写 compareTo(Object obj) 方法。 

new 一个 Comparator 比较器实例并重写其 compare(Object obj1, Object obj2) 方法。

不能修改

Arrays.stream(myArray).collect(Collectors.toList())

不可变

可变

CollectionUtils.addAll(list, str)

List<Integer> list = List.of(array)

JDK 1.2 之前，一种用户级线程（用户线程），也就是说 JVM 自己模拟了多线程的运行，而不依赖于操作系统。

由用户空间程序管理和调度的线程，运行在用户空间（专门给应用程序使用）。

由操作系统内核管理和调度的线程，运行在内核空间（只有内核程序可以访问）。

用户线程创建和切换成本低，但不可以利用多核。内核态线程，创建和切换成本高，可以利用多核。

问题：内存泄漏、死锁、线程不安全等

在多线程环境下对于同一份数据的访问是否能够保证其正确性和一致性的描述。

CPU 密集型和 IO 密集型。

NEW: 初始状态，线程被创建出来但没有被调用 start() 。

RUNNABLE: 运行状态，线程被调用了 start()等待运行的状态。

BLOCKED：阻塞状态，需要等待锁释放。

WAITING：等待状态，表示该线程需要等待其他线程做出一些特定动作（通知或中断）。

TIME_WAITING：超时等待状态，可以在指定的时间后自行返回而不是像 WAITING 那样一直等待。

TERMINATED：终止状态，表示该线程已经运行完毕。

线程切换需要保存以及恢复相应线程的上下文。

多线程中一个或多个等待某个资源释放，而被无限期阻塞，导致程序不能正常终止。

条件

sleep() 方法没有释放锁，wait() 方法释放了锁 。

sleep()方法操作线程，wait()方法操作对象（对象锁）。

new一个Thread并调用start()，分到时间片后，start()准备后自动调用run()。

直接调用run()就是main线程下的普通方法。

程序顺序规则：一个线程内，按照代码顺序，书写在前面的操作 happens-before 于书写在后面的操作。

解锁规则：解锁 happens-before 于加锁。

volatile 变量规则：对一个 volatile 变量的写操作 happens-before 于后面对这个 volatile 变量的读操作。

传递规则：如果 A happens-before B，且 B happens-before C，那么 A happens-before C。

线程启动规则：Thread 对象的 start()方法 happens-before 于此线程的每一个动作。

如果两个操作不满足上述任意一个 happens-before 规则，JVM 就可以对这两个操作进行重排序。

借助synchronized、各种 Lock 以及各种原子类实现原子性。

借助synchronized、volatile 以及各种 Lock 实现可见性。

volatile 关键字可以禁止指令进行重排序优化。

Compare And Swap（比较与交换）

原子操作，底层依赖于一条 CPU 的原子指令。

三个操作数

早起属于重量级锁，Java 6 后轻量级锁

自旋锁、适应性自旋锁、锁消除、锁粗化、偏向锁、轻量级锁

偏向锁增加了 JVM 的复杂性，JDK15默认关闭，JDK18彻底废弃

修饰实例方法；修饰静态方法；修饰代码块；

通过获取对象监视器 monitor 实现。

只能是非公平锁。

实现了 Lock 接口，是一个可重入且独占式的锁，和 synchronized 关键字类似。

更灵活、更强大，增加了轮询、超时、中断、公平锁和非公平锁等高级功能。

内部类 Sync 继承 AQS（AbstractQueuedSynchronizer）

内部类 Sync 有公平锁 FairSync 和非公平锁 NonfairSync 两个子类，默认非公平锁。

公平锁 : 锁被释放之后，先申请的线程先得到锁。

非公平锁：锁被释放之后，后申请的线程可能会先获取到锁，是随机或者按照其他优先级排序的。

synchronized 和 ReentrantLock都是可重入锁。

等待可中断；可实现公平锁；可实现选择性通知（锁可以绑定多个条件）；

使用少，JDK1.8后使用性能更好的读写锁 StampedLock。

ThreadLocal<?> k ，继承自WeakReference，弱引用

代码中放入的值，强引用

HASH_INCREMENT = 0x61c88647

斐波那契数 也叫 黄金分割数。hash增量为 这个数字，带来的好处就是 hash 分布非常均匀。

HashMap通过链表结构或红黑树解决。

ThreadLocalMap没有链表结构，采用。。。

探测式清理(expungeStaleEntry())：以当前Entry 往后清理，遇到值为null则结束清理，属于线性探测清理。

启发式清理(cleanSomeSlots())：Heuristically scan some cells looking for stale entries.

先探测式清理再扩容

在异步场景下给子线程共享父线程中创建的线程副本数据。

有缺陷，推荐阿里开源的 TransmittableThreadLocal 组件。

ThreadLocalMap 中使用的 key 为 ThreadLocal 的弱引用，而 value 是强引用。
所以，如果 ThreadLocal 没有被外部强引用的情况下，在垃圾回收的时候，key 会被清理掉，而 value 不会被清理掉。

FixedThreadPool：返回一个固定线程数量的线程池。

SingleThreadExecutor： 返回一个只有一个线程的线程池。

CachedThreadPool： 返回一个可调整线程数量的线程池。

ScheduledThreadPool：返回一个延迟后运行或者定期执行任务的线程池。

弊端：最大Integer.MAX_VALUE，导致OOM。

抛出 RejectedExecutionException来拒绝新任务的处理。

任务回退给调用者，使用调用者的线程来执行任务。

不处理新任务，直接丢弃掉。

将丢弃最早的未处理的任务请求。

解决：TransmittableThreadLocal(TTL)

Runnable 接口不会返回结果或抛出检查异常，但是 Callable 接口可以。

execute()无返回值，submit()有返回值。

shutdown()关闭线程池，线程池的状态变为 SHUTDOWN。

shutdownNow()关闭线程池，线程池的状态变为 STOP。

isShutDown 当调用 shutdown() 方法后返回为 true。

isTerminated 当调用 shutdown() 方法后，并且所有提交的任务完成后返回为 true。

创建

处理异步结算的结果

异常处理

组合

并行

建议使用自定义的线程池，而非默认的 ForkJoinPool.commonPool()

尽量避免使用 get()

正确进行异常处理

合理组合多个异步任务

一次性。

BlockingQueue 接口的有界队列实现类，底层采用数组来实现。

底层基于单向链表实现的阻塞队列，可以当做无界队列也可以当做有界队列来使用。

支持优先级的无界阻塞队列。

用于从源头（通常是文件）读取数据（字节信息）到内存中

FileInputStream

DataInputStream

ObjectInputStream

用于将数据（字节信息）写入到目的地（通常是文件）

FileOutputStream

DataOutputStream

ObjectOutputStream

字符流默认采用的是 Unicode 编码

Unicode：任何字符都占 2 个字节

Utf8：英文占 1 字节，中文占 3 字节

Gbk：英文占 1 字节，中文占 2 字节

用于从源头（通常是文件）读取数据（字符信息）到内存中

InputStreamReader

FileReader

用于将数据（字符信息）写入到目的地（通常是文件）

OutputStreamWriter

FileWriter

IO 操作很消耗性能，缓冲流将数据加载至缓冲区，一次性读取/写入多个字节，避免频繁操作来提高效率。

原理

BufferedInputStream（字节缓冲输入流）、BufferedOutputStream（字节缓冲输出流）

ZipInputStream 和 ZipOutputStream 可以分别增强字节缓冲流

类似于字节缓冲流，内部都维护了一个字节数组作为缓冲区。不过，前者主要是用来操作字符信息。

System.out 实际是用于获取一个 PrintStream 对象

PrintStream（字节打印流）、PrintWriter （字符打印流）

随意跳转到文件的任意位置进行读写

应用

RandomAccessFile 的实现依赖于 FileDescriptor (文件描述符) 和 FileChannel （内存映射文件）。

适配者(Adaptee)

适配器(Adapter)

类适配器

对象适配器

NIO 中大量用到了工厂模式

应用程序会一直发起 read 调用，只有最后的read会一直阻塞，直到内核把数据拷贝到用户空间。

调用轮询数据，十分消耗 CPU 资源。

应用程序先查询内核数据是否准备就绪，就绪后再发起read调用，调用过程中还是阻塞的。

NIO 读写数据都是通过缓冲区进行操作的。

变量

模式

Channel 是一个双向的、可读可写的数据传输通道，NIO 通过 Channel 来实现数据的输入输出。

read ：读取 Channel 数据并写入到 Buffer 中。

write ：将 Buffer 中的数据写入到 Channel 中。

允许一个线程处理多个 Channel，基于事件驱动的 I/O 多路复用模型。

原理

JDK 使用了 epoll() 代替传统的 select 实现，所以它并没有最大连接句柄 1024/2048 的限制。

事件类型

Selector是抽象类，可以通过调用此类的 open() 静态方法来创建 Selector 实例。

执行 IO 操作时，避免 CPU 存储区域之间的数据复制，从而减少上下文切换以及 CPU 的拷贝时间来提升性能。

应用

常见实现技术

Java支持

不建议直接使用原生 NIO，推荐使用一些成熟的基于 NIO 的网络编程框架比如 Netty。

JDK 1.7

线程私有的

线程共享的

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

字节码解释器通过改变程序计数器来依次读取指令，从而实现代码的流程控制。

在多线程的情况下，程序计数器用于记录当前线程执行的位置，以便切换回来后继续执行。

唯一一个不会出现 OutOfMemoryError 的内存区域，它的生命周期与线程保持一致。

JVM 运行时数据区域的一个核心，生命周期与线程保持一致。

栈由一个个栈帧组成，而每个栈帧中都拥有：局部变量表、操作数栈、动态链接、方法返回地址。

拥有先进后出的数据结构，只支持出栈和入栈两种操作。

局部变量表

操作数栈

动态链接

只为虚拟机使用到的 Native 方法服务的Java虚拟机栈。

最大一块内存区域，在虚拟机启动时创建，唯一目的就是存放对象实例。

注意：随着 JIT 编译器的发展与逃逸分析技术逐渐成熟，并不是所有对象都在堆中分配，JDK 1.7 默认开启逃逸分析。

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

结构

OutOfMemoryError

JVM 运行时数据区域的一块逻辑区域。

类加载时，存储类信息、字段信息、方法信息、常量、静态变量、即时编译器编译后的代码缓存等数据。

方法区和永久代以及元空间关系

常量池表(Constant Pool Table)

常量池表会在类加载后存放到方法区的运行时常量池中。

运行时常量池是方法区的一部分，受到方法区内存的限制，也会抛出 OutOfMemoryError 错误。

JVM 为了提升性能和减少内存消耗针对字符串（String 类）专门开辟的一块区域，主要目的是为了避免字符串的重复创建。

原理

JDK1.7 之前，字符串常量池存放在永久代。JDK1.7 字符串常量池和静态变量从永久代移动了 Java 堆中。

JDK 1.7 将字符串常量池移动到堆中原因

一种特殊的内存缓冲区，并不在 Java 堆或方法区中分配的，而是通过 JNI 的方式在本地内存上分配的。

堆外内存

类加载检查

分配内存

初始化零值

设置对象头

执行 init 方法

对象头

实例数据

对齐填充

Java 程序通过栈上的 reference 数据来操作堆上的具体对象，对象的访问方式由虚拟机实现而定。

句柄

直接指针

新生代无足够空间时，虚拟机通过 分配担保机制 把新生代的对象提前转移到老年代中。

优化策略：减少新生代的垃圾回收频率和成本。

对象年龄（Age）计数器，每次GC，年龄就增加1，年龄超过设置（默认15）则晋升到老年代中。

部分收集 (Partial GC)

整堆收集 (Full GC)：收集整个 Java 堆和方法区。

为了确保在 Minor GC 之前老年代本身还有容纳新生代所有对象的剩余空间。

给对象中添加一个引用计数器，引用+1，引用失效-1，0代表无引用。

简单高效，但使用少，原因：很难解决对象之间循环引用的问题。

以 “GC Roots” 的对象为起点向下搜索，节点所走过的路径称为引用链，当对象到 GC Roots 没有任何引用链相连则证明此对象不可达。

可以作为 GC Roots 的对象

不可达对象在死亡前，仍需要经历两次标记才能真正死亡被回收：finalize 方法和队列标记。

JDK1.2 以后，Java 对引用的概念进行了扩充，将引用分为强引用、软引用、弱引用、虚引用四种（引用强度逐渐减弱）

强引用（StrongReference）

软引用（SoftReference）

弱引用（WeakReference）

虚引用（PhantomReference）

除了强引用外，在程序设计中一般很少使用弱引用与虚引用，使用软引用的情况较多。

没有任何对象引用的常量就是废弃常量，如果这时发生内存回收的话而且有必要的话，废弃常量就会被系统清理。

条件

虚拟机可以对满足条件的无用的类进行回收，而不是必然被回收。

首先标记（Mark）出所有不需要回收的对象，在标记完成后统一清除（Sweep）掉所有没有被标记的对象。

最基础的收集算法，后续的算法都是对其不足进行改进得到。

问题

将内存分为大小相同的两块A和B，只使用A，当A使用完后，就将还存活的对象复制到B，然后再把A一次清理掉。

问题

标记过程与“标记-清除”算法一样，但后续是让所有存活的对象向一端移动，然后直接清理掉端边界以外的内存。

由于多了整理这一步，因此效率也不高，适合老年代这种垃圾回收频率不是很高的场景。

根据对象存活周期的不同将内存分为几块（新生代和老年代），以便根据各个年代的特点选择合适的垃圾收集算法。

当前虚拟机的垃圾收集都采用分代收集算法。

JDK 8：Parallel Scavenge（新生代）+ Parallel Old（老年代）

JDK 9 ~ JDK20: G1

Serial（串行）收集器是最基本、历史最悠久的垃圾收集器。

单线程收集器，只会使用一条线程去完成工作同时，必须暂停其他所有的工作线程（ "Stop The World" ），直到它工作结束。

新生代采用标记-复制算法，老年代采用标记-整理算法。

优点：简单而高效（与其他收集器的单线程相比），运行在 Client 模式下的虚拟机的不错选择。

Serial 收集器的多线程版本，运行在 Server 模式下的虚拟机的首选。

新生代采用标记-复制算法，老年代采用标记-整理算法。

几乎和 ParNew 收集器一样，但其关注点是吞吐量（高效率的利用 CPU），其它关注更多的是用户线程的停顿时间（提高用户体验）。

吞吐量就是 CPU 中用于运行用户代码的时间与 CPU 总消耗时间的比值。

新生代采用标记-复制算法，老年代采用标记-整理算法。

JDK1.8 默认使用的垃圾收集器是 Parallel Scavenge + Parallel Old。

Serial 收集器的老年代版本，它同样是一个单线程收集器。

用途

Parallel Scavenge 收集器的老年代版本，使用多线程和“标记-整理”算法。

在注重吞吐量以及 CPU 资源的场合，都可以优先考虑 Parallel Scavenge 收集器和 Parallel Old 收集器。

以获取最短回收停顿时间为目标的收集器。它非常符合在注重用户体验的应用上使用。

HotSpot 虚拟机第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程（基本上）同时工作。

步骤

优点

缺点

从 JDK9 开始，CMS 收集器已被弃用。

面向服务器的垃圾收集器，主要针对配备多颗处理器及大容量内存的机器，以极高概率满足 GC 停顿时间要求的同时，还具备高吞吐量性能特征。

特点

步骤

G1 收集器在后台维护了一个优先列表，每次根据允许的收集时间，优先选择回收价值最大的 Region。

从 JDK9 开始，G1 垃圾收集器成为了默认的垃圾收集器。

与 CMS 中的 ParNew 和 G1 类似，ZGC 也采用标记-复制算法，不过 ZGC 对该算法做了重大改进。

ZGC 可以将暂停时间控制在几毫秒以内，且暂停时间不受堆内存大小的影响，出现 Stop The World 的情况会更少，但代价是牺牲了一些吞吐量。

ZGC 在 Java11 中引入，处于试验阶段，在 Java15 已经可以正式使用了，最大支持 16TB 的堆内存。但默认的垃圾回收器依然是 G1。

接近于 Java 语言层面的的常量概念，如文本字符串、声明为 final 的常量值等。

属于编译原理方面的概念。包括 类和接口的全限定名、字段的名称和描述符、方法的名称和描述符 这三类常量。

通过全类名获取定义此类的二进制字节流。

将字节流所代表的静态存储结构转换为方法区的运行时数据结构。

在内存中生成一个代表该类的 Class 对象，作为方法区这些数据的访问入口。

确保 Class 文件的字节流中包含的信息符合《Java 虚拟机规范》的全部约束要求。

组成

正式为类变量分配内存并设置类变量初始值的阶段，在方法区中分配。

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

主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用限定符 7 类符号引用进行。

执行初始化方法 <clinit> ()方法的过程，是类加载的最后一步。

必须对类进行初始化的6种情况

注意

卸载类即该类的 Class 对象被 GC。

要求

最顶层的加载类，由 C++实现，通常表示为 null，并且没有父级。

作用

拓展

加载 %JRE_HOME%/lib/ext 目录下的 jar 包和类以及被 java.ext.dirs 系统变量所指定的路径下的所有类。

Java 9 引入了模块系统，并且略微更改了上述的类加载器。扩展类加载器被改名为平台类加载器（platform class loader）。

面向我们用户的加载器，负责加载当前应用 classpath 下的所有 jar 包和类。

需要继承 ClassLoader抽象类。

重写

将一个类加载器保存在线程私有数据里，跟线程绑定，然后在需要的时候取出来使用。

ClassLoader 类使用委托模型来搜索类和资源。

双亲委派模型要求除了顶层的启动类加载器外，其余的类加载器都应有自己的父类加载器。

ClassLoader 实例会在试图亲自查找类或资源之前，将搜索类或资源的任务委托给其父类加载器。

在类加载的时候，系统会首先判断当前类是否被加载过。

类加载器在进行类加载的时候，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成。

只有当父加载器反馈自己无法完成这个加载请求时，子加载器才会尝试自己去加载。

如果子类加载器也无法加载这个类，那么它会抛出一个 ClassNotFoundException 异常。

拓展

保证了 Java 程序的稳定运行，可以避免类的重复加载，也保证了 Java 的核心 API 不被篡改。

自定义类加载器并重写 loadClass(String name, boolean resolve) 方法。

单纯依靠自定义类加载器没办法满足某些场景的要求，例如，有些情况下，高层的类加载器需要加载低层的加载器才能加载的类。

应用

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

heap size 表示要初始化内存的具体大小。

unit 表示要初始化内存的单位。单位为 “ g” (GB)、“ m”（MB）、“ k”（KB）。

默认情况下，YG 的最小大小为 1310 MB，最大大小为 无限制。

方式

GC调优策略

永久代

元空间

注意

通过-XX:+Use<垃圾回收器标识>指定。

串行垃圾收集器（SerialGC）、并行垃圾收集器（ParallelGC）、CMS 垃圾收集器（ParNewGC）、G1 垃圾收集器（G1GC）

通过-XX:+Print<打印内容标识>指定。

# 必选
# 打印基本 GC 信息
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
# 打印对象分布
-XX:+PrintTenuringDistribution
# 打印堆数据
-XX:+PrintHeapAtGC
# 打印Reference处理信息
# 强引用/弱引用/软引用/虚引用/finalize 相关的方法
-XX:+PrintReferenceGC
# 打印STW时间
-XX:+PrintGCApplicationStoppedTime

# 可选
# 打印safepoint信息，进入 STW 阶段之前，需要要找到一个合适的 safepoint
-XX:+PrintSafepointStatistics
-XX:PrintSafepointStatisticsCount=1

# GC日志输出的文件路径
-Xloggc:/path/to/gc-%t.log
# 开启日志文件分割
-XX:+UseGCLogFileRotation
# 最多分割几个文件，超过之后从头文件开始写
-XX:NumberOfGCLogFiles=14
# 每个文件上限大小，超过就触发分割
-XX:GCLogFileSize=50M