Java 高频面试题，涵盖基础类型、三大特性、重载重写、修饰符、equals/hashcode、String 机制、反射、拷贝、并发编程、线程池、JVM 内存模型、垃圾回收及锁机制等核心知识点。内容包含代码示例与原理分析，适合求职者复习参考。
数字型： 字节类型 (byte)、短整型 (short)、整型 (int)、长整型 (long)、单精度浮点数 (float)、双精度浮点数 (double) 字符类型 (char) 布尔类型 (boolean)
封装： 使用 private 关键字，让对象私有，防止无关的程序去使用。
继承： 继承某个类，使子类可以使用父类的属性和方法。
多态： 同一个行为，不同的子类具有不同的表现形式。
重载： 发生在同一类中，函数名必须一样，参数类型、参数个数、参数顺序、返回值、修饰符可以不一样。
重写： 发生在父子类中，函数名、参数、返回值必须一样，访问修饰符必须大于等于父类，异常要小于等于父类，父类方法是 private 不能重写。
public： 同一个类、同一个包、不同包的子类、不同包的非子类都可以访问。
protected： 同一个类、同一个包、不同包的子类可以使用，不同包的非子类不能。
(default) 不写： 同一个类、同一个包可以使用，不同包的子类、不同包的非子类不能。
private： 只有同一个类可以。
==： 基础类型比较的值，引用类型比较的是地址值。
equals： 没有重写比较地址值是否相等，重写比较的内容是否相对。比如 String 类重写 equals，源码首先比较是否都是 String 对象，然后再向下比较。
不一定，因为 "重地" 和 "通话" 的 hashcode 值就相同，但是 equals() 就为 false。
但是 equals() 为 true，那么 hashcode 一定相同。
保证同一对象，如果不重写 hashcode，可能会出现 equals 比较一样，但是 hashcode 不一样的情况。
程序 1 会编译报错，因为 s + 1 的 1 是 int 类型，因为类型不兼容。强制转换失败。
程序 2 可以正常运行，因为 java 在复合赋值解释是 E1 += E2,等价于 E1 = (T)(E1 + E2),T 是 E1 的类型，因此 s += 1 等价于 s = (short)(s + 1)，所以进行了强制类型的转换，所以可以正常编译。
public static void main(String[] args) {
Integer a = 128, b = 128, c = 127, d = 127;
System.out.println(a == b);
System.out.println(c == d);
}
结果：false，true
Integer = a，相当于自动装箱 (基础类型转为包装类)，因为 Integer 引入了 IntegerCache 来缓存一定的值，IntegerCache 默认是 -128~127，所以 128 超过了范围，a 和 b 不是相同对象，c 和 d 是相同对象。
可以通过 jvm 启动时，修改缓存的上限。
&&： 如果一边为假，就不比较另一边。又叫短路运算符。
&: 不论一边是真是假，都会比较另一边。如果表达式两边不是 Boolean 类型时候，表示按位运算。
String： 适用于少量字符串。创建之后不可更改，对 String 的修改会生成新的 String 对象。
StringBuilder： 适用于大量字符串，线程不安全，性能更快。单线程使用
StringBuffer： 适用于大量字符串，线程安全。多线程使用，用 synchronized 关键字修饰。
一个或两个，如果常量池存在，那就在堆创建一个实例对象，否则常量池也需要创建一个。
在运行过程中，对于任何一个类都能获取它的属性和方法，任何一个对象都能调用其方法，动态获取信息和动态调用，就是反射。
浅拷贝： 基础数据类型复制值，引用类型复制引用地址，修改一个对象的值，另一个对象也随之改变。
深拷贝： 基础数据类型复制值，引用类型在新的内存空间复制值，新老对象不共享内存，修改一个值，不影响另一个。
深拷贝相对浅拷贝速度慢，开销大。
不能，可以被重载。
并发： 宏观上看是一个处理器"同时"处理多个任务（实际上多个任务轮流使用时间片）。微观上是同一时间只有一个任务在执行。(一个人同时吃两个苹果)
并行： 多个处理器同时处理多个任务。(两个人同时吃两个苹果)
类变量是被 static 所修饰的，没有被 static 修饰的叫实例变量也叫成员变量。同理也存在类对象和实例对象，类方法和实例方法。
//类变量
public static String classVar = "testValue";
//实例变量 (成员变量)
public String instanceVar = "testValue2";
public class InitialTest {
public static void main(String[] args) {
A ab = new B();
ab = new B();
}
}
class A {
static {
// 父类静态代码块
System.out.print("A");
}
public A() {
// 父类构造器
System.out.print("a");
}
}
class B extends A {
static {
// 子类静态代码块
System.out.print("B");
}
public B() {
// 子类构造器
System.out.print("b");
}
}
结果：ABabab
原因：
①执行顺序是 父类静态代码块 (父类静态变量) -> 子类静态代码块 (子类静态变量) -> 父类非静态代码块 -> 父类构造方法 -> 子类非静态代码块 -> 子类构造方法
②静态代码块 (静态变量) 只执行一次。
抽象类只能单继承，接口可以实现多个。
抽象类有构造方法，接口没有构造方法。
抽象类可以有实例变量，接口中没有实例变量，有常量。
抽象类可以包含非抽象方法，接口在 java7 之前所有方法都是抽象的，java8 之后可以包含非抽象方法。
抽象类中方法可以是任意修饰符，接口中 java8 之前都是 public，java9 支持 private。
扩展：普通类是亲爹，手把手教你怎么学，抽象类 (多个类具有相同的东西，拿出来放抽象类) 是师傅，教你一部分秘籍，然后告诉你怎么学。接口 (规范了某些行为) 是干爹，只给你秘籍，怎么学全靠你。
Error： 程序无法处理，比较严重的问题，程序会立即崩溃，jvm 停止运行。
Exception： 程序本身可以处理 (向上抛出或者捕获)。编译时异常和运行时异常
NoClassDefFoundError： 在打包时漏掉了某些类或者打包时存在，然后你把 target 里的类删除，然后 jvm 运行时找不到报错。
ClassNotFoundException： 在编译的时候某些类找不到，然后报错。
会执行，在 return 之前执行，如果 finally 有 return 那么 try 的 return 就会失效。
public class TryDemo {
public static void main(String[] args) {
System.out.println(test1());
}
public static int test1() {
int i = 0;
try {
i = 2;
return i;
} finally {
i = 3;
}
}
}
结果 2
因为在 return 前，jvm 会把 2 暂存起来，所以当 i 改变了，回到 try 时，还是会返回暂存的值。
修饰类： 不能被继承。
修饰方法： 不能被重写。
修饰变量： 声明时给定初始值，只能读取不能修改。如果是对象引用不能改，但是对象的属性可以修改。
①lambda 表达式
②方法引用
③加入了 base64 的编码器和解码器
④函数式接口
⑤接口允许定义非抽象方法，使用 default 关键字即可
⑥时间日期类改进
重定向发送两次请求，转发发送一次请求
重定向地址栏会变化，转发地址栏不会变化
重定向是浏览器跳转，转发是服务器跳转
重定向可以跳转任意网址，转发只能跳转当前项目
重定向会有数据丢失，转发不会数据丢失
get 相对不安全，数据放在 url 中 (请求行)，post 放在 body 中 (请求体)，相对安全。
get 传送的数据量小，post 传送的数据量大。
get 效率比 post 高，是 form 的默认提交方法。
存储 位置不同：cookie 放在客户端电脑，session 放在服务器端内存的一个对象
存储容量不同：cookie <=4KB，一个站点最多保存 20 个 cookie，session 是没有上限的，但是性能考虑不要放太多，而且要设置 session 删除机制
存储数据类型不同：cookie 只能存储 ASCll 字符串，session 可以存储任何类型的数据
隐私策略不同：cookie 放在本地，别人可以解析，进行 cookie 欺骗，session 放在服务器，不存在敏感信息泄露
有效期不同：可以设置 cookie 的过期时间，session 依赖于 jsessionID 的 cookie，默认时间为 -1，只需要关闭窗口就会失效
数组、链表、哈希表、栈、堆、队列、树、图
跨域指的是浏览器不能执行其他网站的脚本。它是由浏览器的同源策略造成的，是浏览器施加的安全限制
协议、域名、端口
注意：localhost 和 127.0.0.1 虽然都指向本机，但也属于跨域
8005：这个端口负责监听关闭 tomcat 的请求。
8009：接受其他服务器的请求
8080：用于监听浏览器发送的请求
throw：抛出一个异常。
throws：声明一个异常。
单例模式： 保证被创建一次，节省系统开销。
工厂模式： 解耦代码。
观察者模式： 定义了对象之间的一对多的依赖，这样一来，当一个对象改变时，它的所有的依赖者都会收到通知并自动更新。
代理模式： 代理对象具备被代理对象的功能，并代替被代理对象完成相应操作，并能够在操作执行的前后，对操作进行增强处理。
模板模式： 较少代码冗余。例如：redis 模板。
① new
② clone()
③ 反射
④先序列化在反序列化
抽象类： abstract 关键字修饰的类。
序列化： 把对象转为字节序列的过程，在传递和保存对象时，保证了对象的完整性和可传递性，便于在网络传输和保存在本地文件中。
反序列化： 把字节序列转为对象的过程，通过字节流的状态和信息描述，来重建对象。
将对象转为字节流存储到硬盘上，当 JVM 崩溃的话，字节流还会在硬盘上等待，等待下一次 JVM 的启动，把序列化的对象，通过反序列化为原来的对象，减少储存空间和方便网络传输 (因为是二进制)。
单点登录 (SSO：Single Sign On)： 同一账号在多系统中，只登录一次，就可以访问其他系统。多个系统，统一登录。
列如：在一个公司下，有多个系统，比如淘宝和天猫，你登录上淘宝，就不用再去登录天猫了。
① Cookie： 用 cookie 为媒介，存放用户凭证。登录上父应用，返回一个加密的 cookie，访问子应用的时候，会对 cookie 解密校验，通过就可以登录。不安全和不能跨域免登。
② 分布式 session 实现： 用户第一次登录，会把用户信息记录下来，写入 session，再次登录查看 session 是否含有对应信息。session 系统不共享，使用缓存等方式来解决。
③重定向： 父应用提供一个 GET 方式的登录接口 A，用户通过子应用重定向连接的方式访问这个接口，如果用户还没有登录，则返回一个登录页面，用户输入账号密码进行登录，如果用户已经登录了，则生成加密的 token，并且重定向到子应用提供的验证 token 的接口 B，通过解密和校验之后，子应用登录当前用户，虽然解决了安全和跨域，但是没前两种简单。
单点登录： 就是一个公司多个子系统登录问题。
OAuth2.0： 是授权问题，比如微信授权问题。是一种具体的协议。
①js 屏蔽提交按钮。
②给数据库添加唯一约束。
③利用 Session 防止表单重复提交。会有一个 token 标记，表单提交的时候拦截器会检查是否一致，不一致就不通过。
④使用 AOP 切入实现。自定义注解，然后新增切入点，然后每次都记录过期时间，然后做比较。
本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
好处：
①类型安全
②消除强制类型转换
③提高性能
④提高代码的复用性
值传递： 函数调用时会把实际参数，复制一份到函数中，函数中对参数进行操作，并不会影响参数实际的值。
引用传递： 将实际参数的地址值传递到函数中，函数对参数进行操作，会影响到实际参数的值。
注意： java 中不存在引用传递 (即使传的是对象，那也只是传递了对象的引用地址的副本，也属于值传递)。
List 集合有序、可重复的单例集合。
Set 集合无序、不可重复的单例集合。
Map 集合无序、k 不可重复，v 可重复的双例集合。
List
vector：底层是数组，方法加了 synchronized 来保证线程安全，所以效率较慢，使用 ArrayList 替代。
ArrayList： 线程不安全，底层是数组，因为数组都是连续的地址，所以查询比较快。增删比较慢，增会生成一个新数组，把新增的元素和原有元素放到新数组中，删除会导致元素移动，所以增删速度较慢。
LinkedList： 线程不安全，底层是链表，因为地址不是连续的，都是一个节点和一个节点相连，每次查询都得重头开始查询，所以查询慢，增删只是断裂某个节点对整体影响不大，所以增删速度较快。
Set
HashSet：底层是哈希表 (数组 + 链表或数组 + 红黑树)，在链表长度大于 8 时转为红黑树，在红黑树节点小于 6 时转为链表。其实就是实现了 HashMap，值存入 key，value 是一个 final 修饰的对象。
TreeSet：底层是红黑树结构，就是 TreeMap 实现，可以实现有序的集合。String 和 Integer 可以根据值进行排序。如果是对象需要实现 Comparator 接口，重写 compareTo() 方法制定比较规则。
LinkedHashSet：实现了 HashSet，多一条链表来记录位置，所以是有序的。
Map<key,value>双例结构
TreeMap：底层是红黑树，key 可以按顺序排列。
HashMap：底层是哈希表，可以很快的储存和检索，无序，大量迭代情况不佳。
LinkedHashMap：底层是哈希表 + 链表，有序，大量迭代情况佳。
初始容量： 默认 10，也可以通过构造方法传入大小。
扩容机制： 原数组长度 + 原数组长度/2(源码中是原数组右移一位，也就相当于除以 2)
注意：扩容后的 ArrayList 底层数组不是原来的数组。
扩容过程： 因为 ArrayList 底层是数组，所以它的扩容机制和数组一样，首先新建一个新数组，长度是原数组的 1.5 倍，然后调用 Arrays.copyof() 复制原数组的值，然后赋值给新数组。
根据关键码值 (Key value) 而直接进行访问的数据结构，在一个表中，通过 H(key) 计算出 key 在表中的位置，H(key) 就是哈希函数，表就是哈希表。
不同的 key 通过哈希函数计算出相同的储存地址，这就是哈希冲突。
(1) 开放地址法
如果发生哈希冲突，就会以当前地址为基准，再去寻找计算另一个位置，直到不发生哈希冲突。
寻找的方法有：① 线性探测 1，2，3，m
② 二次探测 1 的平方，-1 的平方，2 的平方，-2 的平方，k 的平方，-k 的平方，k<=m/2
③ 随机探测 生成一个随机数，然后从随机地址 + 随机数++。
(2) 链地址法
冲突的哈希值，连到到同一个链表上。
(3) 再哈希法 (再散列方法)
多个哈希函数，发生冲突，就在用另一个算计，直到没有冲突。
(4) 建立公共溢出区
哈希表分成基本表和溢出表，与基本表发生冲突的都填入溢出表。
得到哈希值然后右移 16 位，然后进行异或运算，这样使哈希值的低 16 位也具有了一部分高 16 位的特性，增加更多的变化性，减少了哈希冲突。
因为计算元素存储的下标是 (n-1)&哈希值，数组初始容量 -1，得到的二进制都是 1，这样可以减少哈希冲突，可以更好的均匀插入。
会获得一个大于指定的初始值的最接近 2 的次幂的值作为初始容量。
jdk1.7 中因为使用头插法，再扩容的时候，可能会造成闭环和数据丢失。
jdk1.8 中使用尾插法，不会出现闭环和数据丢失，但是在多线程下，会发生数据覆盖。(put 操作中，在 putVal 函数里) 值的覆盖还有长度的覆盖。
(1) 使用 Hashtable 解决，在方法加同步关键字，所以效率低下，已经被弃用。
(2) 使用 Collections.synchronizedMap(new HashMap<>()),不常用。
(3) ConcurrentHashMap(常用)
jdk1.7： 采用分段锁，是由 Segment(继承 ReentrantLock：可重入锁，默认是 16，并发度是 16) 和 HashEntry 内部类组成，每一个 Segment(锁) 对应 1 个 HashEntry(key，value) 数组，数组之间互不影响，实现了并发访问。
jdk1.8： 抛弃分段锁，采用 CAS(乐观锁)+synchronized 实现更加细粒度的锁，Node 数组 + 链表 + 红黑树结构。只要锁住链表的头节点 (树的根节点)，就不会影响其他数组的读写，提高了并发度。
①节省内存开销。ReentrantLock 基于 AQS 来获得同步支持，但不是每个节点都需要同步支持，只有链表头节点或树的根节点需要同步，所以使用 ReentrantLock 会带来很大的内存开销。
②获得 jvm 支持，可重入锁只是 api 级别，而 synchronized 是 jvm 直接支持的，能够在 jvm 运行时做出相应的优化。
③在 jdk1.6 之后，对 synchronized 做了大量的优化，而且有多种锁状态，会从 无锁 -> 偏向锁 -> 轻量级锁 -> 重量级锁一步步转换。
AQS (Abstract Queued Synchronizer)： 一个抽象的队列同步器，通过维护一个共享资源状态（ Volatile Int State ）和一个先进先出（ FIFO ）的线程等待队列来实现一个多线程访问共享资源的同步框架。
减少和解决哈希冲突，把冲突的值放在同一链表下。
当数据过多，链表遍历较慢，所以引入红黑树。
维护成本较大，红黑树在插入新的数据后，可能会进行变色、左旋、右旋来保持平衡，所以当数据少时，就不需要红黑树。
①根节点是黑色。
②节点是黑色或红色。
③叶子节点是黑色。
④红色节点的子节点都是黑色。
⑤从任意节点到其子节点的所有路径都包含相同数目的黑色节点。
红黑树从根到叶子节点的最长路径不会超过最短路径的 2 倍。保证了红黑树的高效。
因为链表长度越长，哈希冲突概率就越小，当链表等于 8 时，哈希冲突就非常低了，是千万分之一，我们的 map 也不会存那么多数据，如果真要存那么多数据，那就转为红黑树，提高查询和插入的效率。
因为如果都是 8 的话，那么会频繁转换，会浪费资源。
加载因子越大，填满的元素越多，空间利用率越高，但发生冲突的机会变大了；
加载因子越小，填满的元素越少，冲突发生的机会减小，但空间浪费了更多了，而且还会提高扩容 rehash 操作的次数。
'冲突的机会'与'空间利用率'之间，寻找一种平衡与折中。
又因为根据泊松分布，当负载因子是 0.75 时，平均值时 0.5，带入可得，当链表为 8 时，哈希冲突发生概率就很低了。
元素个数 > 数组长度 * 负载因子 例如 16 * 0.75 = 12，当元素超过 12 个时就会扩容。
链表长度大于 8 并且表长小于 64，也会扩容
因为元素越多，空间利用率是高了，但是发生哈希冲突的几率也增加了。
jdk1.7： 会生成一个新 table，重新计算每个节点放进新 table，因为是头插法，在线程不安全的时候，可能会出现闭环和数据丢失。
jdk1.8： 会生成一个新 table，新位置只需要看 (e.hash & oldCap) 结果是 0 还是 1,0 就放在旧下标，1 就是旧下标 + 旧数组长度。避免了对每个节点进行 hash 计算，大大提高了效率。e.hash 是数组的 hash 值，，oldCap 是旧数组的长度。
①HashMap，运行 key 和 value 为 null，Hashtable 不允许为 null。
②HashMap 线程不安全，Hashtable 线程安全。
更加安全，因为它可以确保，在当前遍历的集合元素被更改的时候，就会抛出 ConcurrentModificationException 异常。
如果不用迭代器，只能 for 循环，还必须知道集合的数据结构，复用性不强。
线程： 是最小的调度单位，包含在进程中。
多线程： 多个线程并发执行的技术。
守护线程： jvm 给的线程。比如：GC 守护线程。
用户线程： 用户自己定义的线程。比如：main() 线程。
拓展：
Thread.setDaemon(false) 设置为用户线程
Thread.setDaemon(true) 设置为守护线程
新建 (New): 新建一个线程。
就绪 (Runnable): 抢夺 cpu 的使用权。
运行 (Running): 开始执行任务。
阻塞 (Blocked)： 让线程等待，等待结束进入就绪队列。
死亡 (Dead)： 线程正常结束或异常结束。
wait()： 线程等待，会释放锁，用于同步代码块或同步方法中，进入等待状态
sleep()： 线程睡眠，不会释放锁，进入超时等待状态
yield()： 线程让步，会使线程让出 cpu 使用权，进入就绪状态
join()： 指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。
notify()： 随机唤醒一个在等待中的线程，进入就绪状态。
notifyAll()： 唤醒全部在等待中的线程，进入就绪状态。
① wait() 来自 Object，sleep() 来自 Thread。
② wait() 会释放锁，sleep() 不会释放锁。
③ wait() 只能用在同步方法或代码块中，sleep() 可以用在任何地方。
④ wait() 不需要捕获异常，sleep() 需要捕获异常。
① 锁可以是任何对象，如果在 Thread 类中，那只能是 Thread 类的对象才能调用上面的方法了。
② java 中进入临界区 (同步代码块或同步方法)，线程只需要拿到锁就行，而并不关心锁被那个线程持有。
③ 上面方法是 java 两个线程之间的通信机制，如果不能通过类似 synchronized 这样的 Java 关键字来实现这种机制，那么 Object 类中就是定义它们最好的地方，以此来使任何 Java 对象都可以拥有实现线程通信机制的能力。
start() 方法： 是启动线程，调用了之后线程会进入就绪状态，一旦拿到 cpu 使用权就开始执行 run() 方法，不能重复调用 start()，否则会报异常。
run() 方法： 就相当于一个普通的方法而已。直接调用 run() 方法就还只有一个主线程，还是会顺序执行，也可以重复调用 run() 方法。
①继承 Thread 类。
②实现 Runnable 接口
③实现 Callable 接口
④线程池
①Runnable 没有返回值，Callable 有返回值。
②Runnable 只能抛出异常，不能捕获，Callable 能抛出异常，也能捕获。
① 线程是稀缺资源，使用线程池可以减少线程的创建和销毁，每个线程都可重复使用。
② 可以根据系统的需求，调整线程池里面线程的个数，防止了因为消耗内存过多导致服务器崩溃。
corePoolSize： 核心线程数，创建不能被回收，可以设置被回收。
maximumPoolSize： 最大线程数。
keepAliveTime： 空闲线程存活时间。
unit： 单位。
workQueue： 等待队列。
threadFactory： 线程工程，用于创建线程。
handler： 拒绝策略。
①接到任务，判断核心线程池是否满了，没满执行任务，满了放入等待队列。
②等待队列没满，存入队列，等待执行，满了去查看最大线程数。
③最大线程数没满，执行任务，满了执行拒绝策略。
①ExecutorService executor = Executors.newCachedThreadPool()： 创建一个缓存线程池，灵活回收线程，任务过多，会 oom。
②ExecutorService executor = Executors.newFixedThreadPool()： 创建一个指定线程数量的线程池。提高了线程池的效率和线程的创建的开销，等待队列可能堆积大量请求，导致 oom。
③ExecutorService executor = Executors.newSingleThreadPool()： 创建一个单线程，保证线程的有序，出现异常再次创建，速度没那么快。
④ExecutorService executor = Executors.newScheduleThreadPool()： 创建一个定长的线程池，支持定时及周期性任务执行。
①new ThreadPoolExecutor.AbortPolicy()： 添加线程池被拒绝，会抛出异常 (默认策略)。
②new ThreadPoolExecutor.CallerRunsPolicy()： 添加线程池被拒绝，不会放弃任务，也不会抛出异常，会让调用者线程去执行这个任务 (就是不会使用线程池里的线程去执行任务，会让调用线程池的线程去执行)。
③new ThreadPoolExecutor.DiscardPolicy()： 添加线程池被拒绝，丢掉任务，不抛异常。
④new ThreadPoolExecutor.DiscardOldestPolicy()： 添加线程池被拒绝，会把线程池队列中等待最久的任务放弃，把拒绝任务放进去。
① shutdown 没有返回值，shutdownNow 会返回没有执行完任务的集合。
②shutdown 不会抛出异常，shutdownNow 会抛出异常。
③shutdown 会等待执行完线程池的任务在关闭，shutdownNow 会给所以线程发送中断信号，然后中断任务，关闭线程池。
各进程互相等待对方手里的资源，导致各进程都阻塞，无法向前推进的现象。
互斥： 当资源被一个线程占用时，别的线程不能使用。
不可抢占： 进程阻塞时，对占用的资源不释放。
不剥夺： 进程获得资源未使用完，不能被强行剥夺。
循环等待： 若干进程之间形成头尾相连的循环等待资源关系。
原子性： 一个或多个操作，要么全部执行，要么全部不执行 (执行的过程中是不会被任何因素打断的)。
可见性： 一个线程对主内存的修改可以及时的被其他线程观察到。
有序性： 程序执行的顺序按照代码的先后顺序执行。
保证原子性
使用锁 synchronized 和 lock。
使用 CAS (compareAndSet：比较并交换），CAS 是 cpu 的并发原语)。
保证可见性
使用锁 synchronized 和 lock。
使用 volatile 关键字 。
保证有序性
使用 volatile 关键字
使用 synchronized 关键字。
① volatile 仅能使用在变量级别的，synchronized 可以使用在变量、方法、类级别的
② volatile 不具备原子性，具备可见性，synchronized 有原子性和可见性。
③ volatile 不会造成线程阻塞，synchronized 会造成线程阻塞。
④ volatile 关键字是线程同步的轻量级实现，所以 volatile 性能肯定比 synchronized 要好。
① synchronized 是关键字，lock 是 java 类，默认是不公平锁（源码）。
② synchronized 适合少量同步代码，lock 适合大量同步代码。
③ synchronized 会自动释放锁，lock 必须放在 finally 中手工 unlock 释放锁，不然容易死锁。
java 内存模型，一个抽象的概念，不是真是存在，描述的是一种规则或规范，和多线程相关的规则。需要每个 JVM 都遵循。
①线程解锁前，必须把共享变量立即刷回主存。
②线程加锁前，必须读取主存中的最新值到工作内存中。
③加锁和解锁必须是同一把锁。
为了支持 JMM，定义了 8 条原子操作，用于主存和工作内存的交互。
lock（锁定）： 作用于主内存的变量，把一个变量标识为一条线程独占状态。
unlock（解锁）： 作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
read（读取）： 作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的 load 动作使用。
load（载入）： 作用于工作内存的变量，它把 read 操作从主内存中得到的变量值放入工作内存的变量副本中。
use（使用）： 作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎。
assign（赋值）： 作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量。
store（存储）： 作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以遍随后的 write 的操作。
write（写入）： 作用于主内存的变量，它把 store 操作从工作内存中的一个变量的值传送到主内存的变量中。
解决由于多线程通过共享内存进行通信时，存在的本地内存数据不一致、编译器会对代码指令重排序、处理器会对代码乱序执行等带来的问题。
java 虚拟机，是实现 java 跨平台的核心组件。
java 中所有的类，必须被装载到 jvm 中才能使用，装载由类加载器完成，.class 这个类型可以在虚拟机运行，但不是直接和操作系统交互，需要 jvm 解释给操作系统，解释的时候需要 java 类库，这样就能和操作系统交互。
.java -> .class -> 类加载器 -> jvm
jdk： 包含 java 运行环境和开发环境、jvm、java 类库。
jre： 包含 java 运行环境和 jvm、java 类库。
jvm： java 虚拟机，是跨平台的核心组件。
将.class 文件装载到 jvm 中，实质就是把文件从硬盘写到内存。
引导类加载器 (Bootstrap ClassLoader)： c++编写，jvm 自带的加载器，负责加载 java 核心类库，该加载器无法直接获取。
拓展类加载器 (Extension ClassLoader)： 加载 jre/lib/etc 目录下的 jar 包。
系统类加载器 (Application ClassLoader)： 加载当前项目目录下的类或 jar 包，最常用的加载器。
自定义加载器 (Custom ClassLoader)： 开发人员自定义的。需要继承 ClassLoader
①接到类加载的请求。
②向上委托给父类加载器，直到引导类加载器。
③引导类加载器检查能否加载当前这个类，如果能，使用当前加载器，请求结束，如果不能，抛出异常，通知子加载器进行加载。
④重复③。
优点：保证类加载的安全性，不管那个类被加载，都会被委托给引导类加载器，只有类加载器不能加载，才会让子加载器加载，这样保证最后得到的对象都是同样的一个。
缺点：子加载器可以使用父加载器加载的类，而父加载器不能使用子加载器加载的类。
子加载器可以使用父加载器加载的类，而父加载器不能使用子加载器加载的类。
例如：使用 JDBC 连接数据库，需要用到 com.mysql.jdbc.Driver 和 DriverManager 类。然而 DriverManager 被引导类加载器所加载，而 com.mysql.jdbc.Driver 被当前调用者的加载器加载，使用引导类加载器加载不到，所以要打破双亲委派机制。
① 自定义类加载器，重写 loadclass 方法。
② 使用线程上下文类 (ServiceLoader：使父加载器可以加载子加载器的类)。
方法区 (线程共享)： 常量池、静态 (static) 变量以及方法信息 (方法名、返回值、参数、修饰符等) 等。
堆 (线程共享)： 是虚拟机内存中最大的一块，储存的是实例对象和数组。
本地方法栈 (线程不共享)： 调用的本地方法，被 native 修饰的方法，java 不能直接操作操作系统，所以需要 native 修饰的方法帮助。
虚拟机栈 (线程不共享)： 8 大基本类型、对象引用、实例方法。
程序计数器 (线程不共享)： 每个线程启动是都会创建一个程序计数器，保存的是正在执行的 jvm 指令，程序计数器总是指向下一条将被执行指令的地址。
内存溢出的原因： (1) 内存使用过多或者无法垃圾回收的内存过多，使运行需要的内存大于提供的内存。
(2) 长期持有某些资源并且不释放，从而使资源不能及时释放，也称为内存泄漏。
解决： (1) 进行 jvm 调优。-Xmx：jvm 最大内存。-Xms:启动初始内存。-Xmn：新生代大小。 -Xss:每个虚拟机栈的大小。
(2) 使用专业工具测试。
手动制造： 一直 new 对象就 ok。
栈溢出原有： 线程请求的栈容量大于分配的栈容量。
解决： (1) 修改代码 (2) 调优 -Xss
手动制造： 一直调用实例方法。
作用在方法区和堆，主要实在堆中的伊甸园区。年轻代分为 (伊甸园区和幸存区)
可达性分析算法： 简单来说就是一个根对象通过引用链向下走，能走到的对象都是不可回收的。可作为根对象有： 虚拟机栈的引用的对象，本地栈的引用的对象，方法区引用的静态和常量对象。
引用计数算法： 每个对象都添加一个计数器，每多一个引用指向对象，计数器就加一，如果计数器为零，那么就是可回收的。
强引用： 基于可达性分析算法，只有当对象不可达才能被回收，否则就算 jvm 满了，也不会被回收，会抛出 oom。
软引用： 一些有用但是非必须的对象，当 jvm 即将满了，会将软引用关联对象回收，回收之后如果内存还是不够，会抛出 oom。
弱引用： 不论内存是否够，只要开始垃圾回收，软引用的关联对象就会被回收。
虚引用： 最弱的引用和没有一样，随时可能被回收。
(1) 标记 - 清除算法 (适用老年代)： 先把可回收的对象进行标记，然后再进行清除。
优点： 算法简单。
缺点： 产生大量的内存碎片，效率低。
(2) 复制算法 (适用年轻代)： 把内存分成两个相同的块，一个是 from，一个是 to，每次只使用一个块，当一个块满了，就把存活的对象放到另一个块中，然后清空当前块。主要用在年轻区中的幸存区。
优点： 效率较高，没有内存碎片。
缺点： 内存利用率低。
(3) 标记 - 整理算法 (适用老年代)： 标记 - 清除算法的升级版，也叫标记 - 压缩算法，先进行标记，然后让存活对象向一端移动，然后清除掉边界以外的内存。
有点： 解决了内存利用率低和避免了内存碎片。
缺点： 增加了一个移动成本。
轻 GC： 普通 GC，当新对象在伊甸园区申请内存失败时，进行轻 GC，会回收可回收对象，没有被回收的对象进入幸存区，新对象分配内存极大部分都是在伊甸园区，所以这个区 GC 比较频繁。一个对象经历 15 次 GC，会进入老年区，可以设置。
重 GC： 全局 GC，对整个堆进行回收，所以要比轻 GC 慢，因此要减少重 GC，我们所说的 jvm 调优，大部分都是针对重 GC。
①当老年区满了会重 GC：年轻区对象进入或创建大对象会满。
②永久代满了会重 GC。
③方法区满了会重 GC。
④system.gc() 会重 GC 。
⑤轻 GC 后，进入老年代的大小大于老年代的可用内存会，第一次轻 GC 进入老年代要 2MB，第二次的时候会判断是否大于 2MB，不满足就会重 GC。
悲观锁： 在修改数据时，一定有别的线程来使用，所以在获取数据的时候会加锁。java 中的 synchronized 和 Lock 都是悲观锁。
乐观锁： 在修改数据时，一定没有别的线程来使用，所以不会添加锁。但是在更新数据的时候，会查看有没有线程修改数据。比如：版本号和 CAS 原理 (无锁算法)。
悲观锁： 更适合写操作多的场景，因为先加锁可以保证数据的正确。
乐观锁： 更适合读操作多的场景，因为不加锁会让读操作的性能提升。
前言：因为线程竞争，会导致线程阻塞或者挂起，但是如果同步资源的锁定时间很短，那么阻塞和挂起的花费的资源就得不偿失。
自旋锁： 当竞争的同步资源锁定时间短，就让线程自旋，如果自旋完成后，资源释放了锁，那线程就不用阻塞，直接获取资源，减少了切换线程的开销。实现原理是 CAS。
缺点：占用了处理器的时间，如果锁被占用的时间短还好，如果长那就白白浪费了处理器的时间。所以要限定自旋次数（默认是 10 次，可以使用-XX:PreBlockSpin 来更改）没有成功获得锁，就应当挂起线程。
自适应自旋锁： 自旋次数不固定，是由上一个在同一个锁上的自旋时间和锁拥有者的状态决定。如果在同一个锁对象上，自旋刚刚获得锁，并且持有锁的线程在运行，那么虚拟机会认为这次自旋也可能成功，那么自旋的时间就会比较长，如果某个锁，自旋没成功获得过，那么可能就会直接省掉自旋，进入阻塞，避免浪费处理器时间。
这四个锁是专门针对 synchronized 的，在 JDK1.6 中，对 synchronized 锁的实现引入了大量的优化，并且 synchronized 有多种锁状态。级别从低到高依次是：无锁、偏向锁、轻量级锁和重量级锁。锁状态只能升级不能降级。
无锁： 就是乐观锁。
偏向锁： 当只有一个线程访问加锁的资源，不存在多线程竞争的情况下，那么线程不需要重复获取锁，这时候就会给线程加一个偏向锁。(对比 Mark Word 解决加锁问题，避免 CAS 操作)
轻量级锁： 是指当锁是偏向锁的时候，被另外的线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，从而提高性能。(CAS+ 自旋)
重量级锁： 若当前只有一个等待线程，则该线程通过自旋进行等待。但是当自旋超过一定的次数或者一个线程在持有锁，一个在自旋，又有第三个来访时，轻量级锁升级为重量级锁。(将除了拥有锁的线程以外的线程都阻塞)
公平锁： 多个线程按照申请锁的顺序来获取锁。 Lock lock = new ReentrantLock(true); 默认是非公平锁，设置为 true 是公平锁。
优点：等待线程不会饿死。
缺点：CPU 唤醒线程得开销比非公平锁要大。
非公平锁： 多个线程获取锁的顺序并不是按照申请锁的顺序。 sybchronized 和 lock 都是非公平锁。
优点：减少唤醒线程得开销。
缺点：可能会出现线程饿死或者很久获得不了锁。
可重入锁： 也叫递归锁，同一个线程在外层方法获取了锁，在进入内层方法会自动获取锁。(前提：锁对象是同一个对象或者类)。ReentrantLock 和 synchronized 都是可重入锁。
独享锁： 独占锁是指锁一次只能被一个线程所持有。如果一个线程对数据加上排他锁后，那么其他线程不能再对该数据加任何类型的锁。获得独占锁的线程即能读数据又能修改数据。synchronized 和 Lock 的实现类就是独占锁。
共享锁： 共享锁是指锁可被多个线程所持有。如果一个线程对数据加上共享锁后，那么其他线程只能对数据再加共享锁，不能加独占锁。获得共享锁的线程只能读数据，不能修改数据。
互斥锁： 是独享锁的实现，某一资源同时只允许一个访问者对其访问。具有唯一和排它性。
读写锁： 是共享锁的实现，读写锁管理一组锁，一个是只读的锁，一个是写锁。读锁可以在没有写锁的时候被多个线程同时持有，而写锁是独占的。写锁的优先级要高于读锁。并发度要比互斥锁高，因为可以拥有多个读锁。
是锁的设计，不是具体的某一种锁，分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。
ConcurrentHashMap 的锁机制 jdk1.7 用的就是分段锁。
锁粗化： 将多个同步块的数量减少，并将单个同步块的作用范围扩大，本质上就是将多次上锁、解锁的请求合并为一次同步请求。
锁消失： 锁消除是指虚拟机编译器在运行时检测到了共享数据没有竞争的锁，从而将这些锁进行消除。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online