Java 要点

线程安全

性能偏低

数组实现

非线程安全

数组实现，两倍扩容

链表实现，近乎无界

非线程安全，

装载因子

并发死锁

jdk7/8 实现差别

数组链表红黑树

排序，二分查找

数组(范围)比较，equals 对比

范围复制，装填，hashCode

交集，切分

不可变集合

安全类型对象(类型不匹配抛出异常)

空集合

同步集合

常用最大最小排序等方法

调用 Class.forName("驱动类")时，调用了内部静态方法，注册到 DriverManager 中

优点：
1. 可以运行时动态生成代理对象
2. 在被代理对象变更时，没有特殊代理变动不需要修改代理类

缺点：
1. 性能有影响
2. 元空间占用
3. JDK 代理时需要抽象出业务接口，然后代理该接口

基于接口和反射实现，必须实现要代理的接口才能代理

Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

private Object target;

ClassLoader cl = target.getClass().getClassLoader();
Class<?>[] il = target.getClass().getInterfaces();

return Proxy.newProxyInstance(cl, il, new InvocationHandler() {
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前拦截...");
        Object result = method.invoke(target, args); // 不能调用 proxy，否则永远调用不到实际代码
        System.out.println("后拦截...");
        return result;
    }
});

可以在没有接口的情况下实现动态代理，也可以代理接口

原理：通过 ASM 继承扩展被代理类，通过方法索引调用被代理对象的方法，通过父类和增强实现，实现类似静态代理

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(Waiter.class);
enhancer.setCallback(new WaiterProxy());
Waiter w = (Waiter) enhancer.create();
w.order("1111");

class WaiterProxy implements MethodInterceptor {
    // 增强对象，代理方法，代理方法参数，方法代理
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("您好！");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("很高兴为您服务。");
        return result;
    }
}

Spring AOP

Hibernate

RPC 调用实现

CPU 调度的基本单元

进程之前有一个线程

没有独立的内存空间，共享所在进程的内存，文件I/O

线程间通讯简单

资源分配的最小单元

独立的内存空间

进程间通讯复杂

唯一存放对象实例的地方（随着优化技术发展，不再绝对）

垃圾回收工作的主要区域

不要求物理连续，但逻辑上连续

所有线程共享区域

垃圾分代收集划分

线程分配

操作数栈

局部变量表

返回地址

动态链接

各个线程共享的内存区域

存储被虚拟机加载的类信息，常量，静态变量，即时编译器编译的代码

包含运行时常量池

不能解决循环引用问题

从 GC Root 开始搜索，当一个对象不与任何引用链相连，表明对象不可达、不可用

GC Root（实例对象）

标记所有需要回收的对象，然后统一回收

缺点：
1. 标记和收集效率都不高
2. 内存碎片

在标记清楚的过程后，将内存统一向一端移动，收集边界外的内存

内存空间对分，每次使用一部分，GC后存活对象复制到另一部分

缺点：
1. 内存浪费太大
2. 存活对象较大时导致大量复制

根据对象存活周期不同将内存划分为多个块，每个块可以根据各自对象的特点适用不同的回收算法

新生代 1/3

老年代 2/3

Minor GC 新生代

Major GC老年代/Full GC 所有区域

串行收集

并行收集

并发收集

新生代

老年代

混合支持

不存在该类的任何实例

加载该类的 ClassLoader 被回收

该类的 Class 对象没有任何引用，不能通过反射访问到该类

当某个年龄的内存总和大于 Survivor 空间的一半，大于或等于该年龄进入老年代

一组符号描述所引用的目标

符号可以是任何字面量，只要可以没有歧义的定位到目标即可

符号引用与虚拟机内存布局无关，引用的目标不一定已经加载到内存了

可以直接指向目标的指针、偏移、句柄

与虚拟机内存布局有关，同一符号引用在不同 jvm 实例中翻译出来的直接引用一般都不会相同

有了直接引用，引用的目标一定存在于内存中了

1. Loading 加载

2. Linking 连接

3. Initialization 初始化

启动类加载器，c++ 实现，虚拟机的一部分

其他所有类型类加载器，java 实现，
继承自抽象类 ClassLoader

要求出了顶级启动类加载器外，其余的类加载器都有自己的父类加载器，通过组合复用父类加载器。
步骤：
1. 收到一个加载类的请求，首先委派给父类加载器去加载
2. 每个类加载器都是如此，最后将会由顶级启动类加载器执行加载
3. 如果父类加载器不能加载成功，子类才尝试自己去加载

类加载器具有一定优先级，保证基础类的统一性，维护了程序的稳定性

破坏双亲委派模型

句柄访问

直接指针

强引用

软引用

弱引用

虚引用

_markWord

_klassWord

数组长度（只有数组对象才有）

内填充和外填充

所有变量存储在主内存

线程间变量的值传递必须通过主内存

线程不能直接读写主内存的变量

每个线程有自己的工作内存

保存当前线程使用到变量的主内存的副本

线程对变量的所有操作（读取，赋值等）都必须在工作内存中进行

不能放弃其他线程的工作内存中的变量

lock 作用主内存，把一个变量表示一个线程独占状态

unlock 作用主内存，取消一个变量的独占状态

read 作用主内存，读取一个变量前往工作内存，供 load 使用

load 作用工作内存，接收 read 的变量保存到工作内存中

use 作用工作内存，传递一个工作内存中的变量给执行引擎使用

assign 作用工作内存，接收执行引擎的值赋值给工作内存中的变量

store 作用工作内存，把工作内存中的一个变量传递到主内存去

write  作用主内存，接收工作内存中传递出来的值保存到主内存中的变量

额外规则

最轻量级的同步机制

两个语义

对交互操作的影响

当一个变量被一个线程修改了值，新值对其他线程是可以立即得知这个修改

多个线程获取的同一变量的值不一致的情况

一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行

本线程观察内部执行是有序的，线程内串行，线程内优化不影响先行发生

一个线程观察其他线程是无序的

volatile、synchronized 保证有序性

1. 程序次序规则 线程内方法执行是顺序的，按照控制流程来说

2. 监视器锁定规则 同一个对象的解锁操作总是发生于后一个上锁操作，时间纬度

3. volatile 变量规则  volatile 变量写操作总是时间上先行发生于该变量的读操作

4. 线程启动规则  线程 start 方法先行发生于线程内动作

5. 线程终止规则 线程所有操作早于线程终止检查

6. 线程中断规则  中断操作先行发生于中断检查

7. 线程终结规则 对象初始化早于对象终结方法 finalize

8. 传递性  A 先于 B, B 先于 C, 那么 A 先于 C

直接由操作系统内核支持的线程叫内核线程

内核完成线程切换，内核通过调度器完成对线程的调度，以及线程到处理器的映射

可以看做内核的一个分身，支持多线程的内核叫多线程内核

内核线程的高级接口，就是通常意义上的线程

每个轻量级进程都由一个内核线程支持，1:1 对应，是一对一线程模型

优点：由于每个LWP由内核线程支持，是一个独立的调用单元，阻塞也不影响进程的执行 

缺点：
1. 基于内核，创建销毁操作需要进行代价较高的系统操作，用户态和内核态切换
2. 需要占用内核资源(如内核栈空间)，支持数量有限

定义

用户线程的创建同步销毁调度都在用户态完成，不需要内核的参与。因此操作快速且消耗低

进程与用户线程的对比关系为 1：N 线程模型

优点：不需要内核参与，速度和消耗很好

缺点：实现复杂，有些问题困难甚至无法解决(线程管理和调度，以及映射到CPU)

基于高级接口 LWP实现， 一对一的线程模型

基于用户线程实现，实现困难，越来越少使用用户线程实现了。一对多的线程模型

即存在内核线程，也存在LWP

用户线程还是创建在用户空间，创建销毁切换依旧廉价，支持大规模用户线程并发

LWP 作为内核线程和用户线程之间的桥梁，使用内核提供的调度器功能和CPU 映射功能

用户线程需要通过 LWP 完成系统调用，降低进程被阻塞的风险

用户线程和 LWP 比例不定，M:N 的关系，是多对多的线程模型

Linux/Windows 下是 一对一的线程模型，一条Java线程映射到一个 LWP

Solaris 系统支持多对多模型，所以 Java 在 Solaris 上同时支持一对一和多对多的线程模型

协同式

抢占式

优先级并不靠谱

Java 有 10个优先级，Windows 7个，Solaris 有 2^31 存在 多对一的情况

系统能够调整优先级，此外工具也能够修改优先级

New 新建 刚创建的、未启动的线程

Runnable 就绪态，获取了除 CPU 外的所有资源

Running 执行态，就绪态的线程获取 CPU 时间片后切换至执行状态。时间片耗完，切换回就绪态等待下一时间片的分配

Blocked 阻塞态，执行状的线程发生了某种暂停执行的事件，放弃CPU的执行时间，进入阻塞状态。比如竞争临界资源，等待IO等事件。
位于阻塞状态的进程，获取到等待资源后，将进入就绪状态等待CPU分配时间片。

Terminated 结束，完成执行逻辑后

New 创建后未启动

Runnable 运行，对应操作系统的 Ready 和 Running 两种状态

Waiting 等待中，不会获取 CPU 时间片，等待被其他线程显式唤醒

TimedWaiting 期限等待，不会获取 CPU 时间片，显示唤醒或者超时自动唤醒

Blocked 阻塞，等待获取排他锁，等待进入同步区块时就是处于阻塞状态

Terminated 结束，已终止的线程状态，线程已结束执行了

1. 不可变对象，线程安全的，如 基础数据类型和 String 对象

2. 绝对线程安全，如 Vector，多个安全方法一起使用并不安全，所以绝对不绝对

3. 相对线程安全，就是常说的线程安全。这类对象单独操作是安全的，连续操作需要额外的同步手段来保证正确性
如：Vector， Hashtable，Collections.synchronizedCollection 等

4. 线程兼容。本上不是线程安全，通过调用端同步保证同步保证并发情况下安全使用
非线程安全的类通常说的是这一类情况

5. 线程对立。不能再多线程环境下使用，如线程的 suspend/resume 方法

1. 互斥同步(阻塞同步)

2. 非阻塞同步

3. 无同步方案

自旋锁

锁消除

锁粗化

轻量级锁（通过对象头实现）
无竞争情况下CAS替代互斥量

偏向锁（通过对象头实现）
无竞争情况下消除同步(和CAS)

词法分析，将字符流转换为 token 集合

语法分析，将 token 序列转换成 AST 语法树

填充符号表，符号表是地址分配的依据

读取/添加/修改 抽象语法树中的任意元素

语义分析，对结构正确的源程序进行上下文有关性质的审查，如：
int a = 1; boolean b = false, char c = 2;
对于 int d = b + c 这种错误是通过语义分析来保证的

1. 标注检查

2. 数据和控制流分析
局部变量是否赋值，每条路径都有返回值等等

3. 解语法糖 拆解

4. 字节码生成

泛型

装箱拆箱

增强 for 循环

可变参数

* 多次被调用的方法

* 多次被执行的循环体

编译的是方法体，发生在方法执行过程中，也称为栈上替换

基于采样的热点探测，周期性检查栈顶方法

基于计数的热点探测，hotspot 采用的是这一种，两个计数器

数组边界检查消除

方法内联

逃逸分析

* invokestatic 调用静态方法

* invokespecial 实例 <init> 方法、私有方法、父类方法

* invokevirtual 所有虚方法

* invokeinterface 接口方法，运行时再确定一个实现该接口的对象

invokestatic/invokespecital 能调用的方法（也叫非虚方法），都可以再解析阶段唯一确定调用版本

其他方法（除去 final 方法，final 方法是非虚方法），称为虚方法。final 方法用 invokevirtual 调用，但是 final 方法不会被覆盖，版本唯一

变量类型

单分派/多分派

静态分派（多分派）

动态分派（单分派）

虚拟机实现动态分派

Eden/Survivor

老年代

方法区

堆内存

垃圾回收器选择

停顿时间

吞吐率