JAVA 知识体系（第四版）

用来存储字符串中的字符。

用来缓存计算之后的 hascode。这样就不用每次都重新计算哈希值了。

通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然字符串内容
相同，但是地址值不同

以“”方式给出的字符串，此时字符串值声明在字符串常量池中，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几
次，JVM 都只会建立一个 String 对象，并在字符串池中维护，且字符串常量池不会存储相同的字符串

String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd"
// 内存中有"abc"，"abcd","d",3个对象，s1从指向"abc"，改变指向，指向了"abcd"。

String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

String str = "abc";
相当于：
char[] data = {'a', 'b', 'c'};
String str = new String(data);
// String底层是靠字符数组实现的,jdk9底层是字节数组。
byte[] bys = {97,98,99};
String str = new String(bys);

当字符串重新赋值时，需要重写指定内存区域赋值，不能使用原有的value进行赋值

当对现有字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

当使用 String 类提供的修改方法时，都是重新 new 了一个String 对象，并未对原有的内存区域进行修改

1、new一个 StringBuilder，传入一个 string 类型参数，调用有参构造方法

2、在构造方法中，调用 appennd 方法

3、判断传入的 string 是否为null，然后获取 string 长度

4、做扩容判断，是否扩容，如果需要扩容，则扩容至原来数组长度的2倍再加 2

5、调用 String 的 getChars 方法，将传入参数 String 的 value 数组 拷贝到原有的 StringBuilder 的 value 数组中

与 StringBuilder 一致，自己的 append 方法里都是显示调用父类 AbstractBuilder 的 append 方法，super.append()，只不过在调用 StringBuffer 的 append 方法时，StringBuffer 会在自己的 append 方法加上 synchronized  做同步

用来存储字符序列中的字符。value是一个动态的数组，当存储容量不足时，会对它进行扩容。

表示value数组中已存储的字符数。

描述数据具有的共性

描述类具有的行为，表现形式即方法，方法的调用即执行类的行为

具体的不同表现为：类型、个数、顺序的不同才可以构成重载

相同

两小

一大

编译和运行都看父类

编译看父类，运行看子类

编译和运行都看父类

编译和运行都看父类

如果变量的类型为父类类型,该变量就可以接收该父类类型的对象或者其所有子
类对象

如果参数类型为父类类型,该参数就可以接收该父类类型的对象或者其所有子类对象

如果返回值类型为父类类型,那么就可以返回该父类类型的对象或者其所有子类对象

提高代码的可扩展性

多态的情况下，只能调用父类的共性内容，不能调用子类的特有内容。

this()

this(实参)

super()

super(实参)

static 方法属于类方法，随着类的加载而加载，所以静态方法可以直接通过类名来调用，静态方法也可以访问其他静态方法，而非静态成员属于对象，类会优先于对象存在，静态成员随着类加载而加载，所以当静态方法加载到内存时，非静态成员还未被加载到内存中，所以静态方法无法访问非静态成员

非静态方法调用时·，对象已经存在，而静态成员也早于对象（一般情况）被加载，所以非静态方法可以访问调用任意成员

没有方法体,使用abstract修饰的方法就是抽象方法，但 abstract 不能与 static 共存

强制要求子类实现，如果子类不实现抽象方法就必须加上 abstract 关键字，把子类也变成抽象类

如果有冲突，则实现类不继承冲突的静态常量，当使用子类访问冲突的静态常量时，编译直接报错

实现类只需要重写一个

实现类必须重写一次最终版本

接口中的静态方法不能被继承,所以不存在冲突

私有方法只能在本接口中直接使用,不存在冲突

子接口无法继承父接口中冲突的常量，当使用子接口访问冲突的静态常量时，编译报错

子接口只会继承一个有冲突的抽象方法，子接口的实现类会自己实现

子接口中必须重写一次有冲突的默认方法(注意要加default)

不冲突,因为静态方法是直接属于接口的,只能使用本接口直接访问,而私有方法只能在接口中访问,也没有冲突

子类无法继承有冲突的常量，当使用子类访问冲突的静态常量时，编译报错

子类必须重写一次有冲突的抽象方法

优先访问父类的

只会访问父类的静态方法

不存在冲突

即没有使用static修饰的内部类.这说明,成员内部类属于外部类的实例对象,不属于外部类本身(类比字段).

OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();

1、成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括 private 和 静态成员）

2、成员内部类要访问外部类的同名成员，需要以下面的形式进行访问

3、外部类要访问成员内部类的成员，必须先创建一个成员内部类的对象，在通过指向这个对象的引用来访问

4、成员内部类可以拥有四大访问权限

5、成员内部类可以定义常量，但不能定义静态成员

使用static修饰的内部类.所以,该内部类属于外部类本身,而不属于外部类的实例对象

OuterClass.InnerStaticClass innerStaticClass = new OuterClass.InnerStaticClass();

import com.qmy.innerClass.OuterClass.InnerStaticClass;
InnerStaticClass innerStaticClass = new InnerStaticClass();

1、在创建内部类的实例时，不必创建外部类的实例，不依赖于外部类实例存在

2、可以定义静态和非静态成员，但只能访问外部类的静态成员，不能直接访问外部类非静态成员，除非持有外部类实例引用

匿名内部类是一个没有名称的局部内部类,适合于只使用一次的类，匿名内部类必须继承一个父类或者实现一个接口,但最多只能继承一个父类或实现一个接口.

Runnable thread = new Runnable() {
@Override
public void run() {
}
};

1、匿名内部类是不能有访问修饰符和static修饰符的；

2、匿名内部类是唯一一种没有构造器的类；

3、匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

在方法中定义的内部类,其可见范围是当前方法,和局部变量是同一个级别,所以局部内部类只能在方法中使用.

1、局部内部类和方法里面的局部变量一样，是不能有public、protected、private以及static修饰符的。

2、局部内部类是定义在一个方法或者一个作用域里面的类，局部内部类的访问仅限于方法内或者该作用域内；

3、局部内部类访问的局部变量必须使用 final 修饰，在 Java8 中是自动隐式加上 final (语法糖)，如果局部内部类访问到的局部变量自动加上 final 编变成常量

4、局部内部类和成员内部类一样,不能包含静态成员

当方法被调用运行完毕之后，当前方法的栈帧被销毁，方法内部的局部变量的空间全部销毁。但内部类对象可能还在堆内存中，要直到没有被引用时才会消亡。此时就会出现一种情况：内部类要访问一个不存在的局部变量.为了避免该问题，我们使用final修饰局部变量，从而变成常量；永驻内存空间,即使方法销毁之后，该局部变量也在内存中，对象可以继续持有。

编译期间，编译器检测到某段代码可能会发生异常，需要开发者提前给代码作出错误解决方案，否则编译不通过

编译通过，运行期间出现的异常

Error

Exception

数组是一种线性表数据结构，它用一组连续的内存空间，来存储一组具有相同类型的数据。

数组的逻辑结构指的是我们可以用什么的表示方式来描述数组元素，数组的物理结构指的是数组元素实际的存储形式

数组的寻址公式

数组下标为何从 0 开始

高效的随机访问

低效插入和删除

链表（Linked list）是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。

数组

链表

执行插入、删除操作效率高，访问任意节点效率低

单链表

循环链表

双向循环链表

栈就是一种操作受限的线性表，只允许在栈的一端进行数据的插入和删除，这两种操作分别叫做入栈和出栈。

1、基于数组的顺序栈的实现

2、支持动态扩容的顺序栈

3、基于链表的链式栈的实现

队列和栈一样都属于一种操作受限的线性表，先进先出

顺序队列

链式队列

1、线性探测

2、二次检测

3、双重散列

链表法对内存的利⽤率⽐开放寻址法要⾼。因为链表结点可以在需要的时候再创建，并不需要像开放寻址法那样事先申请好。链表法⽐起开放寻址法，对⼤装载因⼦的容忍度更⾼。基于链表的散列冲突处理⽅法⽐较适合存储⼤对象、⼤数据量的散列表，⽽且，⽐起开放寻址法，它更加灵活，⽀持更多的优化策略，⽐如⽤红⿊树代替链表。

节点到叶子节点的最长路径(边数)，所有叶子节点的高度为 0

根节点到这个节点所经历的边的个数，根的深度为 0

节点的深度+1

树核心概念释义

每个节点最多有两个“叉”，也就是两个子节点，分别是左子节点和右子节点，二叉树并不要求每个节点都有两个子节点，有的节点只有左子节点，有的节点只有右子节点，

链式存储

顺序存储

满二叉树

完全二叉树

二叉查找树

平衡二叉查找树

堆

存储有序、可重复的数据

 ArrayList

LinkedList

Vector、Stack

但凡是实现了Set接口的类都叫做Set集合， 元素无索引,元素不可重复(唯一)，存储无序且不重复的数据，Set 判断两个对象是否相同不是使用 == 运算符，而是根据 hashcode 和 equals() 方法

无序性

不可重复性

HashSet

LinkedHashSet

TreeSet

基本概念

继承体系

工作流程

扩容与数据迁移

底层原理

HashMap的子类，存储数据采用的 哈希表结构+链表 结构。通过链表结构可以保证键值对的存取顺序一致；
通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、

原理简述

TreeMap集合和Map相比没有特有的功能，底层的数据结构是红黑树；
可以对元素的键进行排序，排序方式有两种:自然排序和比较器排序

1、将 String 类型对象添加到存储 Object 参数类型的对象的集合中

2、读取集合中的数据时，将数据将转为 String

这样做导致在添加元素到集合中的时候，任意类型都可以添加到集合中。当读取数据时需要强转过程繁琐，且强转可能不成功而导致类型转换错误

只有指定类型才可以添加到集合中，保证类型安全，读取时不需要强转且不会出现类型转换错误

Pair<String> stringPair = .....

Pair<Employee> employeePair=......

stringPair.getClass() == employeePair.getClass() 为 true

Pair<String>[] table = new Pair<String>[10]  //ERROR

PS: 声明 Pair<String>[] 类型的变量是合法的，只是不允许创建参数化类型数组

概述

字节输入流

字符输入流

概述

字节输出流

字符输出流

以字节为单位，读写数据的流。

字节输入流

字节输出流

以字符为单位，读写数据的流。

字符输入流

字符输出流

直接与数据源相连（直接和文件打交道），读入或写出

与节点流一块使用，在节点流的基础上，再套接一层，不与文件直接接触

FileInputStream

FileOutputStream

BufferedInputStream

BufferedOutputStream

问：为什么缓冲流效率高？

ObjectInputStream

ObjectOutpuStream

注意事项

FileReader

FileWriter

Java中有两种线程，一种是用户线程，另一种是守护线程。

用户线程是指用户自定义创建的线程，主线程停止，用户线程不会停止。

守护线程当进程不存在或主线程停止，守护线程也会被停止。

所谓的原子性是指在一次操作或者多次操作中，
要么所有的操作全部都得到了执行并且不会受到任何因素的干扰而中断，
要么所有的操作都不执行，多个操作是一个不可以分割的整体。Java内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过synchronized和Lock来实现。

图示

是指多个线程访问一个共享资源时，该资源的状态、值信息的修改对于其他线程不是立即可见的。如果其他线程处于循环中，且循环体代码执行速度非常快，快到工作线程来不及读取主存中的值，那么会造成死循环，如图所示。

图示

指程序中代码的执行顺序 （编译器会重排）

图示

如果它们没有共享，则线程安全

如果它们被共享了

局部变量是线程安全的

但局部变量引用的对象则未必安全

JMM 是抽象模型，一种规范，一种设计，一种思想，JVM 内存区域 就是按照 Java 内存模型 去划分的，其中 栈区和PC 都是属于工作空间内存，

1、主内存

2、工作内存空间

所有的共享变量都存在主内存中，线程在执行的时候，有单独的工作内存，会把共享变量拷贝一份到现成单独的工作内存中，并对变量所有的操作，都是在单独的工作内存中完成的，不会直接读写主内存中的变量值,线程对拷贝到工作内存的共享变量副本进行修改后，在之后的某一刻（什么时间不确定）会将修改后的值同步到主内存中，更新主内存的值。而后，其他线程会在不确定的某一时刻读取主存中的共享变量值

概述

MarkWord

Klass Pointer

实例数据（Instance Data）：主要是存放类的数据信息，父类的信息，对象字段属性信息。

为了字节对齐，填充的数据，不是必须的。

被synchronized修饰的代码块，多了两个指令

被synchronized修饰的方法，多了一个指令

sync 拥有锁重入的功能，即在使用 sync 时，当一个线程得到锁后，再次请求此对象的锁时，即获取对象关联的 monitor 对象，monitor 进入数加 1

问题：正常退出时计数器减1，抛异常时计数器也是减1。那如果两次重入，在内层抛出异常，会释放锁吗？还是只会计数器减1，锁并不会释放？

1、synchronized是靠Monitor关联拿到锁的

2、如果竞争的时候拿不到锁，线程就去竞争队列

3、如果拿到锁了，第二次拿，它又拿到锁,其他线程进入阻塞队列

4、如果拿到锁的线程调用了wait方法，其他线程进入等待队列

5、释放锁，需要将计数器减减操作

6、出现异常，释放锁。锁重入后内层出现异常，也释放锁（Exception table）

引入偏向锁是为了在无多线程竞争的情况下尽量减少不必要的轻量级锁执行路径，因为轻量级锁的获取及释放依赖多次CAS原子指令，而偏向锁只需要在置换ThreadID的时候依赖一次CAS原子指令（由于一旦出现多线程竞争的情况就必须撤销偏向锁，所以偏向锁的撤销操作的性能损耗必须小于节省下来的CAS原子指令的性能消耗）。上面说过，轻量级锁是为了在线程交替执行同步块时提高性能，而偏向锁则是在只有一个线程执行同步块时进一步提高性能。一个对象创建时：
如果开启了偏向锁（默认开启），那么对象创建后，markword 值为 0x05 即最后 3 位为 101，这时它的
thread、epoch、age 都为 0
偏向锁是默认是延迟的，不会在程序启动时立即生效，如果想避免延迟，可以加 VM 参数 -
XX:BiasedLockingStartupDelay=0 来禁用延迟
如果没有开启偏向锁，那么对象创建后，markword 值为 0x01 即最后 3 位为 001，这时它的 hashcode、
age 都为 0，第一次用到 hashcode 时才会赋值

图示

访问Mark Word中偏向锁的标识是否设置成1，锁标志位是否为01——确认为可偏向状态。

如果为可偏向状态，则测试线程ID是否指向当前线程

偏向锁的撤销在上述第四步骤中有提到。偏向锁只有遇到其他线程尝试竞争偏向锁时，持有偏向锁的线程才会释放锁，线程不会主动去释放偏向锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有字节码正在执行），它会首先暂停拥有偏向锁的线程，判断锁对象是否处于被锁定状态，撤销偏向锁后恢复到未锁定（标志位为“01”）或轻量级锁（标志位为“00”）的状态。

如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以
使用轻量级锁来优化。

轻量级锁对使用者是透明的，即语法仍然是 synchronized

案例

在代码进入同步块的时候，如果同步对象锁状态为无锁状态（锁标志位为“01”状态，是否为偏向锁为“0”），虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的Mark Word的拷贝，官方称之为 Displaced Mark Word。

拷贝对象头中的Mark Word复制到锁记录中。拷贝成功后，虚拟机将使用CAS操作尝试将对象的Mark Word更新为指向Lock Record的指针，并将Lock record里的owner指针指向object mark word。

如果这个更新动作成功了，那么这个线程就拥有了该对象的锁，并且对象Mark Word的锁标志位设置为“00”，即表示此对象处于轻量级锁定状态

当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重
入计数减一。如果这个更新操作失败了，虚拟机首先会检查对象的Mark Word是否指向当前线程的栈帧，如果是就说明当前线程已经拥有了这个对象的锁，那就可以直接进入同步块继续执行。否则说明多个线程竞争锁，轻量级锁就要膨胀为重量级锁，锁标志的状态值变为“10”，Mark Word中存储的就是指向重量级锁（互斥量）的指针，后面等待锁的线程也要进入阻塞状态。 而当前线程便尝试使用自旋来获取锁，自旋就是为了不让线程阻塞，而采用循环去获取锁的过程。

解锁

线程如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁，即让 Object 对象的MarkWord 指向Monitor，当前线程阻塞等待。待到持有轻量级锁的线程执行完后解锁，发现 Markword 的指针已经指向 Monitor ，解锁失败，然后执行重量级锁的解锁流程

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞，避免上下文切换消耗性能。当多次自旋仍然无法获得锁时，再进入 Monitor 的 EntryList 阻塞

PS

对共享变量修改其他变量马上能感知，即执行共享变量写操作的时候，发出信号通知其他 CPU 将该变量的 Cache line 置为无效，但最终其他线程能不能从主存中读到更新后的数据还不一定，看读的时机（也就是说不能满足原子性）

禁止指令重排；在编译阶段和指令优化阶段会重排，输入代码的顺序并不是最终执行的顺序，执行时间短的会被放到前面执行，提高CPU的吞吐量。重排序后对单线程没有影响，但是对多线程有影响

Compare and Swap即比较交换，CAS 有三个操作数，内存值V，旧的预期值A，将要修改的值B，当且仅当预期值A 和内存值V相同时（即工作内存中的值和主内存中的值一致），将内存值修改为 B 并返回 true，如果不相同则证明内存值在并发的情况下已经被其他线程修改过了，则不作任何修改，返回 false，循环重复操作

疑问？如果多条线程同时获取到旧值，compare结果为 true

1、工作内存从主内存中获取共享变量的值

2、再拿工作内存中获取到的共享变量的值与当前主内存中的值进行比较

3、如果相同，就做写操作，然后写入主内存；如果不相同，就循环重新获取，判断，做写操作，再写入主内存

cas 工作原理

CAS 源码

线程不安全

线程安全

线程不安全

线程安全

线程不安全

线程安全

能够使一个线程在等待另外一些线程完成各自工作之后，再继续执行。使用一个计数器进行实现。计数器初始值为线程的数量。当每一个线程完成自己任务后，计数器的值就会减一。当计数器的值为0时，表示所有的线程都已经完成一些任务，然后在CountDownLatch上等待的线程就可以恢复执行接下来的任务。

CyclicBarrier的字面意思是可循环使用（Cyclic）的屏障（Barrier）。它要做的事情是，让一组线程到
达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障
拦截的线程才会继续运行。例如：公司召集5名员工开会，等5名员工都到了，会议开始。

是一个计数信号量，必须由获取它的线程释放。常用于限制可以访问某些资源的线程数量，例如通过 Semaphore 限流。                        Semaphore的主要作用是控制线程的并发数量。
synchronized可以起到"锁"的作用，但某个时间段内，只能有一个线程允许执行。
Semaphore可以设置同时允许几个线程执行。
Semaphore字面意思是信号量的意思，它的作用是控制访问特定资源的线程数目。

Exchanger（交换者）是一个用于线程间协作的工具类。Exchanger用于进行线程间的数据交换。
这两个线程通过exchange方法交换数据，如果第一个线程先执行exchange()方法，它会一直等待第二
个线程也执行exchange方法，当两个线程都到达同步点时，这两个线程就可以交换数据，将本线程生
产出来的数据传递给对方。
A线程 exchange方法 把数据传递B线程
B线程 exchange方法 把数据传递A线程

核心线程数，线程池创建好后就初始化的线程数量，等待接收异步任务去执行 相当于 new 了 corePoolSize 个 Thread，只要线程池不销毁，这些线程一直存在，除非设置了 allowCoreThreadTimeOut

最大线程数量，即线程池里允许存放的最大线程数量，控制资源

存活时间，当前正在运行的线程数量大于 corePoolSize，且线程空闲时间大于了指定的 keepAliveTime， 当前正在运行的线程 - corePoolSize 的线程数会被释放掉，核心线程不会释放

时间单位，是 KeepAliveTime 参数的时间单位

阻塞队列，如果任务很多，就会将多的任务放入队列，只要有现成空闲，就会从队列中取出新的任务继续执行

线程的创建工厂

如果队列满了，按照指定的拒绝策略拒绝执行任务

变量的类型为函数式接口类型,那么可以赋值一个Lambda表达式

方法的形参类型为函数式接口类型,那么就可以传入一个Lambda表达式

方法的返回值类型为函数式接口类型,那么就可以返回一个Lambda表
达式

对类型为T的对象应用操作，包含方法： void accept(T t)

返回类型为T的对象，包含方法：T get()

对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(T t)

确定类型为T的对象是否满足某约束，并返回 boolean 值。包含方法：boolean test(T t)

构造方法

成员方法(有参数)

静态方法

静态方法\成员方法(无参数)

一个数据源（如：集合、数组），获取一个流

一个中间操作链，对数据源的数据进行处理

一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

中间操作的返回结果都是Stream，除非流水线上触发终止操作，否则中间操作不会执行任何的处理！而在终止操作时一次性全部处理，称为“惰性求值”

终端操作会从流的流水线生成结果。其结果可以是任何不是流的值，例如： List、 Integer、Double、String等等，甚至是 void 。只能有一个终止操作

筛选与切片

映射

排序

查找与匹配

规约

收集

当程序要使用某各类时，如果该类还未被加载到内存中，则系统会通过类的加载、类的连接、类的初始化这三个步骤来对类进行初始化，如果不出现意外情况，JVM将会连续完成这三个步骤，所以将这三步骤统称为类的初始化

1、加载

2、连接

3、初始化

1、使用 new 关键字实例化对象时

2、读取或设置一个类型的静态字段（被 final 修饰，已在编译期把结果放入常量池的静态字段除外）

3、调用一个类的静态方法

4、使用 java.lang.reflect 包的方法对类型进行反射调用时，如果类型还未初始化，则需要先触发其初始化

5、当初始化类时，如果父类还未初始化，先触发父类初始化

6、当虚拟机启动，用户需要制定一个要执行的主类（ main 方法的类），虚拟机会先初始化这个主类

7、当一个接口定义了 JDK8 新加入的默认方法（被 default 关键字修饰的接口方法）时，如果这个接口实现类发生了初始化，那么接口要在其之前初始化

当一个类加载器负责加载某个 Class 时，该 Class 所依赖的和应用的其他 Class 也将由该类加载器负责载入，除非显示使用另外一个类加载器来载入

当一个类加载器负责加载 Class 时，先让父类加载器尝试加载该 Class，只有父类加载器无法加载该类时才尝试从自己的类路径中加载该类

保证所有加载过的 Class 都会被缓存，当程序需要使用某个 Class 对象时，类加载器先从缓存区中搜索该 Class，只有当缓存区中不存在该 Class 对象时，系统才会读取该类对应的二进制数据，并将其转换成 Class 对象，存储到缓存区

Bootstrap Class loader

Extension Class loader

APP Class loader

类加载方式

Bootstrap Class loader

Platform Class loader

APP Class loader

类加载方式

在对象中添加一个引用计数器，当存在一个引用时，计数器加 1，当引用失效时，计数器就会减 1，当计数器为 0 时，对象就可以进行垃圾回收

通过一系列称为 “GC Roots” 的根对象作为起始节点集，从这些节点开始，根据引用关系向下搜索，搜索过程走过的路径称为引用链，如果某个对象到 GC Roots 间没有任何引用链相连，则证明此对象不可能再被使用

作为 GC Roots 的对象包含下面几种

指代码中普遍存在的引用赋值，只要存在强引用，垃圾回收器永远不会回收被引用的对象

用来描述一些还有用但非必须的对象，被软引用关联的对象，在系统将要发生内存溢出异常前，会把这些对象列进回收范围之中进行二次回收。如果一个对象只具有软引用，若内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存

不管内存是否足够，弱引用的对象都会在下一次垃圾回收时回收该对象

那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。

概述

回收前的状态

回收后的状态

缺点

概述

回收前状态

回收后状态

缺点

概述

图示

缺点

概述

图示

清理过程

内存分配与回收策略

前面我们提到了垃圾收集的算法，但还需要具体的实现，在 JVM 中，实现了多种垃圾收集器，包括：串行垃圾收集器、并行垃圾收集器、CMS 垃圾收集器、G1 垃圾收集器。

图示

JDK1.7

JDK1.8

JDK1.9

Serial 串行收集器

ParNew 并行收集器

Parallel 收集器

Serial Old 收集器

Parallel Old 收集器

CMS 收集器

概述

G1 的内存布局

垃圾收集模式

使用 G1 注意点