一、Java 基础语法 & 关键字

1. JDK、JRE 和 JVM 的区别

• JVM（Java Virtual Machine）：Java 虚拟机，负责执行字节码（.class）。提供类加载、字节码校验、内存管理（堆、方法区）、执行引擎、垃圾回收、线程调度等。是抽象的规范，具体由不同厂商实现（HotSpot、OpenJ9 等）。
• JRE（Java Runtime Environment）：运行环境，包含 JVM、核心类库（rt.jar 或 modules）、以及运行时需要的其它资源。用于运行 Java 程序。
• JDK（Java Development Kit）：开发工具包，包含 JRE + 开发工具（javac、jar、javadoc、调试工具等）。用于开发 Java 程序。
  总结：JDK ⊃ JRE ⊃ JVM（JDK 包含 JRE，JRE 包含 JVM）。

2. Java 的跨平台原理是什么？

• Java 程序先由 javac 编译成与平台无关的 字节码（.class）。字节码不是机器码，而是供 JVM 执行的指令集。
• 每个平台（Windows/Linux/macOS）有相应的 JVM 实现，JVM 把字节码翻译成该平台的机器指令（通过解释器、JIT 编译器等）。因此同一套 .class 可以在不同平台的 JVM 上运行 —— “一次编写，处处运行”（Write Once, Run Anywhere）。
• 其它保证跨平台的要点：标准库隐藏平台差异（I/O、线程等），需避免使用与平台绑定的本地代码（JNI）。

3. Java 的基本数据类型有哪些？各自的默认值？

8 种基本类型及默认值（成员变量/数组元素；局部变量无默认值必须初始化）：

• byte：1 byte，默认值 0
• short：2 bytes，默认值 0
• int：4 bytes，默认值 0
• long：8 bytes，默认值 0L
• float：4 bytes，默认值 0.0f
• double：8 bytes，默认值 0.0d
• char：2 bytes（UTF-16 code unit），默认值 '\u0000'（即 0）
• boolean：JVM 语义上用 1 bit 表示，默认值 false

另外，引用类型（对象、数组等）的默认值是 null。

4. byte、short、int、long 各占多少字节？

• byte：1 字节（8 位）
• short：2 字节（16 位）
• int：4 字节（32 位）
• long：8 字节（64 位）

（上述为 Java 语言规范定义，与平台无关。）

5. float 和 double 的区别？

• 精度与存储：
  • float：32 位单精度浮点（IEEE 754），约 6~7 位有效数字。
  • double：64 位双精度浮点（IEEE 754），约 15~16 位有效数字。
• 精度更高的 double 更常用；float 用于节省内存或与特定 API（如图形库）兼容。
• 注意：浮点数有精度误差，不适合做精确货币计算（应使用 BigDecimal）。
• 默认浮点字面量为 double（例如 1.2 是 double，写成 1.2f 才是 float）。

6. char 类型占几个字节？能存汉字吗？

• char 占 2 字节（16 位），表示 UTF-16 的一个 code unit。
• 能否存汉字：多数常用汉字（位于基本多文种平面 BMP）可以用单个 char 表示（例如 '你'）；但有些罕见汉字或 emoji 属于补充平面（Supplementary Planes），它们需要 两个 char（称为 surrogate pair） 来表示。
• 因此，单个 char 能表示一个 UTF-16 code unit，而不是完整的 Unicode code point。处理 Unicode 字符时注意使用 int codePoint / Character 的相关 API。

7. 自动装箱（autoboxing）和拆箱（unboxing）的原理是什么？

• 概念：

  • 装箱：把基本类型自动转换成对应的包装类型（如 int → Integer）。
  • 拆箱：把包装类型自动转换回基本类型（如 Integer → int）。

• 编译器行为：自动装箱/拆箱是在编译期由 Java 编译器插入对应的调用，示例：

  1 2	Integer a = 10; // 编译器会转换为 Integer.valueOf(10) int b = a; // 编译器会转换为 a.intValue()

• valueOf 缓存：包装类（如 Integer.valueOf(int)）会对小整数（默认 -128 到 127）做缓存以重用对象，减少频繁创建对象。

• 注意事项：

  • 拆箱 null 会抛出 NullPointerException：

    1 2	Integer x = null; int y = x; // NPE

  • 装箱/拆箱会有性能开销（对象创建、装箱/拆箱方法调用），在性能敏感场景尽量使用基本类型或手动优化。

  • 比较时注意：Integer a = 100; Integer b = 100; a==b 在缓存范围内可能为 true，超出范围则通常为 false。

8. == 和 equals() 的区别？

• ==：
  • 对于基本类型：比较 值（数值是否相等）。
  • 对于引用类型：比较 引用地址（是否是同一个对象）。
• equals()：
  • 是 Object 的方法，默认实现也是比较引用（等价于 ==）。
  • 许多类（如 String、Integer、集合类等）重写了 equals()，用于比较逻辑/内容相等。
• 使用建议：
  • 比较对象内容用 equals()（需检查 null），比较是否同一实例用 ==。
  • 与 equals() 配套应重写 hashCode()（见下题）。

9. hashCode 和 equals 的关系？

• 合同（Contract）（重要）：
  1. 如果两个对象通过 equals() 被判定为相等（a.equals(b) 为 true），那么 a.hashCode() == b.hashCode() 必须成立。
  2. 反之不要求：hashCode 相等的对象不一定 equals() 相等（哈希冲突允许）。
• 在哈希集合中的角色：
  • 哈希表（HashMap/HashSet）先用 hashCode() 找到桶（bucket），若桶中有多个元素，再用 equals() 逐个比较确认相等或冲突。
  • 如果只重写 equals() 而不重写 hashCode() 会破坏集合行为（例如放入 HashSet 后无法正确查找）。
• 实现要点：
  • hashCode() 要尽量分散（降低冲突），并在对象不可变字段上基于相同规则计算。
  • 若对象可变，若用于哈希集合要小心：修改字段会导致 hashCode() 改变，破坏集合内部结构。

10. String、StringBuffer、StringBuilder 的区别？

• String：
  • 不可变（immutable），每次修改都会产生新的对象（或新内部 char/byte 数组）。
  • 线程安全（因为不可变），适合频繁读取、少量修改的场景。
• StringBuffer：
  • 可变的字符序列（内部有缓冲区 char[]/byte[]），几乎与 StringBuilder 接口相同。
  • 线程安全，其方法大多使用 synchronized，因此在多线程下可以被多个线程安全使用。
  • 相对较慢（同步开销）。
• StringBuilder（Java 5+）：
  • 可变，非线程安全（没有同步），比 StringBuffer 快。
  • 推荐在单线程或外部已同步的场景下使用。
• 选择建议：
  • 多线程需要可变字符串：StringBuffer（或外部同步）。
  • 单线程/局部构造字符串：StringBuilder。
  • 常量字符串或少量拼接：String（编译器对 + 会优化为 StringBuilder）。

11. 为什么 String 是不可变的（immutable）？

原因（几条重要理由）：

1. 安全性：String 经常用于关键场景（类加载器、网络地址、文件名、权限检查、数据库连接字符串等）。不可变保证在传递引用时不被恶意或意外修改。
2. 线程安全：不可变对象固有线程安全，多个线程可共享同一 String 实例而无需同步。
3. 性能（缓存 hashCode）：String 的哈希值可缓存（hash 字段），便于作为 Map 的 key，避免重复计算。
4. 字符串常量池：可安全地将字面量放入池中重用，不用复制或担心修改。
5. 优化：JVM 可进行共享、常量折叠等优化（更易于实现某些编译期/运行期优化）。

12. String 常量池的实现机制？

• 概念：编译期和运行期维护一个字符串池（String Intern Pool），用于存放字符串字面量（literal）和显式 intern() 后的字符串，以便重用相同内容的 String 实例。
• 编译期：源代码中的字符串字面量（如 "abc"）会被放到常量池（编译后的 class 文件常量池），类加载后这些字面量会放入运行时的字符串池。
• 运行期：
  • 以前（Java 6 及更早）：字符串常量池在 PermGen（方法区）中。
  • Java 7 起：常量池迁移到 Java 堆（运行时常量池也在堆里），避免 PermGen 问题。
• intern()：当调用 s.intern() 时，JVM 会检查池中是否已有相同内容的字符串：
  • 若存在，返回池中的引用；
  • 若不存在，将该字符串的引用加入池并返回它。
• 编译时优化：字符串常量的拼接（编译时常量）会在编译期合并，如 "a" + "b" → "ab"，直接放入常量池；而运行时拼接（变量参与）则使用 StringBuilder。

13. new String("abc") 创建了几个对象？

• 通常情形：
  • 若 "abc" 字面量尚未在常量池中存在，执行 new String("abc") 会导致 两个对象 被创建：常量池中的 "abc"（一个 String）和堆中通过 new 创建的新的 String 实例（内容通常是对常量池中字符数组的复制或共享，具体实现随 Java 版本而异）。
  • 如果字面量 "abc" 已经存在于常量池中（例如之前被加载过），那么 new String("abc") 只会创建 一个堆对象（new 的那个 String）。
• 注意：自 Java 7/9 后 String 内部实现改变（压缩字符串、byte[] 存储等），但逻辑上上述结论成立：通常 1 或 2 个对象，取决于常量池中是否已存在该字面量。

14. final 关键字的作用？

• 用于类（final class）：类不可被继承（如 String）。
• 用于方法（final 方法）：方法不能被子类重写（override），用于确保行为不可变。
• 用于变量（final 字段/局部变量）：
  • 对基本类型：赋值后值不可改变（常量）。
  • 对引用类型：引用不可改变（不能指向另一个对象），但所指向对象的内部状态仍可变（除非对象本身不可变）。
  • static final 常用来定义常量（编译期常量）。
• 用于参数（方法形参可以声明为 final）：代表方法内不能修改该参数引用/值。
• 其它用途：在多线程中，final 字段的写-构造过程被 JMM（Java 内存模型）处理，确保构造完成后其他线程可见（安全发布方面有好处）。

15. static 关键字的作用？

• 用于声明类级别成员（字段、方法、初始化块、嵌套类），不依赖实例。
• static 变量：类变量，所有实例共享一份。内存中仅有一份副本。
• static 方法：类方法，可通过 ClassName.method() 调用；不能直接访问非静态成员（因无 this）。
• static 代码块：类加载时执行一次（用于静态初始化）。
• static 嵌套类：可以声明为静态的内部类（静态嵌套类），没有外部实例引用。

16. static 修饰变量、方法、代码块分别意味着什么？

• static 变量（类变量）：
  • 随类加载而创建，所有对象共享同一份数据。
  • 可通过 ClassName.field 或 instance.field（不推荐）访问。
• static 方法：
  • 属于类，调用时无需实例。
  • 不能使用 this、不能直接访问非静态成员。
  • 可作为工具方法（如 Math.abs()）。
• static 代码块：
  • 在类加载阶段执行一次，用于复杂静态初始化（比如初始化静态常量、加载本地库等）。
  • 执行顺序：静态块按定义顺序执行，类加载时运行（在实例化之前）。

17. static 和 final 能一起用吗？

• 能。static final 常用于定义类常量（尤其是基本类型和 String），例如：

  1 2	public static final int MAX = 100; public static final String NAME = "abc";

• 区别：

  • 如果是编译期常量（static final 基本类型或 String 且在编译时可以确定），编译器会将其内联到使用处（被引用的类编译后看到的是常量值），注意跨模块修改可能导致需要重新编译引用方。
  • 如果是 static final 引用对象且不是编译期常量，则引用本身不可变，但对象内容可能可变。

18. static 内部类和非静态内部类的区别？

• 静态内部类（static nested class）：
  • 相当于外部类的一个静态成员。
  • 没有对外部类实例的隐式引用（不能直接访问外部类的非静态成员）。
  • 可以像普通类那样实例化：Outer.StaticInner inner = new Outer.StaticInner();
• 非静态内部类（inner class）：
  • 每个实例隐式持有一个外部类实例引用（Outer.this），可以直接访问外部类的所有成员（包括私有成员）。
  • 创建方式：Outer outer = new Outer(); Outer.Inner inner = outer.new Inner();
  • 占用外部类对象的内存引用，可能导致内存泄露（如果长期持有内部类实例导致外部类不能被回收）。
• 选择原则：如果内部类不需要访问外部实例成员，优先使用 static 嵌套类，避免额外引用。

19. Java 中的 this 和 super 的区别？

• this：
  • 引用当前对象的引用。
  • 用于访问当前类的实例变量、调用当前类的其他构造器（this(...)）、或传递当前对象引用。
• super：
  • 引用当前对象的父类部分。
  • 用于访问父类被覆盖的方法（super.method()）、父类字段（若有同名字段）、以及在子类构造器第一行调用父类构造器（super(...)）。
• 注意：
  • this() 或 super() 必须在构造器的第一行（两者不能同时出现）。
  • super 不能用于访问父类的 private 成员（编译期限制）。

20. Java 中构造方法能否被重写？

• 不能。重写（override）适用于实例方法，构造方法不是继承的成员，子类不能重写父类的构造器。
• 可以重载（overload）：在同一类中同名构造器有不同参数列表属于重载。
• 子类构造器可通过 super(...) 显式调用父类构造器来完成父类初始化。

21. 接口和抽象类的区别？

• 接口（interface）：
  • 早期（Java 7 之前）：只包含抽象方法（默认是 public abstract）和 public static final 常量。
  • Java 8+：可以包含 default 方法与 static 方法（可以有部分实现）；Java 9+ 允许 private 方法。
  • 支持多继承（一个类可以实现多个接口）。
  • 没有实例字段（除 static final 常量外）。
• 抽象类（abstract class）：
  • 可以有实例字段（非静态成员变量）、已有实现的方法（具体方法）、构造器。
  • 适合表示一类有共同行为并共享状态的类层次。
  • 类只能单继承（只能继承一个抽象类）。
• 选择建议：
  • 如果需要多继承行为、只定义方法契约且不需要状态，使用接口。
  • 如果需要提供共有实现和状态，使用抽象类。

22. 接口中可以有 default 方法和 static 方法吗？

• 可以（Java 8 起）。
  • default 方法：为实现类提供默认实现，避免破坏已有实现（接口演化）。实现类可以覆盖（override）。
  • static 方法：属于接口自身，可以通过 InterfaceName.method() 调用，不能通过实例调用。
• Java 9 及以后还可有 private 方法，供接口内部复用实现逻辑。

23. Java 8 接口新增了什么？

• Java 8 在接口中新增了 default 方法 和 static 方法，允许接口提供带实现的方法，从而便于接口的演化（向后兼容）。这也是 Java 8 引入函数式编程支持的基础之一（允许接口作为函数式接口）。

24. Java 8 有什么新特性，并详细介绍（重点）

一、Java 8 新特性深入解析

好的，我来帮你把 Java 8 的六大核心特性（Lambda、函数式接口、Stream API、方法引用、java.time API、Optional） 进行 完整整合，从概念、示例、底层原理、实现机制、特点和优势做一个统一、连贯的解析。

Java 8 六大核心特性整合解析

1. Lambda 表达式

概念

• 匿名函数，允许把行为作为参数传递。
• 简化匿名内部类写法，实现函数式编程。

示例

1
2

List<String> list = Arrays.asList("a", "bb", "ccc");
Collections.sort(list, (s1, s2) -> s1.length() - s2.length());

底层原理

• 编译器生成静态/实例方法 + invokedynamic 指令。
• JVM 调用 LambdaMetafactory 动态生成函数对象，实现 函数式接口。
• 捕获外部变量通过闭包机制存储（必须是 effectively final）。

特点

• 语法简洁
• 可作为参数传递行为
• 性能高于匿名内部类（减少对象创建）

2. 函数式接口

概念

• 仅有一个抽象方法的接口，用作 Lambda 表达式的目标类型。
• 可用 @FunctionalInterface 标识。

示例

1
2
3
4
5
6
7

@FunctionalInterface
interface Converter<F, T> {
    T convert(F from);
}

Converter<String, Integer> c = Integer::valueOf;
System.out.println(c.convert("123")); // 123

底层原理

• Lambda 表达式编译时生成实现函数式接口的函数对象。
• 捕获变量通过闭包对象保存。

特点

• 简化匿名类
• 支持函数式编程
• 可与 Stream / Optional 等结合

3. Stream API

概念

• 对集合进行声明式操作（过滤、映射、归约）。
• 支持 惰性求值 和 并行处理。

示例

1
2
3
4
5
6

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> filtered = names.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());
System.out.println(filtered); // [ALICE, CHARLIE]

底层原理

• Stream 是流水线对象，中间操作返回新的 Stream，终端操作触发计算。
• 串行流：顺序迭代器处理
• 并行流：ForkJoinPool 分块处理

特点

• 声明式、链式操作
• 支持并行
• 可与 Lambda / 方法引用结合

4. 方法引用

概念

• Lambda 表达式的简化写法，引用现有方法。
• 类型：
  1. 静态方法引用：ClassName::staticMethod
  2. 实例方法引用：instance::method
  3. 构造器引用：ClassName::new

示例

1
2
3

List<String> names = Arrays.asList("a", "bb", "ccc");
names.forEach(System.out::println); // 实例方法引用
Supplier<List<String>> listSupplier = ArrayList::new; // 构造器引用

底层原理

• 编译器转成 Lambda 表达式 + invokedynamic。
• JVM 生成实现函数式接口的函数对象，内部持有方法引用。

特点

• 简洁直观
• 可减少 Lambda 代码
• 与 Stream / Optional 配合使用

5. java.time API

概念

• 替代 Date / Calendar，不可变、线程安全。
• 核心类：
  • LocalDate / LocalTime / LocalDateTime（无时区）
  • ZonedDateTime（带时区）
  • Duration / Period（时间段）

示例

1
2
3
4
5

LocalDate today = LocalDate.now();
LocalDate tomorrow = today.plusDays(1);
ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("Asia/Singapore"));
System.out.println(tomorrow);
System.out.println(zdt);

底层原理

• 内部字段 final 保存值，不可变。
• 工厂方法创建对象，链式操作返回新对象。
• 使用 enum + 整型/字节优化存储（如 LocalDate 年月日用 int）。

特点

• 不可变，线程安全
• 链式操作，易组合
• 支持各种历法和时区计算

6. Optional

概念

• 容器对象，防止 NullPointerException。
• 可以包含值或为空（empty）。

示例

1
2
3
4
5
6

Optional<String> opt1 = Optional.of("Hello");
Optional<String> opt2 = Optional.ofNullable(null);

System.out.println(opt1.isPresent()); // true
System.out.println(opt2.orElse("Default")); // Default
opt1.map(String::toUpperCase).ifPresent(System.out::println); // HELLO

底层原理

• 内部 value 字段存储非空值，空值使用单例 EMPTY。
• map / flatMap / filter 返回新的 Optional，对象不可变。
• 与 Lambda / 函数式接口结合实现链式安全操作。

特点

• 避免显式 null 判断
• 支持链式调用
• 可与 Stream / Lambda 配合

Java 8 六大核心特性底层对比表

1. Lambda 表达式

语法

1
2

(parameters) -> expression
(parameters) -> { statements; }

示例：排序

1
2
3
4
5
6
7
8
9
10

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
// 传统匿名类写法
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }
});
// Lambda 写法
Collections.sort(names, (s1, s2) -> s1.length() - s2.length());

图示

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

编译器把 Lambda 转成匿名类或 invokedynamic 机制
+----------------+
|   Lambda 表达式  |
+----------------+
        |
        v
+----------------+
|  JVM runtime   |
|  invokedynamic |
+----------------+
        |
        v
+----------------+
| Function Object|
+----------------+

• 捕获外部变量：必须是 effectively final，底层通过匿名类的构造器保存引用或值。

2. Stream API

特点

1. 声明式：关注“做什么”，而非“怎么做”。
2. 惰性求值：中间操作不会立即执行，终端操作触发。
3. 可并行：使用 .parallelStream() 自动利用多核 CPU。

示例：数据处理

1
2
3
4
5
6
7

List<String> words = Arrays.asList("Java","Python","C++","Go");
List<String> filtered = words.stream()
    .filter(s -> s.length() > 2)
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());
System.out.println(filtered); // [C++, JAVA, PYTHON]

图示

1
2
3
4

List -> Stream -> filter -> map -> sorted -> collect
   |        |        |      |           |
   v        v        v      v           v
   数据流   中间操作  中间操作  中间操作   终端操作

3. 方法引用

类型

1. 静态方法：Class::staticMethod
2. 实例方法：instance::method
3. 构造器：Class::new

示例

1
2
3

List<String> names = Arrays.asList("a", "bb", "ccc");
names.forEach(System.out::println); // 实例方法引用
Supplier<List<String>> listSupplier = ArrayList::new; // 构造器引用

4. java.time API

示例

1
2
3
4
5
6

LocalDate date = LocalDate.of(2025, 9, 10);
LocalDate tomorrow = date.plusDays(1);
System.out.println(tomorrow); // 2025-09-11

ZonedDateTime zdt = ZonedDateTime.now(ZoneId.of("Asia/Singapore"));
System.out.println(zdt);

图示

1
2
3
4
5
6

LocalDate/Time (不可变)
  |-- plusDays()
  |-- minusMonths()
  |-- withDayOfMonth()
  v
新的 LocalDate/Time 对象

• 线程安全：无需同步即可共享对象。

5. Optional

示例

1
2
3

Optional<String> opt = Optional.ofNullable(null);
String result = opt.orElse("默认值");
System.out.println(result); // 默认值

图示

1
2
3
4
5
6
7
8

Optional.ofNullable(value)
    |
    v
+-----------------+
| value != null ? |
|  contains value |
|  else empty()   |
+-----------------+

二、synchronized 底层原理深入解析

1. JVM 锁的类型

2. synchronized 对象头结构

• 每个对象在 JVM 内存中都有 对象头（Mark Word），存储锁信息、哈希码、GC 标记等。

1
2
3
4

对象头 Mark Word (32/64bit)
+----------------+----------------+----------------+
| HashCode       | GC info        | Lock info      |
+----------------+----------------+----------------+

• 锁标记位：
  • 00：无锁
  • 01：偏向锁
  • 10：轻量级锁
  • 11：重量级锁

3. synchronized 执行流程

a) 偏向锁（无竞争）

1

线程获取锁 -> 在对象头打上线程ID -> 执行 -> 释放锁 -> 保持偏向状态

b) 轻量级锁（CAS竞争）

1
2

线程尝试CAS抢锁 -> 成功：持有锁 -> 执行 -> 释放
                      |-> 失败：升级为重量级锁

c) 重量级锁（阻塞）

1

线程无法获取锁 -> 阻塞（OS等待队列） -> 被唤醒 -> 获取锁 -> 执行 -> 释放锁

图示

1
2
3
4
5
6
7
8
9

+------------------+
|  synchronized()  |
+------------------+
          |
    JVM对象头Mark Word
          |
+------------------------+
| 偏向锁 -> 轻量级锁 -> 重量级锁
+------------------------+

4. synchronized 方法示例

1
2
3
4
5
6
7
8
9
10
11

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

• 锁对象：实例方法锁住 this，静态方法锁住类对象 ClassName.class。
• 效果：同一时间只有一个线程能进入 increment()，保证 count++ 操作的原子性。

5. JVM 优化

• 锁消除：编译器或 JIT 可检测无竞争情况，消除同步锁。
• 锁粗化：把多次连续的小范围锁合并，减少加锁次数。
• 偏向锁 / 轻量级锁 / 重量级锁升级：动态适应竞争情况，兼顾性能与正确性。

如果你愿意，我可以帮你把 Java 8 新特性 和 synchronized 底层原理 做一张 图解全流程总结图，把 Lambda、Stream、锁状态、对象头等内容融合成一张直观的图，方便记忆和面试答题。

你希望我做这张图吗？25. 多态的实现机制是什么？

• 概念：同一操作作用于不同对象时表现出不同的行为（主要表现为方法的动态绑定）。
• 实现机制：
  • 编译时：根据引用类型检查方法签名（静态类型检查）。
  • 运行时：实际调用的方法根据对象的实际类型（运行时类型）决定；即 动态绑定（dynamic dispatch）。
  • JVM 通常通过 虚方法表（vtable）/方法查找机制 实现。调用一个非 static、非 private、非 final 的方法时，会在运行时查找实际类的实现并调用。
• 结果：子类可以覆盖父类方法，调用者使用父类引用指向子类对象时，调用的是子类的覆盖方法（运行时决定）。
• 注意：static、private、final 方法不会被动态绑定（是静态绑定）。

26. 方法重载（overload）和方法重写（override）的区别？

• 方法重载（Overloading）：

  • 同一类中方法名相同、参数列表不同（参数类型/个数/顺序），返回类型可以不同。
  • 编译时决定（重载解析在编译期完成），与继承关系无关。

• 方法重写（Overriding）：

  • 子类定义与父类相同方法签名（方法名 + 参数类型相同）的实现，目的是改变/扩展父类行为。
  • 运行时动态绑定，必须满足访问权限不能更严格，抛出的受检异常不能超过父类版本等规则。

• 示例：

  1 2 3 4 5 6

  // overload void f(int x) {} void f(String s) {} // override class A { void m() {} } class B extends A { @Override void m() {} }

27. Java 支持多继承吗？如何实现类似效果？

• 类的多继承：Java 不支持类的多继承（不能继承多个类），以避免菱形继承问题（diamond problem）。
• 实现类似效果的方法：
  • 接口多实现：一个类可以实现多个接口（Java 8 的 default 方法也带来类似多继承方法实现的可能，但有冲突解决规则）。
  • 组合/委托（composition/delegation）：在类中持有其它类的实例并把调用委托给它们（优于继承的面向对象设计原则）。
• 接口冲突解决：若多个接口提供相同默认方法，类必须重写该方法并明确调用哪个接口的默认实现（InterfaceName.super.method()）。

28. Java 的四种访问修饰符？

• public：对所有类可见（任何包）。
• protected：对同包类和子类可见（即同包或子类可以访问）。
• 默认（包私有，package-private）（不写修饰符）：对同包类可见，包外不可见。
• private：仅在本类内可见，包外/子类不可访问（子类无法直接访问父类 private 成员）。
• 注意：对类（顶层类）只能使用 public 或默认（包私有），不能声明为 private/protected。

29. transient 关键字的作用？

• 用于标记字段在 Java 序列化（Serializable）过程中不被序列化。
• 被标记为 transient 的字段在序列化后不会写入序列化流，反序列化时这些字段会以默认值恢复（基本类型 0，引用类型 null）。
• 常用于敏感信息（密码）、不需要持久化的缓存字段、或可重建的状态字段。
• 注意：static 字段本身也不会被序列化（因为是类级别，不属于实例状态）。

30. volatile 关键字的作用？

• 可见性：保证对 volatile 变量的写入对其它线程立即可见（读取总是从主内存而不是线程缓存读取）。
• 禁止指令重排序（部分）：读/写 volatile 存在的内存屏障能保证一定的有序性（写 volatile 发生在后续读的可见性上，更多细节参考 JMM）。
• 不保证原子性：对单次读/写操作是原子的（对 long/double 在 Java 5 后也保证原子），但非原子操作（如 i++）不是原子的。
• 典型用途：
  • 状态标志（如 volatile boolean running）。
  • 用于实现双重检查锁定（DCL）单例中的 instance（在 Java 5+ 环境下有效）。
• 与 synchronized 比较：
  • volatile 轻量，只保证可见性与部分有序性，不保证互斥；适用于简单状态通信。
  • synchronized 提供互斥和可见性保证（更重），并可配合 wait/notify。

31. synchronized 的作用及底层原理？

作用

• 互斥（排它）：保证同一时间只有一个线程可以执行被 synchronized 修饰的代码块或方法（针对同一把锁）。
• 可见性：进入/退出同步块会建立 happens-before 关系，确保锁释放前的写对随后获取该锁的线程可见。
• 用途：保护临界区、确保多个线程对共享可变状态的安全访问。

使用方式

• 方法级别：
  • synchronized void m() { ... }：等价于 synchronized(this)（实例方法）或 synchronized (ClassName.class)（静态方法）。
• 代码块级别：
  • synchronized(this) { ... } 或 synchronized(lockObj) { ... } 更灵活，能减小锁的粒度。

底层原理（HotSpot 实现概要）

• JVM 使用对象头（object header）中的 mark word 和关联数据结构维护锁状态。
• 锁优化策略（为提升性能，HotSpot 引入若干优化）：
  1. 偏向锁（Biased Locking）：在没有竞争的情况下，锁会偏向于第一次获得它的线程，重复获取无需 CAS，减少开销。
  2. 轻量级锁（Lightweight Locking）：使用 CAS 操作在栈上记录加锁记录，避免进入重量级监视器（monitor）。
  3. 重量级锁（Monitor/Mutex）：当竞争激烈或 CAS 失败时，升级为重量级锁，使用操作系统互斥量（可能涉及线程阻塞/唤醒）。
• monitorenter / monitorexit 是字节码指令（由编译器/字节码生成器生成）。
• JIT 编译器可进行锁消除、锁粗化、锁优化等（当能证明无并发访问或已外部同步时）。

wait/notify/notifyAll

• Object.wait()、notify()、notifyAll() 必须在持有对象监视器（即在 synchronized 块内）时调用，用于线程间协作（条件等待/通知）。
• wait() 会释放锁并进入等待队列；notify() 唤醒等待队列中的一个线程（被唤醒线程在重新获得锁后继续）。

注意与陷阱

• 锁粒度：避免用过大锁（如 synchronized 在方法头部锁住大量操作），谨慎使用 String 或装箱对象作为锁（可能会导致多个实例共用同一锁或锁被外部持有）。
• 死锁：多线程锁顺序不当可能死锁；设计时谨防。
• 性能：在高并发下可考虑使用 java.util.concurrent 包（ReentrantLock、ConcurrentHashMap、AtomicXxx）等更细粒度、高性能的并发工具。

二、面向对象编程（OOP）

1. 面向对象的三大特性是什么？
2. 封装的作用是什么？
3. 多态的优点是什么？
4. 重写方法时返回值能否不同？
5. 构造函数能否被继承？
6. 构造函数能否 private？
7. 单例模式的几种实现方式？
8. 饿汉式和懒汉式单例的区别？
9. 为什么要使用内部类？
10. 成员内部类、局部内部类、静态内部类的区别？
11. Java 中对象的创建方式有哪些？
12. 对象之间的浅拷贝和深拷贝的区别？
13. clone() 方法的原理？
14. 为什么 Java 不支持多继承？
15. Java 是值传递还是引用传递？
16. 方法参数传递时是如何处理对象的？
17. 封装性体现在哪些方面？
18. 为什么需要继承？
19. 重写 Object 类的 toString 方法的意义？
20. 重写 Object 类的 equals 方法时需要注意什么？

三、异常处理

1. Java 的异常体系结构？
2. Checked Exception 和 Unchecked Exception 的区别？
3. throw 和 throws 的区别？
4. try-catch-finally 的执行顺序？
5. finally 中的 return 会覆盖 try 中的 return 吗？
6. try-with-resources 的作用？
7. 自定义异常类如何实现？
8. Error 和 Exception 的区别？
9. NullPointerException 常见场景有哪些？
10. 运行时异常需要捕获吗？为什么？

四、集合框架（Collections）

1. Collection 和 Collections 的区别？
2. List、Set、Map 的区别？
3. ArrayList 和 LinkedList 的区别？
4. HashMap 的底层实现？
5. HashMap 1.7 和 1.8 的区别？
6. HashMap 如何解决哈希冲突？
7. HashSet 的底层实现？
8. ConcurrentHashMap 的底层实现？
9. Hashtable 和 HashMap 的区别？
10. TreeMap 和 HashMap 的区别？
11. WeakHashMap 的特点？
12. CopyOnWriteArrayList 的应用场景？
13. LinkedHashMap 的底层原理？
14. Map 的 key 是否可以为 null？
15. ArrayList 扩容机制？
16. Vector 和 ArrayList 的区别？
17. PriorityQueue 的底层实现？
18. BlockingQueue 的几种实现类？
19. HashMap 死循环问题出现在哪个版本？
20. fail-fast 和 fail-safe 的区别？

五、并发编程（JUC）

1. Java 中的线程生命周期？
2. Runnable 和 Callable 的区别？
3. ThreadPoolExecutor 的参数有哪些？
4. 线程池的拒绝策略有哪些？
5. 创建线程的四种方式？
6. synchronized 的底层实现原理？
7. synchronized 和 ReentrantLock 的区别？
8. 公平锁和非公平锁的区别？
9. AQS 的原理？
10. CountDownLatch 的应用场景？
11. CyclicBarrier 的应用场景？
12. Semaphore 的应用场景？
13. Exchanger 的应用场景？
14. volatile 能保证原子性吗？
15. CAS 的原理？
16. ABA 问题是什么？怎么解决？
17. ThreadLocal 的作用及原理？
18. ThreadLocal 内存泄漏的原因？
19. JUC 中的原子类有哪些？
20. 乐观锁和悲观锁的区别？

六、JVM & 内存模型

1. JVM 内存结构？
2. 堆和栈的区别？
3. 堆内存的分代模型？
4. 新生代、老年代、永久代的区别？
5. 元空间和永久代的区别？
6. 对象在堆中的分配过程？
7. 对象什么时候进入老年代？
8. JVM 的垃圾回收算法？
9. 垃圾收集器有哪些？
10. CMS 和 G1 的区别？
11. Minor GC 和 Full GC 的区别？
12. 什么是 Stop The World？
13. JVM 常见的调优参数？
14. 类加载的双亲委派机制？
15. 双亲委派的好处？
16. 类加载器的种类？
17. OOM 的常见类型？
18. 内存泄漏和内存溢出的区别？
19. finalize() 方法的作用？
20. Java 内存模型（JMM）的核心内容？

七、泛型、注解、反射

1. 什么是泛型？
2. 泛型的类型擦除机制？
3. 泛型通配符 ? extends 和 ? super 的区别？
4. 注解的作用是什么？
5. 元注解有哪些？
6. 自定义注解如何实现？
7. 反射的作用？
8. 反射的性能问题？
9. 反射能否访问私有字段？
10. 动态代理的两种实现方式？
11. JDK 动态代理和 CGLIB 的区别？
12. 反射如何创建对象？
13. Class.forName 和 ClassLoader.loadClass 的区别？
14. 注解和反射结合能实现哪些功能？
15. 注解处理器（APT）的作用？

八、Java 8+ 新特性

1. Lambda 表达式的作用？
2. 函数式接口有哪些？
3. Stream 流的常见操作？
4. Optional 的作用？
5. CompletableFuture 的作用？
6. Java 8 接口的默认方法和静态方法？
7. forEach 和传统 for 的区别？
8. parallelStream 的原理？
9. Java 9 模块化系统（Jigsaw）是什么？
10. Java 14 的 switch 表达式增强？
11. Java 16 的 record 特性？
12. Java 17 的 sealed class 特性？
13. var 关键字是什么？
14. ZGC 的特性？
15. Project Loom 的虚拟线程是什么？

九、IO

好 — 我把范围 大幅扩展并细化，把 Socket / TCP / UDP / TLS / WebSocket / 内核调优 / 实战题 / 编码题 都加进来了。现在给你一个160 道题目清单（按主题分组），覆盖面更广、更细致，便于你当面试题库或复习大纲使用。

Java IO & Socket 深度面试题（160题）

一、Java IO 基础与流（1–20）

1. Java IO 的总体体系结构是什么？
2. InputStream / OutputStream 的常见子类有哪些？
3. Reader / Writer 的常见子类有哪些？
4. 字节流与字符流的本质区别和使用场景？
5. 为什么要有缓冲流（BufferedInputStream / BufferedReader）？
6. flush() 与 close() 的区别与细节（含异常处理）？
7. try-with-resources 的工作原理（AutoCloseable、suppressed exceptions）？
8. 装饰器模式在 Java IO 中如何体现？举例链式包装。
9. File 类的能力与限制（能否读写数据、元数据操作）？
10. RandomAccessFile 的用途、指针机制与并发注意点？
11. FileInputStream 与 FileReader 有什么差别？何时用哪个？
12. 常见的文件读写拷贝实现方式（read/write、buffered、NIO transferTo）性能对比。
13. 如何安全地读写文本并处理字符编码（InputStreamReader/OutputStreamWriter）？
14. 字符编码问题常见坑（UTF-8 与 GBK 混用、BOM、截断）如何避免？
15. 文件追加（append）实现方式与原子性问题。
16. 如何判断并处理文件是否存在、权限、是否被占用？
17. File.mkdirs() 与 mkdir() 的区别与返回值含义。
18. 临时文件（File.createTempFile）与删除策略。
19. 文件的读写锁与并发访问策略（何时需要外部锁）。
20. 流关闭异常处理的最佳实践。

二、Java IO 设计与模式（21–40）

1. InputStream/OutputStream 的装饰器链常见组合（Buffered -> GZIP -> Cipher 等）。
2. PushbackInputStream、SequenceInputStream 的作用与应用场景。
3. PipedInputStream / PipedOutputStream（管道流）的使用与线程注意点。
4. FilterInputStream/FilterOutputStream 的设计与扩展。
5. IO 与异常处理：IOException 的常见子类与处理策略。
6. 流复制的常见实现模板（模板方法式代码）。
7. NIO 引入前的 IO 局限性（可扩展性、线程模型）。
8. 如何实现一个带超时的读操作（Socket/Channel）？
9. 流式处理与内存友好型处理（流式处理大文件）实践。
10. Base64 编解码在流中的高效集成方法。
11. 加密/解密流（CipherInputStream/CipherOutputStream）如何正确关闭？
12. GZIPInputStream/GZIPOutputStream 的压缩流使用注意事项。
13. ObjectInputStream/ObjectOutputStream 的工作机制（类元数据、句柄表）。
14. 如何实现跨语言的序列化兼容（JSON/Protobuf/Avro）？
15. 实现自定义 InputStream 子类时需要注意什么（read 方法语义）？
16. 设计用于日志写入的高吞吐 IO 模式（异步批量写）。
17. 流复制时如何统计速率与进度（带进度回调）？
18. 如何安全处理二进制文件（流边界、magic header）？
19. 大对象/大数组写入流时的内存优化策略（分块、流化）。
20. 如何实现可重入/可恢复的断点续传文件写入？

三、文件系统、锁与操作（41–60）

1. Java 中文件锁 FileLock 的类型（共享/独占）及实现原理。
2. FileLock 的局限性（跨 JVM、跨 OS 行为差异）。
3. 文件描述符泄露的常见原因与定位方法。
4. 文件句柄上限（ulimit）对 Java 服务的影响与排查。
5. 硬链接与软链接在 Java 中如何区分与操作？
6. MappedByteBuffer（内存映射文件）的优劣与风险（内存回收、文件锁）。
7. 大文件分片读取与并发合并策略。
8. 如何高效统计大日志文件中某条件的行数（分块 + 并行）？
9. 文件系统缓存（PageCache）对读写性能的影响机制。
10. fsync / FileDescriptor.sync 在持久化保障上的作用。
11. 文件顺序写与随机写的性能差异与优化建议。
12. 磁盘类型（SSD vs HDD）对 IO 策略的影响。
13. 原子重命名（renameTo/Files.move）的跨平台差异。
14. 文件监控（WatchService）的实现限制与替代方案。
15. 处理日志切割（rotation）时的文件句柄管理策略。
16. 如何实现零停机部署中对文件的平滑迁移？
17. 软删除（标记删除）与物理删除的 IO 考量。
18. 备份/快照策略对 IO 的影响（冷备 vs 热备）。
19. 大文件校验（MD5/SHA）在流式处理中的实现。
20. 文件系统一致性问题（写入后立即读取到不同步）如何诊断。

四、序列化与反序列化（61–75）

1. Java 原生序列化（Serializable）的机制和对象写入格式。
2. serialVersionUID 的作用、自动生成与兼容性策略。
3. transient 字段、static 字段在序列化中的处理。
4. Externalizable 与 Serializable 的区别与使用场景。
5. Java 序列化的安全风险（反序列化漏洞）与防护措施。
6. 高性能二进制序列化方案对比：Kryo、Protostuff、Protobuf、Avro。
7. JSON 和二进制序列化的权衡（可读性 vs 性能/大小）。
8. 如何实现可演化的序列化协议（向前/向后兼容）？
9. 对象图序列化时循环引用的处理（句柄机制）。
10. 对象序列化性能调优要点（缓冲、对象重用）。
11. 在分布式系统中如何管理序列化策略（跨服务版本）？
12. 自定义序列化（writeObject/readObject）常见陷阱。
13. 序列化时如何处理类加载器问题？
14. 大对象序列化时的内存与 GC 风险如何降低？
15. 使用序列化作为缓存（Redis/Memcached）时的注意事项。

五、NIO 深入：Buffer / Channel / Selector（76–100）

1. NIO 三大核心（Buffer、Channel、Selector）各自职责是什么？
2. ByteBuffer 的 position / limit / capacity 三指针语义详解。
3. flip(), clear(), rewind(), compact() 各自什么时候用？
4. DirectByteBuffer 与 HeapByteBuffer 的底层差异与性能影响。
5. ByteBuffer 的切片（slice）与只读视图（asReadOnlyBuffer）。
6. Scatter/Gather IO（分散读取/聚集写入）的使用场景与实现。
7. FileChannel 的 position、size、truncate 等方法详解。
8. MappedByteBuffer（内存映射）在 NIO 中如何创建与释放？
9. Channel 与传统 Stream 的区别（阻塞/非阻塞、文件描述符共享）。
10. Selector 的工作流程：注册、选择、取消、keys、selectedKeys。
11. Selector 的底层实现依赖（select/poll/epoll/kqueue）及其影响。
12. 非阻塞 Channel 的 read/write 返回值语义（-1、0、>0）。
13. NIO 中的粘包/拆包问题与常见解决策略（定长/分隔/长度前置）。
14. 如何在 NIO 中实现超时断开和心跳检测？
15. Pipe（管道）在 NIO 中的用途与限制。
16. 多 Selector / 多 Reactor 的线程模型设计要点。
17. ByteBuffer 内存可见性与多线程访问问题（不是线程安全）。
18. 避免 NIO 频繁创建 DirectByteBuffer 的垃圾和内存泄露策略。
19. 使用 Selector 时的遍历与删除 selectedKeys 的正确姿势。
20. NIO 读写循环的高效实现模板。
21. Channel.transferTo/transferFrom 的零拷贝含义与局限。
22. NIO 与 FileChannel 实现文件间高效复制的流程。
23. 使用 NIO 实现高并发服务器时的常见瓶颈。
24. NIO 在 Windows 与 Linux 上的行为差异（可伸缩性影响）。
25. 实战题：实现一个使用 NIO 的简单 echo 服务器（思路要点）。

六、Socket / TCP / UDP / WebSocket（101–140）

1. Socket 的基本概念：端点、三元组/四元组（IP:port + peer）。
2. Java 中 Socket、ServerSocket、DatagramSocket 的主要 API 区别。
3. TCP 与 UDP 的核心差异（可靠性、有序性、连接性）。
4. TCP 三次握手（SYN、SYN-ACK、ACK）与四次挥手流程详解。
5. TIME_WAIT、CLOSE_WAIT、FIN_WAIT1/2 等 TCP 状态含义与产生原因。
6. 半开连接（half-open）是什么，如何检测与恢复？
7. TCP 的流量控制（窗口）与拥塞控制（慢启动、拥塞避免、快重传、快恢复）基础。
8. Nagle 算法（TCP_NODELAY）的原理和在延迟场景下的影响。
9. TCP 延迟确认（delayed ACK）对交互型应用的影响。
10. Socket 选项 SO_TIMEOUT、SO_KEEPALIVE、SO_REUSEADDR、SO_REUSEPORT、SO_LINGER 含义与使用场景。
11. backlog 参数（ServerSocket 构造或 listen）与 accept 队列（syn, accept 队列）区别。
12. ephemeral port（短暂端口）与端口耗尽问题及解决办法。
13. SYN flood 攻击的原理和防护（SYN cookies、firewall）。
14. TCP 快速打开（TCP Fast Open）是什么，有何优劣？（简述）
15. MTU、MSS 与 IP 分片对传输的影响与诊断方法。
16. UDP 的组播（Multicast）与广播（Broadcast）机制与 Java 支持（MulticastSocket）。
17. UDP 丢包、乱序、包大小限制（最佳实践）。
18. UDP 穿透 NAT（STUN/ICE）的基本原理。
19. 如何在 Java 中实现高性能 UDP 服务器？（NIO + DatagramChannel）
20. WebSocket 协议基础（握手、帧格式、ping/pong、close）。
21. Java 实现 WebSocket 的常见库（javax.websocket、Netty websocket、Undertow）。
22. TLS over TCP（HTTPS）的握手流程要点（证书验证、对称密钥协商）。
23. 使用 SSLSocket / SSLServerSocket 和 SSLEngine 的差别及适用场景。
24. SSL/TLS 握手的重用（session resumption）与性能优化。
25. 中间人攻击（MITM）与证书链、CA、信任根的角色。
26. 如何在 Socket 程序中实现心跳、超时与断线重连？
27. TCP Keepalive 与应用层心跳的区别和协同使用。
28. 如何通过抓包（tcpdump/wireshark）诊断 Socket 连接问题？
29. Socket 的非阻塞 accept/read/write 实现注意点（资源/异步安全）。
30. 如何避免 TCP 粘包/拆包在 Socket 原生编程中的影响（流式协议设计）？
31. 实战：实现一个带长度前缀的 TCP 协议的 Java 服务端/客户端（思路）。
32. 如何优雅处理大量短连接的场景？（连接池、HTTP keep-alive）
33. Socket 端口复用（SO_REUSEADDR vs SO_REUSEPORT）在负载均衡中的用法。
34. 多路复用（select/poll/epoll）与 socket 大连接数的处理。
35. 网络字节序（big-endian）与数据编解码注意点。
36. 使用 TCP_NODELAY（禁用 Nagle）时的 CPU/网络 trade-off。
37. 如何在 Java 中做到零拷贝文件传输（Socket + FileChannel.transferTo）？
38. Socket 关闭流程中遇到阻塞（SO_LINGER）的处理办法。
39. 如何防止或检测 “socket half-closed” 的资源泄漏？
40. 实战题：用 BIO、NIO、Netty 各实现一个简易的聊天服务器，比较性能与代码复杂度（思路要点）。

七、异步 IO、IO 模型与高阶模式（141–150）

1. IO 模型分类：同步阻塞、同步非阻塞、IO 多路复用、信号驱动、异步（AIO）。
2. Reactor 模式与 Proactor 模式的原理与区别。
3. Java AIO（AsynchronousChannel、AsynchronousSocketChannel）API 介绍。
4. CompletionHandler 与 Future 风格的异步回调比较。
5. 高并发下选择 NIO 还是 AIO 的实际考量（实现复杂度、平台支持）。
6. 事件驱动系统的 back-pressure 设计（流控、速率限制）。
7. 线程模型设计：acceptors / io workers / business workers 的权衡。
8. RCU、无锁队列在高并发 IO 框架中的应用场景。
9. 如何在应用层实现请求队列与排队策略来缓解突发流量？
10. 实战题：设计一个支持百万连接的服务器架构（核心组件与 IO 策略）。

八、零拷贝、内核与性能调优（151–160）

1. 零拷贝（zero-copy）概念和常见实现（sendfile, mmap, splice）。
2. FileChannel.transferTo/transferFrom 在 Linux 下如何利用 sendfile 实现零拷贝？
3. mmap（内存映射文件）的实现原理与 GC /回收问题。
4. DMA（Direct Memory Access）在零拷贝中的作用与限制。
5. 内核态 / 用户态拷贝次数与零拷贝带来的减少效果。
6. TCP 窗口、拥塞控制调优参数（net.ipv4.tcp_* 系列常见项）。
7. 系统级调优：文件描述符上限（ulimit -n）、somaxconn、backlog、epoll_limits 等。
8. 高并发网络服务的监控指标（fd 使用、accept latency、context switch、cpu steal）。
9. 性能诊断工具与流程：iostat, vmstat, sar, perf, tcpdump, ss, strace。
10. 实战题：如何定位并修复一个高并发服务器的 accept 阻塞 / 连接丢失 问题（诊断步骤）。

如果你愿意，我可以 接着把每一道题写成“面试级详细解析”：每题包含 —— 概念简述 + 原理/底层机制 + 常见面试追问点 + 典型代码/伪代码（若适用） + 常见坑与性能考量。
为了不把单条回复弄得太长，我建议按批次输出解析（例如每批 15–20 题）。

下面我 先示范性地把第 1–10 题写成详细解析，风格如下（概念 + 要点 + 代码/命令 + 面试追问点）。如果你满意这个格式，我会继续按相同风格往下写每批题的解析。

示例：第1–10题 详细解析（示范风格）

1. Java IO 的总体体系结构是什么？

概念
Java IO 可以分为两大类：传统阻塞 IO（java.io）和 NIO（java.nio）。传统 IO 提供字节流（InputStream/OutputStream）、字符流（Reader/Writer）、以及各种装饰器（Buffered、Data、Object 等）。NIO 提供 Buffer、Channel、Selector 及更底层的文件映射（MappedByteBuffer）。

原理 / 要点

• 传统 IO 基于流（Stream）抽象，面向流式、同步、阻塞操作。
• NIO 引入 Buffer（内存块）和 Channel（可读写的端点），支持非阻塞和多路复用（Selector），更适合高并发网络 I/O。
• Java 还有 AIO（Asynchronous IO）作为异步回调风格的补充（java.nio.channels.AsynchronousChannel）。

面试追问点

• 什么时候用阻塞 IO，什么时候用 NIO？
• NIO 能否替代传统 IO？（部分场景：文件流仍然方便）
• AIO 与 NIO 的区别是什么？

2. InputStream / OutputStream 的常见子类有哪些？

要点列举（常见）

• FileInputStream / FileOutputStream（文件字节流）
• ByteArrayInputStream / ByteArrayOutputStream（内存字节流）
• BufferedInputStream / BufferedOutputStream（缓冲）
• DataInputStream / DataOutputStream（按基本类型读写）
• ObjectInputStream / ObjectOutputStream（对象序列化）
• PipedInputStream / PipedOutputStream（管道，用于线程间通信）

面试追问点

• 什么时候使用 Buffered 流？（I/O 较小且频繁时）
• DataOutputStream 写的二进制如何跨平台读？（须约定端序）

3. Reader / Writer 的常见子类有哪些？

要点列举（常见）

• FileReader / FileWriter（字符文件）
• InputStreamReader / OutputStreamWriter（字节流 ↔ 字符流 适配器）
• BufferedReader / BufferedWriter（字符缓冲）
• CharArrayReader / CharArrayWriter（基于字符数组）

面试追问点

• 为什么不用 FileReader 直接读取所有文本？（编码问题）
• InputStreamReader 如何指定编码？

4. 字节流与字符流的本质区别和使用场景？

概念

• 字节流（InputStream/OutputStream）以字节为单位处理数据，适用于二进制数据（图片、音频、视频、压缩包）。
• 字符流（Reader/Writer）以字符为单位，做了字符解码/编码，适合处理文本。字符流基于字符集（charset），内部通常由 InputStreamReader/OutputStreamWriter 做转换。

面试追问点

• 处理 UTF-8 文件时用哪种流？（用字节流 + 指定 InputStreamReader 编码，或者 Files.newBufferedReader(Path, Charset)）
• 字符流会不会丢失数据？（若编码/解码不一致会）

5. 为什么要有缓冲流（BufferedInputStream / BufferedReader）？

要点

• 减少系统调用次数（read 系统调用代价高），提升 I/O 效率。
• 提供按行读取、标记/重置等高级功能（BufferedReader.readLine(), mark/reset）。
• 对小、频繁的读写操作特别有效。

代码示例

1
2
3
4
5
6

try (BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(path), StandardCharsets.UTF_8))) {
    String line;
    while ((line = br.readLine()) != null) {
        // 处理
    }
}

面试追问点

• BufferedInputStream 的默认缓冲区大小是多少？（通常 8KB，但可构造时指定）
• 缓冲流什么时候可能不适合使用？（极低延迟、实时数据场景）

6. flush() 与 close() 的区别与细节（含异常处理）

要点

• flush()：将缓冲区中的数据强制写出到底层流，但流仍然可用。适合在不关闭流的情况下确保数据发送。
• close()：先 flush()，再释放资源（关闭底层描述符），关闭后不能再写入。close() 可能抛出异常，要在 finally 或 try-with-resources 中处理。
• try-with-resources 会自动调用 close，并会将 close 抛出的异常作为 suppressed exception 记录。

面试追问点

• 为什么要显式 flush？（网络协议的即时发送、日志写入保证等）
• close 抛出异常时如何处理 suppressed exception？（在 Java 里可通过 Throwable.getSuppressed() 查看）

7. try-with-resources 的工作原理（AutoCloseable、suppressed exceptions）

要点

• Java 7 引入，任何实现 AutoCloseable 的对象都可以在 try(…) 中声明，try 结束时会自动调用 close()。
• 若 try 块中抛出异常，close 抛出异常会被作为 suppressed 添加到初始异常上，不会覆盖初始异常。
• 编译器把 try-with-resources 翻译为 finally 块并处理 suppressed。

面试追问点

• AutoCloseable 与 Closeable 的区别？（Closeable 的 close() 声明抛 IOException；AutoCloseable 更通用）
• 多个资源按什么顺序关闭？（与声明顺序相反，即后声明先关闭）

8. 装饰器模式在 Java IO 中如何体现？举例链式包装

要点

• Java IO 将基础流包装成更复杂功能的流：例如 new BufferedReader(new InputStreamReader(new FileInputStream(path)))，每一层都是装饰器，扩展了读取能力（缓冲、解码）。
• 装饰器允许在不改变原始类的情况下添加行为，且可任意组合。

面试追问点

• 装饰器带来的缺点？（层级过深可读性差、异常处理复杂）

9. File 类的能力与限制（能否读写数据、元数据操作）

要点

• java.io.File 主要用于表示路径和进行文件/目录的元数据操作（exists, isDirectory, length, renameTo 等），它 不直接读写内容。
• 读写需通过流（FileInputStream/FileOutputStream/FileChannel 等）或 NIO 的 Files 工具类。
• File 的 renameTo 在不同平台上语义不一致（原子性不可保证）。

面试追问点

• Java 7 后 Files / Path 提供哪些增强？（更丰富的原子操作、拷贝、移动、文件属性）

10. RandomAccessFile 的用途、指针机制与并发注意点

要点

• RandomAccessFile 允许在文件中任意位置读取/写入，通过 seek(long pos) 移动文件指针。
• 适合索引文件、实现简单的数据库、文件内插入/覆盖等。
• 不是线程安全的；多个线程共享同一个 RandomAccessFile 需外部同步或为每线程打开独立实例（但会增加文件描述符消耗）。

代码示例

1
2
3
4

try (RandomAccessFile raf = new RandomAccessFile("data.bin", "rw")) {
    raf.seek(1024);
    raf.writeInt(42);
}

面试追问点

• RandomAccessFile 与 FileChannel 的关系？（RandomAccessFile.getChannel() 可获取 Channel；NIO 更现代）

如果这个示例的详细程度和格式符合你的期望，我会接着按相同格式把 第11–30、31–50……分批完整输出，直到把所有 160 题都写成“面试级详解”。我建议每批 15–20 题，这样查阅方便，也便于你随时检索或要求调整深度。

要我继续把接下来的题（11–30）写成详细解析吗？我可以现在开始并把下一批（11–30，共20题）一次性发给你。

当然可以 👍
Java 基础的面试题非常庞杂，我可以帮你继续扩展，补充到更多的维度，甚至超过 200+ 道。之前我给你整理了 150 道，下面我会在原有的基础上，继续补充更多（会覆盖一些面试官经常“刁钻”考的点、源码、陷阱题、实战场景）：

Java 基础面试题（继续扩展）

一、语言特性 & 基础语法

1. Java 中的 == 和 equals() 有什么区别？如何正确重写 equals()？
2. 为什么重写 equals() 时必须重写 hashCode()？不重写会怎样？
3. Object 类有哪些方法？哪些方法经常需要重写？
4. final、finally、finalize() 有什么区别？
5. Java 中的 instanceof 关键字是如何实现的？
6. 接口和抽象类的区别？接口能不能有构造函数？
7. 接口可以多继承吗？抽象类可以实现接口吗？
8. default 方法和 static 方法在接口中的意义是什么？
9. 什么是内部类？分为哪几种？（成员内部类、静态内部类、局部内部类、匿名内部类）
10. 匿名内部类和 Lambda 表达式的区别？

二、数据类型 & 内存

1. Java 中的基本数据类型和包装类型有哪些区别？
2. 为什么 Integer 有缓存机制？范围是多少？
3. 为什么 new Integer(127) == new Integer(127) 为 false，而 Integer.valueOf(127) == Integer.valueOf(127) 为 true？
4. NaN 和 Infinity 在 Java 中如何表示？
5. 为什么浮点数计算有精度问题？如何避免？
6. BigDecimal 为什么能解决浮点数精度问题？
7. Java 中的字符集默认是什么？在不同平台上会不一样吗？
8. String、StringBuilder、StringBuffer 区别？线程安全性？
9. 为什么 String 是不可变的？背后实现细节？
10. intern() 方法的作用是什么？

三、集合框架

1. ArrayList 和 Vector 的区别？
2. 为什么 ArrayList 的扩容是 1.5 倍？
3. LinkedList 是双向链表还是单向链表？
4. HashSet 底层是如何实现的？
5. TreeSet 和 TreeMap 的底层实现是什么？
6. PriorityQueue 的底层数据结构是什么？
7. ConcurrentSkipListMap 的底层原理是什么？
8. CopyOnWriteArrayList 的写时复制是怎么实现的？有什么优缺点？
9. EnumMap 和 EnumSet 是什么？为什么效率高？
10. WeakHashMap 和 HashMap 的区别？

四、异常 & 错误处理

1. Java 中的异常分为哪两大类？
2. Error 和 Exception 的区别？
3. 受检异常和非受检异常区别？
4. throw 和 throws 有什么区别？
5. try-with-resources 的底层原理是什么？
6. 自定义异常如何设计？继承哪个类？
7. 为什么不建议捕获 Throwable？
8. 异常链（Exception Chaining）是什么？
9. Java 8 之后对异常处理有改进吗？
10. 如何在多线程环境下正确传递异常？

五、JVM & 内存管理

1. Java 内存模型（JMM）是什么？
2. JVM 内存分为哪几个区域？每个区域的作用是什么？
3. 为什么 String 常量池要放在堆里而不是方法区？
4. 什么是垃圾回收（GC）的可达性分析算法？
5. 哪些对象可以作为 GC Roots？
6. 强引用、软引用、弱引用、虚引用的区别？
7. GC 有哪些算法？标记-清除、标记-整理、复制算法区别？
8. 常见的垃圾收集器有哪些？G1、ZGC、Shenandoah 有什么特点？
9. 什么是 Stop-The-World (STW)？
10. JVM 调优常见参数有哪些？

六、并发编程基础

1. Java 中的 volatile 关键字的底层实现原理？
2. synchronized 的实现原理？对象头和 Monitor 是什么？
3. 偏向锁、轻量级锁、重量级锁的区别？
4. 什么是 CAS 操作？ABA 问题如何解决？
5. 什么是线程安全？举例哪些类是线程安全的？
6. ThreadLocal 的底层原理是什么？为什么会有内存泄漏问题？
7. 线程池的核心参数有哪些？
8. 什么是拒绝策略？
9. Executors 提供的几种常见线程池？
10. Future 和 CompletableFuture 区别？

七、编译 & 运行时

1. Java 的反射机制是什么？底层原理？
2. 为什么反射性能差？JDK 9 之后如何优化？
3. 什么是动态代理？JDK 动态代理和 CGLIB 区别？
4. 注解的底层原理是什么？运行时注解如何实现？
5. ClassLoader 的双亲委派模型是什么？
6. 如何打破双亲委派？
7. 什么是 SPI（Service Provider Interface）机制？
8. Java 是如何实现跨平台的？
9. JIT（即时编译器）优化了哪些东西？
10. 什么是逃逸分析？

八、常见场景 & 设计

1. 单例模式在 Java 中有哪些实现方式？哪种最优？
2. 懒汉模式和饿汉模式的区别？
3. 枚举单例为什么是最佳实践？
4. 为什么要用工厂模式？
5. 装饰器模式和代理模式区别？
6. Java 中的事件监听模型是怎么实现的？
7. 为什么 Java 不支持多继承？
8. 如何用 Java 实现回调机制？
9. Java 中如何实现观察者模式？
10. Optional 的设计初衷是什么？

二、Java 并发编程（30题）

1. 线程的生命周期？
2. 创建线程的方式有哪些？
3. Runnable 和 Callable 的区别？
4. Future 和 CompletableFuture 的区别？
5. ThreadLocal 原理？
6. synchronized 的锁优化机制？
7. ReentrantLock 的实现原理？
8. 公平锁和非公平锁区别？
9. 乐观锁和悲观锁区别？
10. AQS 原理？
11. CountDownLatch 和 CyclicBarrier 区别？
12. Semaphore 的实现原理？
13. Exchanger 的使用场景？
14. ForkJoinPool 的原理？
15. CAS 操作的底层实现？
16. ABA 问题是什么？如何解决？
17. Atomic 原子类的原理？
18. BlockingQueue 的实现原理？
19. ConcurrentHashMap 的分段锁机制？
20. ConcurrentHashMap 扩容机制？
21. CopyOnWriteArrayList 的原理？
22. 线程池的核心参数？
23. 线程池的拒绝策略？
24. 线程池的工作流程？
25. ThreadPoolExecutor 和 ScheduledThreadPoolExecutor 的区别？
26. 为什么不建议使用 Executors 创建线程池？
27. JMM 内存可见性问题？
28. happens-before 规则？
29. 死锁产生的条件？如何避免？
30. 常见并发容器有哪些？区别？

三、JVM 与性能优化（30题）

1. JVM 内存结构？
2. 堆和栈的区别？
3. 新生代、老年代、永久代（元空间）的区别？
4. 对象的创建过程？
5. 对象的内存分配策略？
6. GC Roots 有哪些？
7. 垃圾回收算法有哪些？
8. CMS 垃圾回收器的工作流程？
9. G1 垃圾回收器原理？
10. ZGC 和 Shenandoah 的特点？
11. Minor GC 和 Full GC 的区别？
12. OOM 常见类型？如何排查？
13. 类加载器的分类？
14. 双亲委派模型的破坏场景？
15. JVM 常见参数调优？
16. 内存泄漏和内存溢出的区别？
17. 逃逸分析是什么？
18. 方法内联的原理？
19. JIT 编译器的优化？
20. Safepoint 机制？
21. Stop The World 是什么？
22. Finalize 方法的问题？
23. JVM 如何判断对象可回收？
24. TLAB 的作用？
25. Direct Memory 为什么会 OOM？
26. Metaspace 的作用？
27. Full GC 触发条件？
28. 如何查看 JVM 内存使用情况？
29. Arthas 常用命令？
30. JVM 调优常见面试题？

四、Spring & Spring Boot（30题）

1. Spring 的 IoC 容器原理？
2. Bean 的生命周期？
3. BeanFactory 和 ApplicationContext 的区别？
4. 单例 Bean 如何保证线程安全？
5. Spring AOP 的实现原理？
6. JDK 动态代理和 CGLIB 的区别？
7. Spring 事务的传播机制？
8. Spring 事务的隔离级别？
9. @Transactional 的实现原理？
10. 循环依赖如何解决？
11. Spring 的三级缓存解决了什么问题？
12. Spring MVC 的工作流程？
13. DispatcherServlet 的作用？
14. Spring Boot 的自动装配原理？
15. Spring Boot Starter 的机制？
16. @ConfigurationProperties 和 @Value 的区别？
17. Spring Boot 如何实现热部署？
18. Spring Boot 如何处理配置文件？
19. @Conditional 注解的作用？
20. Spring Boot 常见的优化点？
21. Spring 中的事件机制？
22. ApplicationListener 的使用？
23. Spring 如何加载配置文件？
24. Bean 的作用域有哪些？
25. Spring 如何实现异步调用？
26. Spring 中的 @Lazy 注解？
27. Spring 的资源加载机制？
28. Spring Boot 的内嵌容器有哪些？
29. Spring Boot Actuator 的作用？
30. Spring Boot 如何与 Docker/K8s 结合？

五、Spring Cloud（30题）

1. Spring Cloud 是什么？
2. Spring Cloud 和 Dubbo 的区别？
3. Eureka 的工作原理？
4. Eureka 的自我保护机制？
5. Ribbon 的负载均衡策略？
6. Ribbon 和 Nginx 的区别？
7. Feign 的工作原理？
8. Feign 如何支持熔断？
9. Hystrix 的工作原理？
10. Hystrix 的线程池隔离和信号量隔离？
11. Resilience4j 和 Hystrix 区别？
12. Gateway 的核心功能？
13. Gateway 和 Zuul 的区别？
14. Config Server 的作用？
15. Config Server 如何保证配置实时刷新？
16. Spring Cloud Bus 的原理？
17. Sleuth 的作用？
18. Sleuth 与 Zipkin 的关系？
19. 分布式链路追踪的原理？
20. Spring Cloud Stream 的作用？
21. 消息驱动模型和事件驱动模型区别？
22. Nacos 和 Eureka 的区别？
23. Nacos 配置中心和注册中心的实现原理？
24. Sentinel 的工作原理？
25. 限流的常见算法（令牌桶、漏桶）？
26. 熔断和降级的区别？
27. CAP 定理和 Spring Cloud 的关系？
28. Spring Cloud 与 Kubernetes 的关系？
29. 微服务中的灰度发布？
30. Spring Cloud 如何实现服务网格？

六、微服务架构 & 分布式系统（30题）

1. 什么是微服务？
2. 微服务与 SOA 的区别？
3. 微服务的优缺点？
4. 微服务的拆分原则？
5. 如何保证微服务之间的数据一致性？
6. 分布式事务有哪些解决方案？
7. TCC、SAGA、XA 的区别？
8. 本地消息表和可靠消息最终一致性？
9. 分布式锁的实现方式？
10. Redis 分布式锁的缺陷？
11. Zookeeper 分布式锁的实现？
12. 数据库分库分表策略？
13. 水平拆分与垂直拆分区别？
14. 分布式 ID 生成方案？
15. 雪花算法的原理？
16. API 网关的作用？
17. 服务注册与发现机制？
18. 微服务如何保证高可用？
19. 微服务中的限流和熔断？
20. 微服务如何保证安全性？
21. OAuth2 的原理？
22. JWT 的作用？
23. 单点登录 SSO 的实现？
24. 配置中心的作用？
25. 微服务中的监控体系？
26. Prometheus 的原理？
27. ELK 在微服务中的应用？
28. 服务调用链路追踪的意义？
29. 服务雪崩效应是什么？
30. 如何设计一个高并发的微服务系统？

七、数据库 & 缓存（30题）

1. MySQL 的存储引擎区别？
2. InnoDB 和 MyISAM 的区别？
3. MySQL 的事务特性？
4. MVCC 的实现原理？
5. MySQL 的索引类型？
6. 聚簇索引和非聚簇索引？
7. B+ 树索引原理？
8. 覆盖索引和回表？
9. 索引下推优化？
10. MySQL 的锁机制？
11. 行锁和表锁区别？
12. 间隙锁是什么？
13. 死锁的排查方法？
14. SQL 执行计划如何分析？
15. 慢查询优化方法？
16. 数据库分库分表的难点？
17. 分布式事务如何保证？
18. Redis 的数据结构？
19. Redis 为什么快？
20. Redis 的持久化机制？
21. Redis 的过期策略？
22. Redis 的内存淘汰机制？
23. Redis 的主从复制原理？
24. Redis 的哨兵机制？
25. Redis 的集群模式？
26. Redis 的分布式锁实现？
27. Redis 的常见问题？
28. 缓存穿透、击穿、雪崩？
29. 如何保证缓存和数据库一致性？
30. Redis 和本地缓存 Caffeine 的区别？

八、消息队列（30题）

1. 为什么要使用消息队列？
2. 消息队列的优缺点？
3. RabbitMQ 的核心组件？
4. RabbitMQ 的消息确认机制？
5. Kafka 的核心概念？
6. Kafka 的分区机制？
7. Kafka 的副本机制？
8. Kafka 的 ISR 原理？
9. Kafka 的消费组原理？
10. Kafka 的 offset 提交方式？
11. Kafka 的高吞吐量原理？
12. Kafka 的零拷贝机制？
13. RocketMQ 的核心特点？
14. RocketMQ 的顺序消息？
15. RocketMQ 的事务消息？
16. 如何保证消息不丢失？
17. 如何保证消息不重复消费？
18. 如何保证消息有序？
19. 消息堆积的解决办法？
20. 如何设计延迟队列？
21. 死信队列的作用？
22. 幂等性的实现方式？
23. 消息队列的限流方式？
24. 消息队列的监控？
25. Kafka 和 RabbitMQ 的区别？
26. Kafka 和 RocketMQ 的区别？
27. Pulsar 的特点？
28. 消息中间件如何保证高可用？
29. 消息队列如何做水平扩展？
30. 消息队列和事件总线的区别？

九、DevOps & 容器化（30题）

1. CI/CD 的流程？
2. Jenkins 的作用？
3. Docker 的核心原理？
4. Docker 镜像和容器的区别？
5. Dockerfile 的常见指令？
6. 镜像分层机制？
7. 容器与虚拟机的区别？
8. Kubernetes 的核心组件？
9. Pod 的生命周期？
10. Deployment 和 StatefulSet 区别？
11. K8s 的服务发现机制？
12. ConfigMap 和 Secret 的区别？
13. Ingress 的作用？
14. K8s 的水平扩缩容机制？
15. K8s 的滚动更新机制？
16. K8s 如何做灰度发布？
17. K8s 的调度策略？
18. K8s 的网络模型？
19. Service Mesh 的作用？
20. Istio 的工作原理？
21. Helm 的作用？
22. K8s 的存储方案？
23. Prometheus 的监控体系？
24. Grafana 的作用？
25. K8s 的安全机制？
26. 容器的资源限制？
27. Docker Compose 的作用？
28. DevOps 的最佳实践？
29. GitOps 的理念？
30. K8s 如何保证高可用？

十、场景设计题（30题）

1. 如何设计一个秒杀系统？
2. 如何设计一个短链系统？
3. 如何设计一个分布式 ID 生成系统？
4. 如何设计一个高可用缓存系统？
5. 如何设计一个订单系统？
6. 如何设计一个支付系统？
7. 如何设计一个消息推送系统？
8. 如何设计一个日志收集系统？
9. 如何设计一个搜索引擎？
10. 如何设计一个推荐系统？
11. 如何设计一个分布式锁？
12. 如何设计一个统一鉴权系统？
13. 如何设计一个限流系统？
14. 如何设计一个灰度发布系统？
15. 如何设计一个电商购物车？
16. 如何设计一个库存系统？
17. 如何设计一个分布式文件存储系统？
18. 如何设计一个微服务网关？
19. 如何设计一个分布式任务调度系统？
20. 如何设计一个监控报警系统？
21. 如何设计一个高并发聊天室？
22. 如何设计一个排行榜系统？
23. 如何设计一个评论系统？
24. 如何设计一个分布式事务系统？
25. 如何设计一个高可用注册中心？
26. 如何设计一个数据同步系统？
27. 如何设计一个 API 限速系统？
28. 如何设计一个高可用的支付网关？
29. 如何设计一个跨境电商架构？
30. 如何设计一个金融级别的微服务系统？

Java基础

1. 问题: 请详细解释Java的垃圾回收（GC）机制，以及你了解的垃圾回收算法和GC收集器。

   答案: Java的垃圾回收是自动内存管理机制，它负责自动回收不再使用的对象所占用的内存。我理解的GC主要为了避免内存泄漏和OutOfMemoryError。常见的垃圾回收算法包括：

   • 标记-清除（Mark-Sweep）算法: 标记出所有需要回收的对象，然后清除。缺点是会产生大量不连续的内存碎片。

   • 复制（Copying）算法: 将内存分为两块，每次只使用其中一块。当这块用完了，就将存活的对象复制到另一块上，然后清空已使用的那块。缺点是内存利用率只有一半。

   • 标记-整理（Mark-Compact）算法: 标记出所有存活的对象，然后将所有存活的对象向一端移动，最后清理掉边界以外的内存。解决了内存碎片问题。

   • 分代收集（Generational Collection）算法: 将堆内存分为新生代和老年代。新生代中的对象生命周期短，使用复制算法。老年代中的对象生命周期长，使用标记-整理算法。

     我了解的GC收集器包括：Serial、Parallel、CMS、G1等。G1收集器是一种面向服务器的垃圾收集器，它将堆内存划分为多个大小相等的区域，可以并行和并发地进行垃圾回收，并且可以预测GC暂停时间。

2. 问题: 描述一下ArrayList和LinkedList的底层实现原理和各自的优缺点及适用场景。

   答案:

   • ArrayList: 底层是基于动态数组实现的。它支持快速随机访问，因为可以通过索引直接访问元素。但当添加或删除元素时，需要移动数组中的其他元素，特别是当数组容量不足时，需要进行扩容操作，效率较低。因此，ArrayList适用于随机访问频繁的场景。
   • LinkedList: 底层是基于双向链表实现的。每个节点都包含数据、指向前一个节点的引用和指向后一个节点的引用。由于是链式存储，添加和删除元素只需要修改节点的引用，效率很高。但是，随机访问需要从头或尾遍历，效率较低。因此，LinkedList适用于插入和删除操作频繁的场景。

3. 问题: HashMap的底层数据结构是什么？它是如何工作的？在Java 8中，它有哪些改进？

   答案: HashMap的底层数据结构是数组加链表，在Java 8及以后版本是数组加链表加红黑树。

   • 工作原理: HashMap通过键的hashCode()方法计算哈希值，然后将键值对存储在对应的数组索引位置。当哈希冲突发生时，HashMap采用“链地址法”解决，即将冲突的键值对连接成一个链表。
   • Java 8的改进: 为了解决链表过长导致的查询效率降低问题，当链表长度超过8，且数组长度超过64时，HashMap会将链表转换为红黑树，将O(n)的查询复杂度优化为O(log n)。当红黑树的节点数量少于6时，又会退化为链表。

4. 问题: 请详细解释ThreadLocal的原理，以及它在多线程环境下如何实现线程隔离？它是否存在内存泄漏问题？

   答案: ThreadLocal为每个线程提供一个独立的变量副本，从而实现线程隔离。它的原理是，每个Thread对象内部都有一个ThreadLocalMap，键是ThreadLocal对象本身，值是我们要存储的变量。当一个线程调用ThreadLocal.set()方法时，它会将变量存储在自己的ThreadLocalMap中，其他线程无法访问，从而实现了线程隔离 。

   ThreadLocalMap中的键是ThreadLocal对象的弱引用，这意味着当ThreadLocal对象没有其他强引用时，即使ThreadLocalMap中还存在弱引用，垃圾回收器也会回收该ThreadLocal对象。但此时ThreadLocalMap中键为null的值还存在，这就可能导致内存泄漏。为了避免这个问题，我们应该在使用完ThreadLocal后，手动调用remove()方法来清除变量。

5. 问题: 什么是Java中的锁？请详细阐述synchronized和ReentrantLock的区别。

   答案: Java中的锁是用于控制多线程对共享资源访问的机制，以确保线程安全。

   • synchronized: 是Java内置的悲观锁，通过monitorenter和monitorexit指令实现。它是非公平锁，并且是可重入的。它的优点是使用简单，无需手动加锁和解锁，由JVM自动管理。缺点是，它是一个重量级锁，性能相对较低，并且不支持中断、超时等高级功能。
   • ReentrantLock: 是java.util.concurrent包下的一个类，它提供了与synchronized类似的功能，但更加灵活。它可以通过构造函数选择是公平锁还是非公平锁，并且支持可中断锁、限时锁等高级功能。使用时需要手动调用lock()和unlock()方法，unlock()必须放在finally块中以确保锁的释放。在性能方面，ReentrantLock在竞争激烈时通常优于synchronized。

6. 问题: 谈谈你对Java多线程的理解，以及创建多线程的几种方式的优劣。

   答案: 多线程允许程序同时执行多个任务，提高程序的并发性和响应速度 。

   • 继承Thread类: 优点是简单直接，但缺点是Java不支持多重继承，如果继承了Thread类，就不能再继承其他类了。
   • 实现Runnable接口: 优点是更灵活，可以避免单继承的限制，并且可以实现资源的共享。这是最常用的方式。
   • 实现Callable接口: 优点是可以有返回值，并且可以抛出异常。通常与线程池结合使用，通过Future对象获取返回值。

7. 问题: 解释一下Java中的volatile关键字，它的作用是什么？它能保证原子性吗？

   答案: volatile关键字用于修饰变量，它能保证变量在多线程之间的可见性，但不能保证原子性。

   • 可见性: 当一个线程修改了volatile变量的值，新值会立即被刷新到主内存，并且其他线程在读取该变量时，会从主内存中读取最新值。
   • 原子性: volatile不能保证对变量的操作是原子性的。例如，i++不是原子操作，它包含了读取、加1、写入三个步骤，在多线程环境下，仍然可能出现问题。
   • happens-before原则: volatile还具有happens-before原则，即对一个volatile变量的写操作，happens-before后续对该变量的读操作。

8. 问题: 描述一下Java中的异常处理机制。try-catch-finally、throw、throws分别有什么作用？

   答案: Java的异常处理机制通过try-catch-finally、throw、throws等关键字来实现。

   • try-catch-finally: try块中放置可能抛出异常的代码。如果try块中的代码抛出异常，catch块会捕获并处理该异常。finally块中的代码无论是否发生异常都会被执行，通常用于释放资源。
   • throw: 用于在程序中手动抛出一个异常对象。
   • throws: 用于在方法签名中声明该方法可能抛出的异常，告诉调用者需要处理这些异常。

9. 问题: 谈谈你对Java泛型的理解，以及泛型中的通配符?、? extends T、? super T的区别。

   答案: Java泛型是在编译时检查类型安全，并在运行时实现类型擦除的一种机制。它允许我们在编写代码时使用类型参数，从而提高代码的复用性和安全性。

   • ?: 无界通配符，表示可以匹配任何类型。
   • ? extends T: 上界通配符，表示可以匹配T及其子类。它只能用于读取，不能用于写入。
   • ? super T: 下界通配符，表示可以匹配T及其父类。它只能用于写入，不能用于读取。

10. 问题: 解释一下Java中的transient关键字的作用，以及它在对象序列化中的应用。

答案: transient关键字用于修饰类的成员变量，它告诉JVM在对象序列化时，忽略被transient修饰的变量。当对象被反序列化时，transient变量的值将被赋予其类型的默认值（如int为0，String为null）。

Spring框架

1. 问题: 请详细解释Spring IoC（控制反转）的原理和实现方式，以及DI（依赖注入）与IoC的关系。

   答案: IoC是一种设计思想，它将对象的创建和依赖关系的控制权从程序本身反转交给Spring容器 3。IoC的实现方式主要是依赖注入（DI）。

   • 依赖注入: DI是IoC的具体实现，它指的是Spring容器在运行时，自动将对象所依赖的其他对象注入到该对象中。我们不需要手动创建依赖对象，而是通过@Autowired等注解或XML配置，让Spring容器来完成。
   • 关系: DI是IoC的一种实现方式，IoC是DI的设计思想。

2. 问题: 描述一下Spring AOP（面向切面编程）的原理，以及你了解的Joinpoint、Pointcut、Advice、Aspect等核心概念。

   答案: AOP是一种编程范式，它允许开发者在不修改原有代码的情况下，通过切面（Aspect）的方式，在程序的特定连接点（Joinpoint）上插入额外的逻辑。

   • Joinpoint: 连接点，表示程序执行过程中可以插入切面的点，例如方法的调用、异常的抛出等。
   • Pointcut: 切入点，是对Joinpoint的正则表达式匹配，用于确定在哪些Joinpoint上应用Advice。
   • Advice: 通知，定义了在特定Pointcut上要执行的动作，如@Before、@After、@Around等。
   • Aspect: 切面，是Pointcut和Advice的组合，包含了横切关注点和如何将其应用到连接点的逻辑。

3. 问题: 你在简历中提到了Spring的三级缓存机制，请详细描述它是如何解决循环依赖问题的，并解释为什么需要三级缓存而不是一、二级缓存就够了。

   答案: Spring的三级缓存机制用于解决单例模式下的循环依赖问题。它包括：

   • 一级缓存（singletonObjects）：存放完全初始化好的单例对象。
   • 二级缓存（earlySingletonObjects）：存放提前暴露的单例对象，但未进行属性填充。
   • 三级缓存（singletonFactories）：存放ObjectFactory，用于生成代理对象。
   • 解决过程: 当A依赖B，B依赖A时，Spring会先创建A的实例，并将一个ObjectFactory放入三级缓存中。当创建B时，发现B依赖A，会从三级缓存中获取ObjectFactory并创建A的代理对象，注入给B。B创建完成后，将其放入一级缓存。然后Spring再回到A的创建过程，注入B，最后将A放入一级缓存，从而解决了循环依赖。
   • 为什么需要三级缓存: 如果只有二级缓存，只能解决A->B->A的循环依赖，但无法解决A->B->A中A需要被代理的情况。三级缓存中的ObjectFactory可以在需要时生成代理对象，从而在不影响正常对象创建流程的情况下，解决代理对象带来的循环依赖问题。

4. 问题: 详细描述Spring MVC的工作流程，并解释DispatcherServlet在其中的作用。

   答案: Spring MVC的工作流程大致是：

   1. 用户发送请求。

   2. DispatcherServlet接收所有请求，作为前端控制器 5。

   3. DispatcherServlet根据请求找到对应的HandlerMapping。

   4. HandlerMapping找到对应的Controller。

   5. Controller调用Service层处理业务逻辑 6。

   6. Service层返回结果给Controller。

   7. Controller返回ModelAndView给DispatcherServlet 7。

   8. DispatcherServlet根据ModelAndView找到对应的ViewResolver。

   9. ViewResolver返回View。

   10. View将结果渲染后返回给用户。

   DispatcherServlet是整个流程的核心，它负责接收请求、分发请求、协调各个组件的工作，是整个Spring MVC框架的中心。

5. 问题: 请详细解释Spring Boot的自动配置原理，以及你了解的常用注解。

   答案: Spring Boot的自动配置是通过@EnableAutoConfiguration注解实现的。它会根据项目的classpath中的依赖，自动配置相应的Bean 8。

   • 原理: @EnableAutoConfiguration注解会扫描META-INF/spring.factories文件，找到EnableAutoConfiguration接口的所有实现类，然后根据这些实现类，结合@Conditional注解，判断是否满足条件，如果满足，则自动配置相应的Bean。
   • 常用注解: @SpringBootApplication（包含了@Configuration、@EnableAutoConfiguration、@ComponentScan）、@RestController、@RequestMapping、@Autowired等。

6. 问题: 描述一下Spring的声明式事务管理，以及它是如何通过AOP实现的。

   答案: 声明式事务管理是通过AOP实现的。开发者只需要使用@Transactional注解，Spring就会在方法的执行前后自动开启和提交/回滚事务，无需手动编写事务管理代码。

   • 实现原理: Spring在启动时，会通过AOP为带有@Transactional注解的方法生成代理对象。当调用这些方法时，代理对象会在方法执行前开启事务，如果方法正常执行，则提交事务；如果方法抛出异常，则回滚事务。

7. 问题: 谈谈你对Spring Cloud的理解，以及你简历中提到的服务注册、负载均衡和熔断降级。

   答案: Spring Cloud是一套基于Spring Boot的微服务框架 10。

   • 服务注册: 每个微服务在启动时会向注册中心（如Eureka）注册自己的信息，包括服务名称、IP地址、端口号等，以便其他服务能够发现它 11。

   • 负载均衡: 当一个服务有多个实例时，Spring Cloud会使用负载均衡器（如Ribbon）将请求分发到不同的实例上，以达到负载均衡的效果。它支持多种负载均衡策略，如轮询、随机等 12。

   • 熔断降级: 当某个服务调用失败次数达到阈值时，熔断机制（如Hystrix）会阻止对该服务的进一步调用，并返回一个预设的默认值（降级），避免整个系统因一个服务的故障而崩溃 13。

8. 问题: 描述一下Spring IoC容器管理Bean的生命周期。

   答案: Spring IoC容器管理Bean的生命周期包括：

   1. 实例化: 容器根据配置创建Bean实例。
   2. 属性注入: 容器注入Bean的依赖。
   3. 初始化: 调用Bean的初始化方法（如@PostConstruct注解修饰的方法）。
   4. 使用: Bean可以被程序使用。
   5. 销毁: 容器关闭时，调用Bean的销毁方法（如@PreDestroy注解修饰的方法）。

9. 问题: 解释一下@Controller、@RestController、@Service、@Repository注解的区别。

   答案:

   • @Controller: 用于标识Controller层，通常与@RequestMapping结合使用，返回ModelAndView或视图名称。
   • @RestController: 是@Controller和@ResponseBody的组合注解。用于标识Controller层，并自动将返回值序列化为JSON或XML格式，通常用于开发RESTful风格的API。
   • @Service: 用于标识Service层，处理业务逻辑。
   • @Repository: 用于标识Dao层，用于数据库访问。

10. 问题: 在你的项目中，如何处理Spring中的事务传播行为？请举例说明。

答案: 在Spring中，我可以通过@Transactional注解的propagation属性来控制事务的传播行为。

• Propagation.REQUIRED: 如果当前没有事务，就创建一个新事务；如果当前有事务，就加入到这个事务中。这是默认的传播行为。

• Propagation.REQUIRES_NEW: 总是创建一个新事务，如果当前存在事务，就将当前事务挂起。

• Propagation.SUPPORTS: 如果当前有事务，就加入到这个事务中；如果没有，就以非事务方式执行。

  例如，在Service层的方法上加上@Transactional(propagation = Propagation.REQUIRES_NEW)，可以确保该方法总是在一个新事务中执行。

数据库

1. 问题: 解释一下数据库事务的ACID特性，并描述每种特性在数据库中的作用。

   答案: 数据库事务的ACID特性是指：

   • 原子性（Atomicity）: 事务是一个不可分割的工作单位，要么全部执行成功，要么全部失败。
   • 一致性（Consistency）: 事务执行前后，数据库从一个一致性状态变为另一个一致性状态。
   • 隔离性（Isolation）: 多个事务并发执行时，一个事务的执行不应被其他事务干扰。
   • 持久性（Durability）: 事务提交后，对数据库的修改是永久性的，即使系统崩溃，也不会丢失。

2. 问题: 你熟悉MySQL数据库，能详细解释一下InnoDB和MyISAM存储引擎的区别和各自的适用场景吗？

   **答案:**我熟悉InnoDB和MyISAM存储引擎。

   • InnoDB:
     • 事务: 支持事务，符合ACID特性。
     • 锁: 支持行级锁，并发性能高。
     • 外键: 支持外键约束。
     • 适用场景: 适用于对数据完整性和并发性要求较高的OLTP（在线事务处理）应用。
   • MyISAM:
     • 事务: 不支持事务。
     • 锁: 只支持表级锁，并发性能差。
     • 外键: 不支持外键约束。
     • 适用场景: 适用于只读或以插入操作为主的OLAP（在线分析处理）应用。

3. 问题: 描述一下数据库的四种隔离级别，以及它们各自解决了什么问题，又带来了什么问题。

   答案: 数据库的四种隔离级别从低到高分别是：

   • 读未提交（Read Uncommitted）: 允许一个事务读取另一个事务未提交的数据。会带来脏读、不可重复读、幻读问题。
   • 读已提交（Read Committed）: 只允许一个事务读取另一个事务已提交的数据。解决了脏读问题，但会带来不可重复读、幻读问题。
   • 可重复读（Repeatable Read）: 保证一个事务在多次读取同一数据时，结果始终一致。解决了脏读、不可重复读问题，但会带来幻读问题。这是MySQL的默认隔离级别。
   • 串行化（Serializable）: 强制事务串行执行。解决了所有并发问题，但并发性能极低。

4. 问题: 谈谈你对数据库索引的理解，以及B树和B+树的区别。

   答案: 索引是一种数据结构，可以帮助数据库快速查找数据，从而提高查询性能。

   • B树（B-Tree）: 是一种多路平衡查找树，每个节点都包含键和值，并且子节点数量多于2个。它适用于数据库索引，因为可以减少磁盘I/O次数。
   • B+树（B+Tree）: 是B树的变种，它只在叶子节点存储数据，所有叶子节点构成一个有序链表。非叶子节点只存储键，不存储值。
   • 区别: B+树的查询效率更高，因为它只需要遍历到叶子节点就能找到所有数据。同时，B+树的叶子节点构成的有序链表，使得范围查询更加高效。

5. 问题: 在你的项目中，如何实现数据库分库分表？它解决了什么问题？

   答案: 在prism vision短剧平台项目中，我根据模块不同进行了分库分表 16。

   • 实现方式: 我使用了ShardingSphere或Mycat等中间件，根据业务需求，将用户数据、短剧内容数据分别存放在不同的库中，再对每个库中的表进行水平切分。

   • 解决问题: 分库分表解决了数据库单库单表的性能瓶颈，提高了数据库的并发处理能力和系统性能，降低了服务器压力 17。它还能避免单点故障，提高系统的可用性。

6. 问题: MyBatis作为持久层框架，它的动态SQL是如何实现的？请举例说明。

   答案: MyBatis的动态SQL是通过XML映射文件中的标签实现的，如<if>、<choose>、<when>、<otherwise>、<foreach>等 18。

   • 举例:

     1 2 3 4 5 6 7 8 9 10 11

     <select id="findUserByCondition" resultType="User"> SELECT * FROM user <where> <if test="id != null"> AND id = #{id} </if> <if test="name != null"> AND name LIKE concat('%', #{name}, '%') </if> </where> </select>

   这段代码会根据传入的参数是否为空，动态地生成不同的SQL语句，避免了手动拼接SQL字符串的麻烦。

7. 问题: 解释一下Redis的持久化机制，以及你了解的两种持久化方式的优缺点。

   答案: Redis的持久化机制是将内存中的数据保存到磁盘上，以防止数据丢失。主要有两种方式：

   • RDB（Redis Database）: RDB是快照持久化，它会在指定的时间间隔内将内存中的数据生成一个快照文件，保存到磁盘上。
     • 优点: 占用空间小，恢复速度快。
     • 缺点: 如果Redis宕机，可能会丢失最后一次快照之后的数据。
   • AOF（Append Only File）: AOF是增量持久化，它会将所有写操作命令以追加的方式保存到文件中。
     • 优点: 数据安全性高，可以通过aof-rewrite命令压缩文件。
     • 缺点: 文件体积大，恢复速度慢。

8. 问题: 在你的prism vision项目中，你使用Redis作为分布式缓存，能具体谈谈它的作用以及如何提升系统性能？

   答案: 在prism vision项目中，我使用Redis作为分布式缓存，主要作用是缓存热门短剧信息、用户数据等。

   • 作用: 当用户请求这些数据时，系统首先从Redis中查找，如果命中则直接返回，避免了对数据库的频繁访问，从而大大提升了系统响应速度和并发能力。

   • 提升性能: Redis是内存数据库，读写速度远超磁盘数据库。通过将热点数据存放在Redis中，可以有效减轻数据库的压力，提高系统的吞吐量和并发能力。

9. 问题: 描述一下Redis的分布式锁如何实现，以及在实现过程中需要注意哪些问题？

   答案: Redis的分布式锁可以通过SETNX（SET if Not eXists）命令来实现。

   • 实现步骤:
     1. 客户端A尝试使用SETNX lock_key my_unique_id命令获取锁。
     2. 如果返回1，表示获取锁成功，并设置锁的过期时间。
     3. 如果返回0，表示获取锁失败，客户端A需要重试。
   • 注意事项:
     1. 死锁问题: 如果客户端A在获取锁后宕机，锁将永远无法释放。因此，必须为锁设置过期时间。
     2. SETNX和EXPIRE的非原子性: 如果在执行SETNX后，EXPIRE之前宕机，仍会发生死锁。因此，需要使用Redis 2.6.12版本以上提供的SET key value [EX seconds]命令，将SETNX和EXPIRE合并成一个原子操作。
     3. 误删锁问题: 如果客户端A获取锁后，因业务处理时间过长，导致锁过期被释放，客户端B获取了锁。此时客户端A处理完成，调用DEL命令删除锁，就会误删客户端B的锁。因此，需要在value中存储一个唯一的ID，在删除锁时进行校验。

10. 问题: 谈谈你对MySQL慢查询日志的理解，以及如何使用它进行数据库性能优化。

答案: MySQL慢查询日志记录了所有执行时间超过long_query_time阈值的SQL语句。

• 作用: 通过分析慢查询日志，可以找出性能瓶颈所在的SQL语句，然后针对性地进行优化。
• 优化步骤:
  1. 开启慢查询日志: 在my.cnf中配置slow_query_log=1和long_query_time=1。
  2. 分析日志: 使用mysqldumpslow或pt-query-digest等工具分析慢查询日志。
  3. 优化SQL:
     • 为WHERE、ORDER BY、GROUP BY子句中的字段创建索引。
     • 避免在WHERE子句中使用OR、!=、LIKE '%xxx%'等操作符。
     • 避免全表扫描。
     • 使用EXPLAIN分析SQL语句的执行计划。
     • 优化表结构和数据类型。

项目经验

1. 问题: 在你的prism vision短剧平台项目中，你是如何实现JWT认证和双令牌刷新策略的？

   答案: 在prism vision项目中，我使用JWT（JSON Web Token）实现了用户认证。

   • 认证流程: 用户登录成功后，我会生成一个access token和一个refresh token。access token用于访问受保护资源，并设置较短的过期时间（如15分钟）。refresh token用于刷新access token，并设置较长的过期时间（如7天）。

   • 双令牌刷新: 当access token过期后，客户端会使用refresh token向认证服务器请求新的access token。服务器验证refresh token的有效性，如果有效，则生成新的access token和refresh token返回给客户端，从而实现了无感刷新和系统安全。

2. 问题: 描述一下prism vision短剧平台中的RBAC权限控制是如何实现的？

   答案: 在prism vision项目中，我基于RBAC（Role-Based Access Control）模型实现了权限控制 22。

   • 实现模型: 我定义了用户、角色、权限三个实体，并建立了它们之间的关联关系。一个用户可以拥有一个或多个角色，一个角色可以拥有一个或多个权限。
   • 权限校验: 在用户访问资源时，我会通过拦截器或AOP，检查用户是否拥有对应的角色和权限，从而实现精细的权限控制。

3. 问题: 你在prism vision项目中使用了雪花算法生成用户ID，能详细解释一下雪花算法的原理吗？

   答案: 雪花算法是一种分布式ID生成算法，它生成的ID是一个64位的长整型 23。

   • ID构成:

     • 1位：符号位，永远为0。
     • 41位：时间戳，精确到毫秒，可以支持69年。
     • 10位：工作机器ID，可以支持1024台机器。
     • 12位：序列号，用于在同一毫秒内生成不同的ID，可以支持每毫秒生成4096个ID。

   • 优点: 生成的ID是全局唯一且趋势递增的，可以用于数据库主键，避免了ID冲突和数据页分裂问题。

4. 问题: 在prism vision项目中，你提到了CDN加速，它具体是如何工作的？

   答案: 我使用CDN（Content Delivery Network）来加速短剧视频流和媒体资源 25。

   • 工作原理: CDN服务商在全球部署了大量的加速节点。当用户请求短剧视频等静态资源时，CDN会根据用户的地理位置，将请求导向离用户最近的加速节点。如果节点上没有该资源，它会从源站拉取，并缓存起来。

   • 优点: CDN可以提供低延迟、高流畅的观看体验，同时减轻源站服务器的压力 26。

5. 问题: NGINX在你的prism vision项目中扮演了什么角色？

   答案: 在prism vision项目中，NGINX作为Web服务器和反向代理服务器 27。

   • 反向代理: 它作为统一入口，接收所有外部请求，并根据配置将请求转发到不同的后端服务上。
   • 负载均衡: 当后端服务有多个实例时，NGINX可以实现负载均衡，将请求分发到不同的实例上，提高系统的可用性和性能。
   • 静态资源托管: NGINX可以托管静态资源，如图片、CSS、JavaScript等，减轻后端服务器的压力。
   • SSL卸载: NGINX还可以处理SSL/TLS加密，将加密请求转发给后端，减轻后端服务的加密解密负担。

6. 问题: 在视频管理系统项目中，你使用Session技术存储登录用户信息，这种方式有什么优缺点？

   答案: 在视频管理系统项目中，我使用Session技术存储登录用户信息 28。

   • 优点: 用户信息存储在服务器端，相对安全。
   • 缺点:
     1. 服务器压力: Session会占用服务器内存，当并发用户量大时，会给服务器带来很大的压力。
     2. 分布式问题: 在分布式环境下，Session无法共享。需要使用Spring Session结合Redis等技术来解决。

7. 问题: Hutool在视频管理系统项目中是如何用于验证码验证的？

   答案: 在视频管理系统项目中，我使用Hutool工具包生成验证码，并将验证码的值存储在Session中 29。

   • 验证流程:

     1. 后端生成验证码图片和验证码的值，将值存储在Session中，并将图片返回给前端。
     2. 前端用户输入验证码，并提交表单。
     3. 后端从Session中取出验证码，与用户输入的值进行比较。
     4. 如果一致，则验证通过；否则，验证失败，从而防止恶意访问数据库。

8. 问题: 在你的prism vision项目中，你是如何处理日志记录与异常的？

   答案: 我实现了统一的异常捕获机制，使用@ControllerAdvice或@RestControllerAdvice注解来处理全局异常，并返回统一的JSON格式的错误信息。

   • 日志记录: 我使用了Log4j2或Slf4j等日志框架，记录系统运行日志，包括请求日志、业务日志、异常日志等，方便排查问题 。

   • 日志级别: 我根据不同的日志信息，使用不同的日志级别（如INFO、WARN、ERROR）进行记录，方便后期分析。

9. 问题: 你在prism vision项目中使用了Git进行版本管理，能谈谈你常用的Git命令和工作流程吗？

   答案: 我常用的Git命令包括git add、git commit、git push、git pull、git branch、git checkout、git merge、git rebase等 33。

   • 工作流程: 我通常遵循Git Flow工作流。
     1. 创建新分支：git checkout -b feature/xxx。
     2. 进行开发。
     3. 提交代码：git add .、git commit -m "xxx"。
     4. 推送到远程仓库：git push origin feature/xxx。
     5. 发起Pull Request，进行代码审核。
     6. 合并到主分支，发布版本。

10. 问题: 描述一下你在视频管理系统项目中是如何使用Axios完成增量更新和文件上传的？

答案: 在视频管理系统项目中，我使用Axios发送HTTP请求 34。

• 增量更新: 对于增量更新，我使用Axios的GET或POST请求，获取最新的数据并更新页面局部内容，而不是刷新整个页面。

• 文件上传: 对于文件上传，我将文件封装在FormData对象中，然后使用Axios发送POST请求到后端，后端接收并保存文件 35。

计算机基础与网络

1. 问题: 解释一下TCP和UDP协议的区别，以及各自的适用场景。

   答案:

   • TCP（Transmission Control Protocol）: 面向连接的、可靠的、基于字节流的传输层协议。它通过三次握手建立连接，四次挥手断开连接，保证数据传输的可靠性。
     • 适用场景: 对数据完整性要求高、对速度要求不高的场景，如HTTP、HTTPS、FTP等。
   • UDP（User Datagram Protocol）: 无连接的、不可靠的、基于数据报的传输层协议。它不保证数据包的顺序和完整性，但传输速度快。
     • 适用场景: 对速度要求高、对数据完整性要求不高的场景，如在线视频、DNS、RTP等。

2. 问题: 描述一下HTTP和HTTPS的区别，以及HTTPS是如何保证通信安全的。

   答案: HTTP是超文本传输协议，以明文方式传输数据，不安全 36。

   HTTPS是在HTTP的基础上加入了SSL/TLS协议，对数据进行加密传输，提供了身份验证、数据完整性和保密性，更加安全 。

   • HTTPS保证安全:
     1. 加密: HTTPS使用对称加密和非对称加密结合的方式，对传输数据进行加密。
     2. 认证: 服务器会向客户端发送数字证书，客户端验证证书的有效性，确保通信方是可信的。
     3. 完整性: SSL/TLS协议使用MAC（消息认证码）来验证数据的完整性，确保数据在传输过程中没有被篡改。

3. 问题: 谈谈你对Linux操作系统的理解，以及你掌握的常用命令。

   答案: 我熟悉Linux操作系统，掌握了常用的命令操作，如文件管理、权限控制等 38。

   • 常用命令: ls（列出文件）、cd（切换目录）、mkdir（创建目录）、rm（删除文件）、cp（复制文件）、mv（移动文件）、cat（查看文件内容）、tail（查看文件末尾内容）、grep（查找文件内容）、chmod（修改文件权限）、chown（修改文件所有者）等。

4. 问题: 解释一下DNS（域名系统）的工作原理。

   答案: DNS是一个分布式数据库，它将域名（如www.google.com）转换为IP地址。

   • 工作流程:
     1. 用户在浏览器输入域名。
     2. 浏览器首先检查本地hosts文件和DNS缓存。
     3. 如果找不到，向本地DNS服务器发起DNS查询。
     4. 本地DNS服务器向根域名服务器查询。
     5. 根域名服务器返回.com域名服务器的地址。
     6. 本地DNS服务器向.com域名服务器查询。
     7. .com域名服务器返回google.com域名服务器的地址。
     8. 本地DNS服务器向google.com域名服务器查询。
     9. google.com域名服务器返回www.google.com的IP地址。
     10. 本地DNS服务器将IP地址返回给浏览器，并缓存起来。
     11. 浏览器使用IP地址访问Web服务器。

5. 问题: 谈谈你对RESTful API的理解，以及你如何在项目中设计RESTful接口。

   答案: RESTful API是一种设计风格，它使用统一的URL来表示资源，并使用HTTP方法（GET、POST、PUT、DELETE）来对资源进行操作。

   • 设计原则:
     1. 资源: 使用名词来表示资源，如/users、/products。
     2. HTTP方法: 使用HTTP方法来表示对资源的操作，如GET（查询）、POST（创建）、PUT（更新）、DELETE（删除）。
     3. 状态码: 使用HTTP状态码来表示请求结果，如200（成功）、201（创建成功）、404（资源未找到）、500（服务器错误）。
   • 项目实践: 在项目中，我使用@RestController注解，并结合@RequestMapping、@GetMapping、@PostMapping等注解来设计RESTful接口。

6. 问题: 描述一下JWT（JSON Web Token）的结构和工作原理。

   答案: JWT是一个开放标准，它定义了一种紧凑且自包含的方式，用于在各方之间安全地传输信息。JWT由三部分组成：Header、Payload和Signature。

   • Header: 包含Token的类型和签名算法。
   • Payload: 包含了一系列声明（claim），用于存储用户信息、过期时间等。
   • Signature: 由Header和Payload以及一个密钥进行签名，用于验证Token的完整性。
   • 工作原理: 客户端登录成功后，服务器会生成一个JWT并返回给客户端。客户端在后续请求中，将JWT放在HTTP Header中发送给服务器。服务器接收到请求后，会验证JWT的签名，如果有效，则从Payload中获取用户信息。

综合能力与未来发展

1. 问题: 你在简历中提到了Vue，能详细描述一下你对前端技术的掌握程度吗？

   答案: 我对前端技术有一定的了解，能够使用Vue完成前后端数据的绑定，使用Element Plus等组件库快速搭建页面。我能够通过

   Vue的路由、组件化、状态管理等特性，构建单页应用。虽然我的主要方向是Java后端开发，但我具备与前端开发人员沟通需求、协作开发的能力 40。

2. 问题: 你在自我评价中提到自学能力强，能举个例子吗？

   答案: 我对技术有浓厚兴趣，自学能力强 44。例如，在项目中需要使用

   Spring Cloud时，我通过阅读官方文档、博客、视频教程等方式，快速掌握了服务注册、负载均衡、熔断降级等核心概念，并成功地将其应用到项目中 45。我还自学了

   Redis、MySQL的分库分表等技术，并应用到实际项目中 46。

3. 问题: 你对未来有什么职业规划？

   答案: 我希望能够成为一名优秀的全栈工程师，不仅在后端技术方面深入研究，也希望能够掌握更多的前端技术。我将持续学习，不断提升自己的技术能力，关注行业发展趋势，为公司创造更大的价值。

JVM与内存管理

1. 问题: 描述一下JVM的运行时数据区域，并解释每个区域的作用。

   答案: JVM的运行时数据区域主要分为五块：

   * 程序计数器（Program Counter Register）: 一块较小的内存空间，用于存储当前线程执行的字节码指令的地址。它是唯一一个在JVM中不会出现OutOfMemoryError的区域。

   * Java虚拟机栈（Java Virtual Machine Stacks）: 每个线程私有的，用于存储栈帧（Stack Frame），每个栈帧包含局部变量表、操作数栈、动态连接、方法出口等信息。StackOverflowError和OutOfMemoryError可能在此区域发生。

   * 本地方法栈（Native Method Stacks）: 与虚拟机栈类似，但它为Native方法服务。

   * Java堆（Java Heap）: 线程共享的区域，是JVM管理的最大一块内存，用于存放对象实例。这是垃圾回收的主要区域。OutOfMemoryError最常发生在此区域。

   * 方法区（Method Area）: 线程共享的区域，用于存储已被JVM加载的类信息、常量、静态变量等。在JDK 8中，方法区被元空间（Metaspace）取代，元空间使用本地内存，不再受JVM堆大小的限制。

2. 问题: 谈谈你对Java内存模型的理解，它解决了什么问题？

   答案: Java内存模型（JMM）定义了线程如何以及何时可以看到其他线程写入共享变量的值。它解决了多线程并发访问共享变量时，因缓存不一致导致的可见性问题和有序性问题。JMM规定了以下主要内容：

   * 主内存（Main Memory）: 所有线程共享的内存区域，用于存储共享变量。

   * 工作内存（Working Memory）: 每个线程私有的内存区域，用于存储该线程使用的共享变量的副本。

   * 同步规则: JMM定义了线程之间如何通过synchronized、volatile等关键字进行通信，确保操作的可见性和有序性。它通过happens-before原则来保证操作的有序性。

3. 问题: 解释一下Java中的类加载机制，以及双亲委派模型。

   答案: Java的类加载机制是JVM将class文件加载到内存，并对其进行校验、准备、解析、初始化，最终形成可被虚拟机直接使用的Java.lang.Class对象。

   * 加载过程:

   1. 加载（Loading）: 通过类的全限定名获取定义此类的二进制字节流。

   2. 验证（Verification）: 确保加载的class文件的字节流符合JVM规范。

   3. 准备（Preparation）: 为类的静态变量分配内存，并设置默认初始值。

   4. 解析（Resolution）: 将常量池中的符号引用替换为直接引用。

   5. 初始化（Initialization）: 执行类构造器()方法，为静态变量赋初始值。

      * 双亲委派模型: 是一种类加载器的层次结构。当一个类加载器收到加载类的请求时，它会首先把这个请求委派给它的父类加载器。只有当父类加载器无法完成加载时，子加载器才会尝试自己加载。这种模型的好处是，可以避免类的重复加载，并保证Java核心API的类不会被随意替换。

4. 问题: 如何对JVM进行性能调优？你了解哪些JVM参数？

   答案: JVM性能调优通常涉及调整堆内存大小、垃圾回收器选择、线程池配置等。

   * 常见调优步骤:

   1. 监控: 使用JVisualVM、JConsole、arthas等工具监控JVM的内存、CPU、GC等指标。

   2. 分析: 根据监控数据，分析是否存在内存泄漏、GC频繁、CPU使用率过高等问题。

   3. 调整:

      • 堆内存: 使用-Xms和-Xmx设置堆的初始和最大内存。

      • GC收集器: 根据应用类型选择合适的GC收集器，如G1或ZGC。

      • GC日志: 通过-XX:+PrintGCDetails等参数打印详细的GC日志，方便分析。

        * 常用JVM参数:

   • -Xms<size>: 设置堆的初始大小。
   • -Xmx<size>: 设置堆的最大大小。
   • -Xmn<size>: 设置新生代的大小。
   • -XX:MetaspaceSize、-XX:MaxMetaspaceSize: 设置元空间的大小。
   • -XX:+UseG1GC: 启用G1垃圾回收器。
   • -XX:+PrintGCDetails: 打印详细GC日志。

Java并发与高并发

1. 问题: 解释一下java.util.concurrent包中的核心组件，并举例说明你在项目中的应用。

   答案: java.util.concurrent包提供了丰富的并发编程工具类，包括：

   * ExecutorService和ThreadPoolExecutor: 线程池，用于管理和复用线程。在prism vision项目中，我使用ThreadPoolExecutor来管理短剧视频转码任务，避免了频繁创建和销毁线程的开销。

   * BlockingQueue: 阻塞队列，用于生产者-消费者模式。在消息队列的实现中，我使用ArrayBlockingQueue来存储待处理的消息，当队列满时，生产者线程会被阻塞。

   * CountDownLatch: 倒计时门闩，用于控制多个线程等待所有其他线程执行完毕。在项目中，我使用CountDownLatch来等待多个子任务完成后，再进行下一步操作。

   * CyclicBarrier: 循环栅栏，用于让一组线程达到一个共同点时再继续执行。

   * Semaphore: 信号量，用于控制对共享资源的访问数量。

   * Future和FutureTask: 用于获取异步任务的执行结果。

2. 问题: 详细解释一下synchronized和ReentrantLock的底层实现机制，以及它们在性能上的区别。

   答案:

   * synchronized: 是Java内置的悲观锁，底层通过monitorenter和monitorexit指令实现。在JDK 1.6之后，synchronized引入了锁升级机制，从无锁、偏向锁、轻量级锁到重量级锁，以减少锁竞争时的开销。

   * ReentrantLock: 是AQS（AbstractQueuedSynchronizer）的实现类。AQS是一个队列同步器，它通过CAS操作和volatile变量维护一个同步状态，当线程获取锁失败时，会被封装成一个节点，并加入到AQS的等待队列中。

   * 性能区别: 在锁竞争不激烈时，synchronized通过偏向锁和轻量级锁的优化，性能可以和ReentrantLock持平，甚至更好。但在锁竞争激烈时，ReentrantLock由于AQS的队列机制，可以更公平地进行锁的获取，并且提供了可中断锁、限时锁等高级功能，性能通常优于synchronized。

3. 问题: 什么是线程死锁？如何避免死锁的发生？

   答案: 线程死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力干涉，它们都将无法继续执行。

   * 死锁的四个必要条件:

   1. 互斥条件: 一个资源每次只能被一个线程使用。

   2. 请求与保持条件: 一个线程因请求资源而阻塞时，对已获得的资源保持不放。

   3. 不剥夺条件: 一个线程已获得的资源，在未使用完之前，不能被强行剥夺。

   4. 循环等待条件: 若干线程之间形成一种头尾相接的循环等待资源关系。

      * 避免死锁: 只要破坏这四个条件中的一个或多个即可。最常用的方法是破坏循环等待条件，例如通过规定资源的获取顺序。

4. 问题: 谈谈你对高并发的理解，以及你如何在项目中处理高并发问题。

   答案: 高并发是指系统在同一时间点能够处理大量请求的能力。在我的项目中，我通过以下方式处理高并发问题：

   * 前端: 使用CDN加速静态资源，使用NGINX进行负载均衡。

   * 后端:

   • 缓存: 使用Redis作为分布式缓存，减少数据库访问压力。

   • 异步处理: 使用MQ（消息队列）将耗时任务异步化，提高系统响应速度。

   • 线程池: 使用线程池管理线程，避免频繁创建和销毁线程的开销。

   • 限流、降级、熔断: 使用Hystrix或Sentinel等组件，对接口进行限流、降级和熔断，保证系统的可用性。

     * 数据库: 使用数据库连接池，分库分表，读写分离，优化SQL查询。

5. 问题: volatile和synchronized有什么区别？volatile能代替synchronized吗？

   答案:

   * 区别:

   • 作用: volatile保证可见性和有序性，但不保证原子性。synchronized既保证可见性、有序性，也保证原子性。

   • 锁: synchronized是悲观锁，会阻塞线程。volatile是轻量级的，不会阻塞线程。

   • 使用范围: volatile只能修饰变量，synchronized可以修饰方法和代码块。

     * 替代性: volatile不能完全代替synchronized。synchronized可以保证对共享资源的原子性操作，而volatile不能。例如，i++不是原子操作，即使使用volatile修饰，在多线程环境下仍然可能出现问题。

6. 问题: 解释一下CAS（Compare-and-Swap）的原理，以及它在并发编程中的应用。

   答案: CAS是一种乐观锁的实现机制，它包含三个操作数：内存位置V、旧的预期值A和新的值B。当且仅当V处的值等于A时，才用B更新V的值，否则不进行任何操作。这个过程是原子性的。

   * 应用: 在java.util.concurrent包中，很多类的实现都依赖于CAS，例如AtomicInteger。它通过CAS操作，在不使用锁的情况下，实现了对共享变量的原子性更新。

微服务与分布式

1. 问题: 谈谈你对微服务的理解，它与单体应用相比，有什么优缺点？

   答案: 微服务是一种架构风格，它将一个大型的应用拆分成多个独立运行的小服务，每个服务都运行在独立的进程中，并使用轻量级通信机制相互协作。

   * 优点:

   1. 独立部署: 每个服务都可以独立部署，互不影响。

   2. 技术栈灵活: 每个服务可以使用不同的技术栈。

   3. 高可用: 单个服务故障不会影响整个系统。

   4. 扩展性好: 可以根据需要对单个服务进行水平扩展。

      * 缺点:

   5. 运维复杂: 服务数量增多，运维和监控变得复杂。

   6. 分布式问题: 需要处理分布式事务、服务治理等问题。

   7. 开发成本高: 需要更多的技术栈来支持微服务架构。

2. 问题: 在你的项目中，如何实现分布式事务？你了解哪些分布式事务解决方案？

   答案: 分布式事务是指在分布式系统中，多个独立的事务共同完成一个业务操作。

   * 项目实践: 我通常使用Seata框架来解决分布式事务问题。Seata支持AT、TCC、Saga、XA等多种模式。

   * 解决方案:

   • 2PC（两阶段提交）: 在XA模式中，有一个事务协调者，负责协调多个事务参与者，保证所有参与者要么都提交，要么都回滚。缺点是性能差，容易出现单点故障。
   • TCC（Try-Confirm-Cancel）: 将一个业务操作分为三个阶段：Try阶段尝试执行，Confirm阶段确认执行，Cancel阶段取消执行。优点是性能好，但需要业务代码支持。
   • Saga模式: 将一个长事务分解为多个短事务，每个短事务都有一个对应的补偿操作。当某个短事务失败时，会通过补偿操作来撤销之前已执行的短事务。
   • MQ（消息队列）: 通过消息队列来实现最终一致性。当一个服务执行成功后，发送一条消息，其他服务消费这条消息并执行相应的操作。

3. 问题: 解释一下API Gateway的作用，以及你在项目中如何使用它。

   答案: API Gateway是微服务架构中的一个重要组件，它作为所有微服务请求的统一入口。

   * 作用:

   1. 路由: 将外部请求路由到对应的微服务。

   2. 认证与授权: 统一处理用户的认证和授权。

   3. 限流与熔断: 对请求进行限流、熔断，保护后端服务。

   4. 日志与监控: 统一记录请求日志，方便监控。

      * 项目实践: 在prism vision项目中，我使用Spring Cloud Gateway作为API Gateway，配置了路由规则、过滤器，实现了统一认证、日志记录和限流等功能。

4. 问题: 什么是RPC？你了解哪些RPC框架？

   答案: RPC（Remote Procedure Call）是远程过程调用，它允许程序调用位于不同地址空间（通常是网络上的另一台计算机）中的过程，就像调用本地过程一样。

   * RPC框架:

   • Dubbo: 阿里巴巴开源的RPC框架，支持多种协议和负载均衡策略。
   • gRPC: Google开源的高性能RPC框架，基于HTTP/2协议，使用Protocol Buffers作为序列化协议。
   • Thrift: Facebook开源的跨语言RPC框架。

5. 问题: 你在项目中使用了Nacos，请详细解释一下Nacos的作用。

   答案: Nacos是一个开源的服务发现、配置管理和服务治理平台。

   * 服务注册与发现: 每个微服务在启动时向Nacos注册自己的信息，Nacos会维护一个服务实例列表。当一个服务需要调用另一个服务时，会向Nacos查询该服务的实例列表，从而实现服务发现。

   * 配置管理: Nacos可以作为配置中心，将应用的配置信息统一管理。当配置发生变更时，Nacos会通知所有订阅了该配置的服务，实现配置的热更新。

设计模式与架构

1. 问题: 什么是设计模式？请举例说明你在项目中常用的设计模式。

   答案: 设计模式是软件设计中，针对特定问题的通用、可重用的解决方案。

   * 常用设计模式:

   • 单例模式: 确保一个类只有一个实例，并提供一个全局访问点。例如，我在项目中封装了Redis工具类，通过单例模式确保只有一个Redis连接实例。
   • 工厂模式: 定义一个创建对象的接口，让子类决定实例化哪一个类。例如，在支付业务中，根据不同的支付类型（支付宝、微信）创建不同的支付对象。
   • 代理模式: 为某个对象提供一个代理，以控制对这个对象的访问。例如，Spring AOP就是基于代理模式实现的。
   • 策略模式: 定义一系列算法，把它们封装起来，并且使它们可以相互替换。例如，在促销活动中，根据不同的活动类型（满减、打折）使用不同的策略。

2. 问题: 解释一下MVC和MVVM架构模式的区别。

   答案:

   * MVC（Model-View-Controller）:

   • Model: 负责数据和业务逻辑。

   • View: 负责展示数据。

   • Controller: 负责接收用户输入，调用Model进行处理，并将结果返回给View。

     * MVVM（Model-View-ViewModel）:

   • Model: 负责数据和业务逻辑。

   • View: 负责展示数据，并通过数据绑定（Data Binding）与ViewModel进行通信。

   • ViewModel: 负责将Model的数据转换为View可以展示的数据，并处理View的输入。

     * 区别: MVVM通过数据绑定，实现了View和ViewModel的双向同步，使得开发者无需手动操作DOM，大大简化了前端开发。

3. 问题: 谈谈你对消息队列（MQ）的理解，以及你在项目中如何使用它。

   答案: 消息队列是一种用于解耦、异步、削峰的中间件。

   * 作用:

   • 解耦: 生产者和消费者之间不再直接依赖，提高了系统的灵活性。

   • 异步: 将耗时任务异步化，提高系统响应速度。

   • 削峰: 当系统瞬时流量过大时，MQ可以将请求缓存起来，后端服务可以按照自己的处理能力消费，避免系统崩溃。

     * 项目实践: 在prism vision项目中，我使用RabbitMQ来处理短剧视频转码任务。当用户上传视频后，系统将转码任务发送到MQ中，由独立的转码服务进行消费和处理，避免了用户等待转码完成，提高了用户体验。

4. 问题: 你在简历中提到了MyBatis Plus，它与MyBatis相比，有什么优势？

   答案: MyBatis Plus是MyBatis的增强工具，它在MyBatis的基础上提供了许多便捷的功能。

   * 优势:

   • CRUD操作: 提供了BaseMapper，封装了常用的CRUD（增删改查）方法，无需手动编写SQL。
   • 代码生成器: 提供了代码生成器，可以根据数据库表结构自动生成Entity、Mapper、Service等代码。
   • 分页插件: 内置了分页插件，可以方便地实现分页查询。
   • 乐观锁: 提供了乐观锁插件，可以方便地实现乐观锁。
   • 条件构造器: 提供了Wrapper，可以通过API的方式构建复杂的SQL查询条件。

5. 问题: 什么是OAuth2.0？它在你的项目中有什么应用？

   答案: OAuth2.0是一个开放授权协议，它允许用户授权第三方应用访问他们在Web服务上的私有资源，而无需提供用户名和密码。

   * 应用: 在prism vision项目中，我使用了OAuth2.0作为授权协议，允许用户使用微信、QQ等第三方账号登录。用户授权后，第三方平台会返回一个access token，后端通过这个token获取用户信息。

安全

1. 问题: 解释一下SQL注入和XSS攻击的原理，以及如何防范。

   答案:

   * SQL注入: 攻击者通过在输入框中注入恶意的SQL语句，来欺骗数据库执行非法的SQL命令。

   • 防范:

     • 使用预编译的PreparedStatement，而不是字符串拼接。

     • 对用户输入进行严格的SQL关键字过滤和转义。

       * XSS（Cross-Site Scripting）: 攻击者通过注入恶意脚本，当其他用户访问该页面时，恶意脚本会在用户的浏览器中执行，从而窃取用户信息。

   • 防范:

     • 对用户输入进行HTML转义，将特殊字符转换为实体字符。
     • 设置HTTP响应头Content-Security-Policy。

2. 问题: 什么是CSRF（Cross-Site Request Forgery）？如何防范？

   答案: CSRF是跨站请求伪造，攻击者通过伪造用户请求，以用户的身份执行一些操作。例如，攻击者构造一个URL，当用户点击这个URL时，会以用户的身份发送一个转账请求。

   * 防范:

   1. Token校验: 在请求中加入一个CSRF Token，服务器验证Token的有效性。
   2. Referer校验: 检查HTTP请求头中的Referer，判断请求是否来自合法的URL。
   3. SameSite属性: 设置Cookie的SameSite属性为Strict或Lax，可以防止CSRF攻击。

3. 问题: 解释一下HTTPS的握手过程。

   答案: HTTPS的握手过程主要是SSL/TLS协议的握手过程。

   \1. 客户端Hello: 客户端发送Client Hello消息，包含SSL版本、加密套件、随机数等信息。

   \2. 服务端Hello: 服务端收到消息后，返回Server Hello消息，包含协商好的SSL版本、加密套件，以及服务器的数字证书和另一个随机数。

   \3. 客户端验证证书: 客户端验证服务器的数字证书是否有效。

   \4. 客户端发送密钥: 客户端生成一个Pre-master密钥，并使用服务器的公钥加密后发送给服务器。

   \5. 服务端解密密钥: 服务器使用自己的私钥解密Pre-master密钥。

   \6. 生成会话密钥: 客户端和服务器使用Pre-master密钥和之前的两个随机数，生成一个会话密钥。

   \7. 加密通信: 后续的通信都使用会话密钥进行对称加密，保证通信安全。

DevOps与CI/CD

1. 问题: 谈谈你对DevOps的理解，以及你了解哪些DevOps工具。

   答案: DevOps是一种文化、方法论和实践，旨在促进开发（Development）和运维（Operations）团队之间的协作和沟通。

   * 核心思想: 自动化、持续集成、持续交付、持续部署。

   * 常用工具:

   • 版本控制: Git。
   • 持续集成（CI）: Jenkins、Gitlab CI、Travis CI。
   • 容器化: Docker。
   • 容器编排: Kubernetes。
   • 监控: Prometheus、Grafana。

2. 问题: 解释一下CI/CD（持续集成/持续交付）流程。

   答案:

   * CI（Continuous Integration）: 持续集成是指开发者将代码频繁地合并到主干分支，并通过自动化测试来验证代码的正确性。

   1. 开发者提交代码到Git仓库。

   2. Jenkins等CI工具监听到代码变更。

   3. CI工具拉取代码，进行编译、构建、单元测试等。

   4. 如果构建失败，通知开发者。

      * CD（Continuous Delivery）: 持续交付是指将CI通过的构建产物自动部署到测试环境或预发布环境，并等待人工触发部署到生产环境。

      * CD（Continuous Deployment）: 持续部署是指将CI通过的构建产物自动部署到生产环境，无需人工干预。

3. 问题: 你了解Docker吗？它在你的项目中有什么应用？

   答案: Docker是一个开源的应用容器引擎，它可以将应用及其依赖打包成一个轻量级、可移植的容器，从而实现快速部署和环境一致性。

   * 应用: 在prism vision项目中，我将后端服务、MySQL、Redis等都打包成Docker镜像。

   1. 开发环境: 开发者只需要拉取Docker镜像，即可快速搭建开发环境。
   2. 部署: 通过Docker Compose或Kubernetes，可以一键部署整个应用，实现了环境的隔离和一致性。
   3. CI/CD: 在CI/CD流程中，Jenkins等工具可以自动构建Docker镜像，并将其推送到镜像仓库。

前端技术

1. 问题: 你在简历中提到了Vue，请详细解释一下Vue的生命周期钩子函数，以及你常用的几个。

   答案: Vue的生命周期钩子函数是在Vue实例或组件从创建到销毁的整个过程中，可以执行的函数。

   * 常用钩子函数:

   • created: 实例创建完成后调用，但DOM尚未渲染。可以在此阶段进行数据初始化，发送Ajax请求等。
   • mounted: 实例挂载到DOM后调用，DOM已渲染。可以在此阶段进行DOM操作、访问子组件等。
   • updated: 当数据更新导致DOM重新渲染时调用。
   • beforeDestroy / destroyed: 实例销毁前/后调用，可以在此阶段清除定时器、解绑事件等。

2. 问题: 解释一下Vue中的组件通信方式，并举例说明。

   答案:

   * 父子组件通信:

   • props / emit: 父组件通过props向子组件传递数据，子组件通过$emit向父组件触发事件。

     * 兄弟组件通信:

   • Event Bus: 创建一个空的Vue实例作为事件总线，通过$on和$emit进行通信。

   • Vuex: 使用Vuex进行状态管理，兄弟组件可以共享数据。

     * 祖孙组件通信:

   • provide / inject: 在父组件中使用provide提供数据，在子孙组件中使用inject注入数据。

   • Vuex: 使用Vuex进行状态管理。

3. 问题: 什么是Vuex？它解决了什么问题？

   答案: Vuex是Vue的官方状态管理库，它用于集中管理应用中所有组件的状态。

   * 作用: 它解决了多组件共享状态时，状态难以管理和维护的问题，特别是在大型应用中。

   * 核心概念:

   • State: 存储应用的状态。
   • Mutations: 用于同步修改State，必须是同步函数。
   • Actions: 用于异步操作，可以提交Mutations。
   • Getters: 类似于Vue的计算属性，用于从State中派生出新的状态。
   • Modules: 用于将Store分割成模块。

4. 问题: 你了解Webpack吗？它的核心概念是什么？

   答案: Webpack是一个模块打包工具，它可以将各种前端资源（JS、CSS、图片等）打包成一个或多个bundle文件。

   * 核心概念:

   • Entry: 入口，Webpack从Entry开始构建依赖图。
   • Output: 出口，Webpack打包后的文件输出位置。
   • Loader: 转换器，用于对模块进行转换，例如将ES6转为ES5。
   • Plugin: 插件，用于在Webpack的生命周期中执行各种任务，例如压缩文件、生成HTML文件等。

数据结构与算法

1. 问题: 描述一下你熟悉的数据结构，以及它们在项目中的应用。

   答案: 我熟悉数组、链表、栈、队列、哈希表、树等数据结构。

   * 哈希表: 在HashMap、Redis等框架中广泛使用，用于实现快速的键值对存取。

   * 队列: 在消息队列中应用，用于存储待处理的任务。

   * 栈: 在方法调用栈、浏览器的前进后退功能中应用。

   * 树: 在MySQL索引（B+树）、文件系统中应用。

2. 问题: 解释一下二分查找算法的原理和适用场景。

   答案: 二分查找是一种高效的查找算法，它要求待查找的集合必须是有序的。

   * 原理: 它将集合分成两半，与中间元素进行比较。如果目标值等于中间元素，则查找成功。如果目标值小于中间元素，则在左半部分继续查找；如果大于，则在右半部分继续查找。

   * 适用场景: 适用于有序数组、有序链表的查找，时间复杂度为O(log n)。

3. 问题: 描述一下你对快速排序算法的理解，并简述其实现步骤。

   答案: 快速排序是一种分治算法，其平均时间复杂度为O(n log n)。

   * 实现步骤:

   1. 选择基准元素: 从数组中选择一个元素作为基准（pivot）。
   2. 分区（Partition）: 将数组中所有小于基准的元素移到基准的左边，所有大于基准的元素移到基准的右边。
   3. 递归: 对基准左右两边的子数组递归地进行快速排序，直到子数组只包含一个元素或为空。

4. 问题: 什么是红黑树？它有什么特点？在Java中有哪些应用？

   答案: 红黑树是一种自平衡的二叉查找树，它通过对节点颜色（红或黑）的约束，确保了树的高度相对平衡，从而保证了查找、插入、删除等操作的平均时间复杂度为O(log n)。

   * 特点:

   1. 每个节点不是红色就是黑色。

   2. 根节点是黑色的。

   3. 每个叶子节点（null节点）是黑色的。

   4. 如果一个节点是红色的，则它的子节点必须是黑色的。

   5. 从任一节点到其每个叶子节点的所有路径上，包含的黑色节点数相同。

      * 应用: 在Java中，HashMap在链表长度超过阈值时会转换为红黑树，TreeMap、ConcurrentHashMap等集合类的底层也使用了红黑树。

综合能力与未来发展

1. 问题: 假设你负责一个高并发短剧平台的后端设计，你会如何考虑系统的扩展性？

   答案: 我会从以下几个方面考虑系统的扩展性：

   * 水平扩展: 使用微服务架构，将不同功能的短剧服务拆分成独立的服务，并通过负载均衡器（NGINX）将请求分发到多个服务实例上。

   * 数据库扩展: 使用分库分表技术，将用户数据、短剧内容数据分别存放在不同的库中。使用读写分离，将读请求分发到从库，写请求分发到主库。

   * 缓存扩展: 使用Redis Cluster等分布式缓存，对缓存进行水平扩展，提高缓存的存储能力和并发能力。

   * 异步化: 使用消息队列，将视频转码、日志记录等耗时任务异步化，提高系统响应速度。

2. 问题: 在你的项目开发中，你遇到过哪些技术难题？你是如何解决的？

   答案: 在prism vision项目中，我遇到过一个技术难题：如何在分布式环境下实现Session共享。

   * 问题分析: 在单体应用中，Session默认存储在服务器内存中。但在微服务架构中，Session无法共享，导致用户登录后，无法访问其他服务。

   * 解决方案: 我通过引入Spring Session结合Redis来解决。Spring Session将Session数据存储在Redis中，当一个服务需要获取Session时，会从Redis中读取，从而实现了Session的共享。

3. 问题: 你如何学习新技术？请举例说明。

   答案: 我通常会通过以下几种方式学习新技术：

   \1. 官方文档: 官方文档是学习新技术的最佳途径，它包含了最全面、最准确的信息。

   \2. 博客和技术社区: 通过阅读技术博客、GitHub上的开源项目，可以学习到新技术的应用和实践经验。

   \3. 视频教程: 通过观看视频教程，可以快速入门，掌握新技术的核心概念。

   \4. 动手实践: 边学边练，将新技术应用到实际项目中，遇到问题再查阅资料解决，这是最有效的学习方式。例如，我通过阅读Spring Cloud官方文档和GitHub上的示例项目，快速掌握了Spring Cloud的微服务开发。

4. 问题: 你对JVM和G1垃圾收集器有何更深入的了解？

   答案: G1（Garbage-First）是一款面向服务器的垃圾收集器，它的设计目标是：

   * 可预测的GC暂停时间: G1将堆内存划分为多个大小相等的Region，每次GC时，它会优先回收垃圾最多的Region，从而在可控的GC暂停时间内，完成垃圾回收。

   * 并行与并发: G1在GC过程中，可以并行或并发地执行，减少了STW（Stop-The-World）的时间。

   * 分代收集: G1依然采用了分代收集的思想，但不再是物理分代，而是逻辑分代。

5. 问题: 描述一下你对CAP理论的理解，以及它在分布式系统中的应用。

   答案: CAP理论是指在一个分布式系统中，一致性（Consistency）、可用性（Availability）、分区容错性（Partition tolerance）这三个特性不能同时满足，最多只能满足其中两个。

   * Consistency: 一致性，指所有节点在同一时刻看到的数据是一致的。

   * Availability: 可用性，指系统在SLA（服务等级协议）内，始终能够对外提供服务。

   * Partition tolerance: 分区容错性，指系统在网络分区的情况下，仍然能够对外提供服务。

   * 应用:

   • CP系统: 强调一致性和分区容错性，例如Zookeeper。当网络分区时，为了保证一致性，Zookeeper会暂停对外服务。
   • AP系统: 强调可用性和分区容错性，例如Eureka、Redis。当网络分区时，Eureka会保证服务可用，但可能会出现数据不一致。

6. 问题: 谈谈你对Java反射机制的理解，以及它在框架中的应用。

   答案: Java反射机制是指在运行时，可以动态地获取类的信息（如构造方法、属性、方法），并可以动态地创建对象、调用方法。

   * 应用: 反射机制在Spring、MyBatis等框架中被广泛应用。

   • Spring: Spring通过反射机制，根据配置动态地创建Bean实例、注入依赖。
   • MyBatis: MyBatis通过反射机制，根据Mapper接口和XML配置文件，动态生成代理对象，实现数据库操作。

操作系统

1. 问题: 解释一下进程和线程的区别。

   答案:

   * 进程: 是程序的一次执行过程，是系统进行资源分配和调度的基本单位。每个进程都有独立的内存空间。

   * 线程: 是进程的一个执行流，是CPU调度的基本单位。一个进程中可以有多个线程，这些线程共享进程的内存空间。

   * 区别: 进程拥有独立的资源，切换开销大。线程共享进程的资源，切换开销小。

2. 问题: 什么是I/O多路复用？它在Java中的应用？

   答案: I/O多路复用是一种I/O模型，它通过一个线程监听多个socket，当某个socket有数据可读或可写时，通知应用程序进行处理。

   * 应用: 在Java中，NIO（New I/O）框架实现了I/O多路复用。例如，Selector可以监听多个Channel，当某个Channel有事件发生时，Selector会通知应用程序，从而实现一个线程处理多个I/O请求，提高了并发能力。

3. 问题: 描述一下Linux中的Shell脚本，以及你常用的几个命令。

   答案: Shell脚本是Linux中的一种脚本语言，它可以方便地进行自动化操作。

   * 常用命令:

   • ps -ef | grep <keyword>: 查找指定进程。
   • nohup java -jar <jar_name> &: 后台运行Java程序。
   • tail -f <file_name>: 实时查看日志文件。
   • scp <source> <target>: 远程复制文件。
   • top / htop: 查看系统资源使用情况。

4. 问题: 什么是Linux中的inode和block？

   答案:

   * inode: inode是Linux中的一个数据结构，它包含了文件的元信息，例如文件大小、创建时间、文件所有者、文件权限等。每个文件都有一个唯一的inode号。

   * block: block是Linux文件系统存储数据的最小单位。文件的数据存储在block中，inode通过指针指向这些block。

数据库调优

1. 问题: 除了你之前提到的索引优化，你还了解哪些MySQL数据库性能调优的手段？

   答案:

   * 优化SQL语句:

   • 避免使用SELECT *，只查询需要的字段。

   • 使用LIMIT进行分页查询，而不是一次性查询所有数据。

   • 将大表拆分成小表，或者对热点数据进行缓存。

     * 优化表结构:

   • 选择合适的数据类型，例如使用int而不是varchar存储数字。

   • 为join操作的字段创建索引。

   • 减少表的字段数量。

     * 优化数据库配置:

   • 调整MySQL的配置参数，例如innodb_buffer_pool_size（InnoDB缓存池大小）。

   • 使用mysqltuner等工具进行配置优化。

2. 问题: 什么是数据库的悲观锁和乐观锁？它们在MySQL中如何实现？

   答案:

   * 悲观锁: 假设并发访问时会发生冲突，在访问资源前加锁，以保证数据的完整性。

   • MySQL实现: SELECT … FOR UPDATE。

     * 乐观锁: 假设并发访问时不会发生冲突，在更新数据时，检查数据是否被其他线程修改过。

   • MySQL实现: 通过版本号（version字段）或时间戳字段。在更新时，检查版本号是否与读取时一致。

算法

1. 问题: 描述一下你对动态规划算法的理解，并举一个简单的例子。

   答案: 动态规划是一种通过把原问题分解为相对简单的子问题的方式，来求解复杂问题的方法。

   * 核心思想:

   1. 最优子结构: 问题的最优解包含其子问题的最优解。

   2. 重叠子问题: 子问题被多次重复计算。

      * 例子: 斐波那契数列，f(n) = f(n-1) + f(n-2)。通过动态规划，我们可以将计算结果缓存起来，避免重复计算。

2. 问题: 解释一下贪心算法的原理，并与动态规划进行比较。

   答案: 贪心算法是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择，从而希望能够导致结果是全局最好或最优的算法。

   * 与动态规划的比较:

   • 动态规划会考虑所有可能的子问题，然后从子问题的最优解中推导出原问题的最优解。
   • 贪心算法在每一步都做出局部最优解，但并不总是能得到全局最优解。

职业发展

1. 问题: 你如何评估和提高自己的代码质量？

   答案: 我通常会从以下几个方面评估和提高自己的代码质量：

   * 代码规范: 遵循团队的代码规范，使用SonarQube等工具进行代码扫描。

   * 可读性: 使用有意义的变量名和方法名，添加必要的注释。

   * 测试: 编写单元测试和集成测试，确保代码的正确性。

   * Code Review: 积极参与Code Review，从同事的反馈中学习，也帮助同事发现问题。

   * 重构: 定期对代码进行重构，优化代码结构，提高代码的健壮性和可维护性。

2. 问题: 你对未来3-5年的职业规划是什么？

   答案: 在未来3-5年，我希望能够成为一名资深后端工程师，并在技术广度和深度上都有所提升。

   * 技术深度: 在Java、Spring Cloud、MySQL、Redis等技术栈上深入研究，特别是高并发、分布式、性能调优等领域。

   * 技术广度: 学习Go、Python等其他语言，了解Kubernetes、Service Mesh等新技术，拓宽自己的技术视野。

   * 架构设计: 参与和主导大型项目的架构设计，提升自己的系统设计能力。

   * 团队协作: 成为团队中的核心成员，能够带领和指导初级工程师，共同成长。

消息队列（Message Queue，简称MQ）是一种异步通信的中间件，它允许不同的应用程序或服务通过消息进行通信，从而实现系统之间的解耦、异步处理和流量削峰。

核心作用

1. 解耦 (Decoupling): * 问题: 在传统的同步调用模式下，如果服务A需要调用服务B，服务A必须知道服务B的存在。一旦服务B发生故障或需要更换，服务A也需要修改。这种紧耦合的关系使得系统难以维护和扩展。
   • MQ解决方案: 通过引入消息队列，服务A（生产者）只负责将消息发送到队列中，而服务B（消费者）则从队列中获取消息进行处理。生产者和消费者之间不再直接依赖，它们只依赖于消息队列，从而实现了系统的解耦。即使服务B发生故障或需要更换，只要消息格式不变，服务A仍然可以正常发送消息，系统的高可用性得到了保障。
2. 异步 (Asynchronous):
   • 问题: 在同步调用中，当一个请求需要处理多个耗时任务时，用户必须等待所有任务执行完毕才能得到响应，这会严重影响用户体验。例如，一个电商平台的下单操作，可能需要更新库存、生成订单、发送邮件等多个步骤。
   • MQ解决方案: 我们可以将这些耗时任务放入消息队列中。下单服务在创建订单后，立即向消息队列发送一条消息，然后就返回给用户响应。而其他服务（如库存服务、邮件服务）则可以异步地从队列中获取消息进行处理。这样，用户可以更快地得到响应，系统的并发能力也得到了提升。
3. 削峰 (Peak Shaving):
   • 问题: 当系统在某一时刻（如秒杀活动）面临突发的高并发流量时，后端服务可能会因为处理能力不足而崩溃。
   • MQ解决方案: 我们可以将所有请求都先放入消息队列中。后端服务则可以按照自己的处理能力，匀速地从队列中获取消息进行处理。这样，即使瞬时流量超过了后端服务的处理能力，消息队列也可以将多余的请求缓存起来，保护后端服务不被压垮。

消息队列的核心概念

• 生产者 (Producer): 负责创建并发送消息到消息队列的应用程序或服务。
• 消费者 (Consumer): 负责从消息队列中获取并处理消息的应用程序或服务。
• 消息 (Message): 生产者和消费者之间通信的数据载体。
• 队列 (Queue): 消息的存储单元，用于存放生产者发送的消息。
• 代理 (Broker): 消息队列服务器，负责消息的存储、路由、转发等。

消息队列的保障机制

为了确保消息的可靠传输，消息队列通常会提供以下保障机制：

1. 消息持久化: 将消息写入磁盘，即使消息队列服务器宕机，消息也不会丢失。
2. 消息确认机制 (ACK): 消费者在成功处理完消息后，会向消息队列发送确认（ACK），消息队列收到确认后才会删除该消息。如果消费者处理失败或宕机，消息队列会在超时后将消息重新发送给其他消费者，确保消息至少被成功处理一次。
3. 死信队列 (Dead-Letter Queue): 当消息处理失败或超过重试次数后，消息会被发送到死信队列。开发者可以对死信队列中的消息进行分析和处理。

常见的消息队列

• RabbitMQ: 基于AMQP协议，功能强大，支持多种模式，如点对点、发布/订阅。
• Kafka: 高吞吐量的分布式流平台，适用于日志收集、大数据处理等场景。
• ActiveMQ: 老牌开源消息队列，支持多种协议。
• RocketMQ: 阿里巴巴开源的分布式消息中间件，适用于大规模Kafka场景。
• Redis: Redis的List数据结构可以作为简单的消息队列使用，但功能相对较弱，不适用于复杂的生产环境。

项目应用举例

在prism vision短剧平台项目中，消息队列可以用于以下场景：

• 视频转码: 用户上传视频后，将视频转码任务发送到消息队列。后端独立的转码服务可以异步地消费这些任务，进行视频压缩、格式转换等操作。
• 日志收集: 将系统产生的日志发送到消息队列，由日志服务统一收集、分析和存储。
• 异步通知: 用户下单成功后，发送一条消息到消息队列。通知服务可以消费这条消息，异步地发送邮件或短信通知用户。

常用消息队列详解与项目实践

消息队列在微服务架构中扮演着至关重要的角色，它能够有效地解决服务间的解耦、异步处理、流量削峰等问题。下面将详细介绍几种常用的消息队列，并结合项目经验，阐述如何在实际项目中实现和使用它们。

RabbitMQ

特点:

• 协议: 基于AMQP（Advanced Message Queuing Protocol）协议，它是一个开放标准的协议，支持跨语言、跨平台的通信。
• 路由机制: 拥有灵活的路由机制，包括直连交换机（direct）、扇形交换机（fanout）、主题交换机（topic）和头交换机（headers）。
• 可靠性: 提供了多种可靠性保障机制，如消息持久化、发布确认（publisher confirms）、消费者确认（consumer acknowledges）等。
• 上手难度: 相对简单，文档完善，社区活跃。

实现方式:

RabbitMQ的核心是Broker、Exchange、Queue和Binding。

1. 生产者:
   • 与RabbitMQ Broker建立连接。
   • 创建一个Channel。
   • 声明一个Exchange（交换机），指定类型（如direct、fanout、topic）。
   • 将消息发送到Exchange，并指定Routing Key。
2. 消费者:
   • 与RabbitMQ Broker建立连接。
   • 创建一个Channel。
   • 声明一个Queue（队列）。
   • 将Queue通过Binding绑定到指定的Exchange，并指定Binding Key。
   • 开始消费Queue中的消息。

项目中应用:

在prism vision短剧平台中，RabbitMQ可以用于以下场景：

• 视频转码: 用户上传短剧视频后，后端服务将转码任务（包括视频ID、分辨率、码率等信息）封装成消息，发送到RabbitMQ的Exchange。转码服务作为消费者，从队列中获取任务并进行异步转码，完成后将转码结果更新到数据库。
• 异步通知: 用户完成支付后，支付服务发送一条支付成功消息到RabbitMQ。通知服务作为消费者，接收到消息后，异步地发送短信、邮件或站内信通知用户。

Kafka

特点:

• 高吞吐量: Kafka最初是为日志处理设计的，因此具有极高的吞吐量，能够处理每秒百万级别的消息。
• 分布式: 具有良好的分布式特性，通过分区（Partition）和副本（Replica），可以实现水平扩展和高可用。
• 消息持久化: 消息以追加日志（log）的方式存储在磁盘上，具有极高的持久性。
• 流处理: 支持实时流处理，可以与Flink、Spark等流处理框架集成。
• 上手难度: 相对RabbitMQ复杂，但性能更优。

实现方式:

Kafka的核心是Broker、Topic、Partition和Consumer Group。

1. 生产者:
   • 连接Kafka Broker。
   • 创建Producer实例。
   • 将消息发送到指定的Topic，Kafka会根据分区策略将消息写入不同的Partition。
2. 消费者:
   • 连接Kafka Broker。
   • 创建Consumer实例，并指定Consumer Group。
   • 订阅指定的Topic。
   • Kafka会确保同一Consumer Group下的不同消费者消费同一个Partition的消息，从而实现负载均衡。

项目中应用:

在prism vision短剧平台中，Kafka可以用于以下场景：

• 日志收集与分析: 将所有微服务的日志（包括访问日志、错误日志、业务日志）都发送到Kafka。后端通过Logstash等工具消费这些日志，进行实时分析和存储，以便后续的监控和问题排查。
• 大数据分析: 收集用户行为数据（如观看历史、点赞、评论），发送到Kafka。流处理平台（如Spark Streaming）可以消费这些数据，进行实时推荐、用户画像等大数据分析。

Redis

特点:

• 简单: Redis的List数据结构可以作为简单的消息队列使用。
• 内存存储: 消息存储在内存中，读写速度极快。
• 非正式: Redis并非专业的MQ，不具备复杂的路由、持久化、确认机制等。

实现方式:

使用Redis的List数据结构，通过lpush（左侧入队）和rpop（右侧出队）命令，可以实现一个简单的消息队列。

1. 生产者:
   • 连接Redis。
   • 使用lpush key message命令，将消息推入队列。
2. 消费者:
   • 连接Redis。
   • 使用rpop key命令，从队列中获取消息。

项目中应用:

在prism vision短剧平台中，Redis可以用于以下场景：

• 短时任务队列: 对于一些对可靠性要求不高，但对速度要求极高的任务，例如后台的异步计算、统计等，可以使用Redis作为轻量级的消息队列。
• 秒杀队列: 在秒杀活动中，将所有下单请求都推入Redis队列，后端服务按顺序消费，从而实现流量削峰和库存超卖控制。

总结

在选择消息队列时，需要根据实际业务需求进行权衡：

• 如果需要强大的路由功能、完善的可靠性保障，且消息量适中，RabbitMQ是不错的选择。
• 如果需要处理海量的消息、追求极高的吞吐量和并发，且需要进行实时流处理，Kafka是更佳的选择。
• 如果只是需要一个轻量级的、简单的异步任务队列，且对可靠性要求不高，Redis也可以作为一种快速的解决方案。

一、网络基础概念

1. 网络的定义
   网络是多个计算机及通信设备通过通信介质互联的系统，用于信息传输、资源共享、协同工作。
   • 核心目标：可靠、高效、可扩展的数据传输。
   • 设计原则：分层、模块化、接口标准化。
2. 数据传输方式
   • 单工：单向传输（电视广播）。
   • 半双工：双向传输，但不能同时发送（对讲机）。
   • 全双工：双向同时传输（电话、以太网交换机端口）。
3. 通信方式
   • 点对点：两个节点直接通信（PPP）。
   • 广播：单点发送，多点接收（Ethernet）。
   • 组播：单点发送，特定组接收（IP 多播）。
4. 网络分类
   • 按地理范围：LAN、MAN、WAN。
   • 按拓扑结构：星型、总线型、环型、混合型。
   • 按访问控制方式：CSMA/CD（Ethernet）、令牌环（Token Ring）。

二、OSI 七层模型

OSI 模型将网络通信划分为七层，每层负责特定功能，确保模块化与互操作性。

1. 物理层深度

• 电气特性：电压幅值、频率、信号调制。
• 传输介质差异：
  • 铜缆（双绞线、同轴）: 成本低、易干扰。
  • 光纤: 高速、长距离、抗电磁干扰。
• 面试常问：光纤单模和多模区别、网卡速率、半双工/全双工。

2. 数据链路层深度

• MAC 地址：唯一标识网卡，48 位（前 24 位厂商号，后 24 位设备号）。
• 流量控制：
  • 停止等待（Stop-and-Wait）
  • 滑动窗口（Sliding Window）
• 差错控制：CRC 校验、帧校验序列 (FCS)。
• VLAN：逻辑分隔网络，减少广播风暴。

3. 网络层深度

• 逻辑寻址：IPv4/IPv6
• 子网划分：CIDR、VLSM。
• 路由协议：
  • RIP：跳数最短，收敛慢。
  • OSPF：链路状态，快速收敛。
  • BGP：自治系统间，策略路由。
• NAT：私网 IP 转换为公网 IP，节约 IP。

4. 传输层深度

TCP

• 可靠性机制：
  • 序列号与确认号。
  • 滑动窗口。
  • 重传机制（超时/快速重传）。
• 三次握手（建立连接）
  • 第一次 (SYN)：客户端请求，seq=client_ISN。
  • 第二次 (SYN-ACK)：服务器确认客户端，seq=server_ISN, ack=client_ISN+1。
  • 第三次 (ACK)：客户端确认服务器，ack=server_ISN+1。
• 四次挥手（断开连接）
  • FIN/ACK 交替关闭双向。
  • TIME_WAIT: 2MSL，保证最后 ACK 到达并避免旧报文干扰。
• 流量控制：滑动窗口
• 拥塞控制：慢启动、拥塞避免、快速重传、快速恢复。

UDP

• 特点：无连接、无序、不保证到达。
• 应用：DNS、VoIP、视频直播。
• 优点：低延迟、开销小。

5. 会话层深度

• 会话管理：
  • 会话建立、保持、终止。
  • 数据同步点（断点续传）。
• 面试点：HTTP 是无状态协议，如何实现会话保持？（Cookie/Session/Token）

6. 表示层深度

• 数据格式化：ASCII、Unicode、EBCDIC。
• 压缩/解压：JPEG、MPEG、ZIP。
• 加密/解密：TLS/SSL，实现安全通信。
• 面试点：大端小端，Base64 编码。

7. 应用层深度

• HTTP：
  • 请求方法：GET/POST/PUT/DELETE/OPTIONS。
  • 状态码：1xx-5xx。
• DNS：
  • 查询类型：A/AAAA/CNAME/MX。
  • 递归/迭代查询。
• SMTP/POP3/IMAP：
  • 发送与接收流程。
• 面试点：
  • FTP 主动/被动模式差异。
  • HTTPS 握手流程（证书交换 + 对称密钥）。

三、TCP/IP 协议族（详细版）

TCP 三次握手总结

1. 客户端发送 SYN，告知初始序列号。
2. 服务器返回 SYN-ACK，确认收到 SYN 并告知自身序列号。
3. 客户端 ACK 确认，双方 ESTABLISHED。

TCP 四次挥手总结

1. 主动方 FIN，关闭发送。
2. 被动方 ACK，确认。
3. 被动方 FIN，关闭发送。
4. 主动方 ACK，进入 TIME_WAIT，等待 2MSL。

好的，我们可以把“面试重点提示”部分拆解得更深入，每一点都加上原理、实现机制、典型面试问法及回答要点，让你在面试中不仅会答，还能讲出背后的原因。

一、TCP 与 UDP 区别（深入版）

面试问法示例：

• “TCP 为什么可靠，UDP 为什么不可靠？”
  回答要点：TCP 使用序列号、ACK 确认、重传机制、流量控制和拥塞控制来保证可靠性；UDP 没有这些机制，直接发送报文，速度快，但不保证到达和顺序。

二、三次握手的意义（深入版）

三次握手步骤复习：

1. 客户端 → 服务器：SYN 报文，请求建立连接，发送 client_ISN。
2. 服务器 → 客户端：SYN-ACK 报文，确认客户端 SYN，并发送 server_ISN。
3. 客户端 → 服务器：ACK 报文，确认 server_ISN，连接建立。

为什么需要三次握手？

1. 防止旧连接报文误建
   • 如果只有两次握手，旧的 SYN 报文可能延迟到达，服务器误认为是新连接。
   • 三次握手确保客户端主动确认，服务器不会因为旧报文进入 ESTABLISHED。
2. 双向确认收发能力
   • 第一次握手：客户端告诉服务器它能发。
   • 第二次握手：服务器告诉客户端它能发，也确认客户端能发。
   • 第三次握手：客户端确认服务器能收。
   • 面试常问拓展：为什么第一次握手服务器不直接进入 ESTABLISHED？
     答案：服务器不能确定客户端已经准备好接收数据，需第三次握手确认。

三、TIME_WAIT 的意义（深入版）

• TCP 四次挥手后客户端进入 TIME_WAIT
• 作用：
  1. 确保最后 ACK 能到达服务器
     • 如果 ACK 丢失，服务器会重发 FIN，客户端在 TIME_WAIT 状态可以重新响应。
  2. 防止旧报文干扰新连接
     • 2MSL（Maximum Segment Lifetime）内保证网络中旧报文被清除。
• 典型面试问法：
  • “为什么客户端主动关闭连接进入 TIME_WAIT，而服务器不进入？”
    答案：主动关闭方需要确保 ACK 能到达被动关闭方并防止旧报文干扰新连接；被动关闭方在收到 ACK 后即可关闭。
  • “TIME_WAIT 为什么要等待 2MSL？”
    答案：MSL 是报文在网络中的最大生存时间，等待 2MSL 可以确保所有可能滞留的报文消失。

四、OSI 七层 vs TCP/IP 模型（深入版）

OSI 与 TCP/IP 对应关系：

• OSI 应用/表示/会话层 → TCP/IP 应用层
• OSI 传输层 → TCP/IP 传输层
• OSI 网络层 → TCP/IP 网络层
• OSI 数据链路层 + 物理层 → TCP/IP 网络接口层

面试拓展点：

1. TCP/IP 为什么只有 4 层？
   • 因为实际应用中，表示层与会话层功能通常由应用层实现，硬件设备的物理和链路层可合并。
2. OSI 模型为什么重要？
   • 理论指导，帮助理解网络通信分层设计、模块化、互操作性。
3. 面试常问：OSI 七层模型每层面试问法示例
   • 物理层：双绞线和光纤区别？全双工和半双工区别？
   • 数据链路层：MAC 地址格式？交换机与网桥区别？VLAN 原理？
   • 网络层：IP 地址分类？子网掩码？RIP vs OSPF？
   • 传输层：TCP/UDP 区别？三次握手流程？滑动窗口原理？
   • 会话层：HTTP 无状态如何实现会话保持？
   • 表示层：编码转换？大端小端？TLS 加密流程？
   • 应用层：HTTP 状态码？FTP 主动/被动模式？DNS 查询过程？

1. 物理层

Q1：双绞线和光纤区别？
A1：

Q2：全双工和半双工区别？
A2：

• 半双工：数据双向传输，但同一时间只能一个方向（如对讲机）。
• 全双工：数据双向传输，可同时收发（如现代交换机端口）。
  面试要点：半双工容易冲突，需要 CSMA/CD，降低效率；全双工无需冲突检测，速率翻倍。

2. 数据链路层

Q1：MAC 地址格式？
A1：

• 48 位二进制，通常写作 6 组十六进制：00:1A:2B:3C:4D:5E
• 前 24 位：厂商标识（OUI）
• 后 24 位：网卡序列号
• 唯一标识网卡设备
  面试要点：MAC 地址用于局域网内通信，交换机通过 MAC 表转发帧。

Q2：交换机与网桥区别？

Q3：VLAN 原理？
A3：

• 虚拟局域网（Virtual LAN）在同一物理交换机上划分不同逻辑网段。
• 通过 802.1Q 标签 给帧打标签，实现逻辑隔离。
• 优点：隔离广播域，提高安全性和管理性。
  面试要点：同一交换机内不同 VLAN 之间通信需要路由器或三层交换机。

3. 网络层

Q1：IP 地址分类？

Q2：子网掩码作用？

• 用于区分网络号和主机号。
• 通过按位与运算确定同一网段内主机。
• 面试问法：给 IP/子网掩码计算可用主机数或广播地址。

Q3：RIP vs OSPF

4. 传输层

Q1：TCP/UDP 区别
详见上条回答。

Q2：三次握手流程
详见上条回答，可画图辅助说明。

Q3：滑动窗口原理

• TCP 使用滑动窗口进行流量控制。
• 发送方可发送窗口大小内的数据而不必等待 ACK。
• 接收方通过窗口大小告知可接收缓冲区容量。
• 好处：提高链路利用率，避免频繁等待确认。
• 面试问法：滑动窗口与停止等待区别？答案：滑动窗口一次可发送多段，停止等待一次只能发送一段。

5. 会话层

Q1：HTTP 无状态如何实现会话保持？

• HTTP 本身无状态，每次请求独立。
• 实现方式：
  1. Cookie：客户端保存会话 ID，随请求发送。
  2. Session：服务端保存用户状态，客户端发送标识。
  3. Token/JWT：无状态方式，将用户信息加密放在客户端。
• 面试要点：讲清楚“状态存放位置”和“优缺点”。

6. 表示层

Q1：编码转换

• ASCII、UTF-8、Unicode 等，用于不同系统间字符表示兼容。
• 面试问法：中文 UTF-8 编码占多少字节？
  答案：汉字 3 字节，英文 1 字节。

Q2：大端小端

• 大端（Big Endian）：高位字节存放在低地址。
• 小端（Little Endian）：低位字节存放在低地址。
• 面试问法：网络传输使用哪种？
  答案：大端（网络字节序）。

Q3：TLS 加密流程

1. 客户端发送 ClientHello（支持加密算法）。
2. 服务器返回 ServerHello，发送证书。
3. 客户端验证证书，生成会话密钥。
4. 双方用会话密钥加密通信。

• 面试要点：讲清楚“证书验证”和“对称密钥加密数据”。

7. 应用层

Q1：HTTP 状态码

Q2：FTP 主动/被动模式

• 主动模式：客户端建立控制连接，服务器主动建立数据连接。
• 被动模式：客户端建立控制连接和数据连接，服务器被动监听。
• 面试要点：被动模式用于客户端在防火墙后的情况。

Q3：DNS 查询过程

1. 客户端向本地 DNS 发起递归查询。
2. 本地 DNS 如果缓存没有，向根 DNS 查询 → 顶级域 → 权威 DNS。
3. 权威 DNS 返回解析结果到本地 DNS，本地返回给客户端。

• 面试要点：递归查询 vs 迭代查询区别。

一、前后端交互的基本流程

1. 前端发起请求
   • 用户在浏览器或客户端操作，比如点击按钮、提交表单。
   • 前端通过 HTTP/HTTPS 或 WebSocket 向后端发送请求。
   • 请求包含：URL、请求方法（GET/POST/PUT/DELETE 等）、请求头（Header）、请求体（Body，POST/PUT 时）和参数。
2. 后端接收请求
   • 后端服务器（如 Java/Spring、Node.js、Python Flask/Django）解析请求。
   • 后端根据 URL 路径、HTTP 方法匹配路由到对应的处理函数（Controller/Handler）。
3. 后端处理请求
   • 后端进行业务逻辑处理：
     • 数据库查询/更新（CRUD）
     • 调用其他服务或 API
     • 数据验证、权限校验
   • 处理完成后，生成响应数据（通常为 JSON、XML、HTML 或二进制文件）。
4. 后端返回响应
   • 响应包含：状态码（HTTP Status Code）、响应头、响应体（Body）。
   • 状态码示例：
     • 200 OK：请求成功
     • 201 Created：资源创建成功
     • 400 Bad Request：请求错误
     • 401 Unauthorized：未授权
     • 500 Internal Server Error：服务器错误
5. 前端接收响应
   • 前端根据状态码判断请求结果。
   • 前端解析响应体并更新界面（UI），例如渲染数据表格、显示提示信息。
   • 如果是异步请求（AJAX/Fetch/axios），前端可以在回调或 Promise 中处理响应。

二、前后端交互方式

1. HTTP 请求-响应模式

• 同步请求（传统表单提交）：浏览器提交表单，等待响应页面刷新。
• 异步请求（AJAX/Fetch/axios）：页面不刷新，通过 JavaScript 异步获取数据。

2. WebSocket 实时通信

• 前端与后端建立长连接。
• 可以实时双向通信，不需要每次都发 HTTP 请求。
• 适用场景：聊天应用、在线游戏、实时监控。

3. Server-Sent Events（SSE）

• 后端主动向前端推送事件流。
• 单向通信（后端 → 前端）。
• 适用于消息通知、实时数据更新。

4. GraphQL

• 前端发送一个查询请求，后端根据查询返回精确的数据。
• 相比 REST，可以减少冗余数据传输。

三、前后端响应示例

前端（JavaScript fetch）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

fetch("https://api.example.com/users", {
    method: "GET",
    headers: {
        "Content-Type": "application/json"
    }
})
.then(response => {
    if (!response.ok) throw new Error("网络错误");
    return response.json();
})
.then(data => {
    console.log("用户数据:", data);
})
.catch(err => {
    console.error("请求失败:", err);
});

后端（Node.js/Express）：

1
2
3
4
5
6
7

app.get("/users", (req, res) => {
    const users = [
        {id: 1, name: "Alice"},
        {id: 2, name: "Bob"}
    ];
    res.status(200).json(users);
});

• 前端发起 GET 请求 → 后端返回 JSON → 前端解析 JSON 更新页面。

四、状态码与响应流程

Linux

好的，我来给你整理一份 Linux 常见知识点清单，涵盖基础命令、系统管理、权限、网络、进程、文件系统等方面，适合面试或日常运维参考。我会按模块整理，并给出重点说明。

一、基础命令

1. 文件和目录操作

2. 文件查看与编辑

二、用户与权限管理

1. 用户管理

2. 权限管理

三、进程管理

四、网络管理

五、包管理

• Debian/Ubuntu 系列：
  • apt update / apt upgrade
  • apt install <package> / apt remove <package>
• RedHat/CentOS 系列：
  • yum install <package> / yum remove <package>
  • dnf（新版本替代 yum）

六、磁盘与文件系统管理

七、日志管理

八、系统管理

九、压缩与解压

十、Shell 脚本基础（详细版）

1. 变量

• 定义变量：

1
2

NAME="Charlotte"
AGE=25

• 访问变量：

1

echo $NAME

• 只读变量：

1

readonly NAME

• 环境变量：

1

export PATH=$PATH:/new/path

2. 条件判断

• if 语句：

1
2
3
4
5

if [ $AGE -ge 18 ]; then
    echo "成年人"
else
    echo "未成年人"
fi

• 常用条件表达式：

  表达式	含义
  -eq	等于
  -ne	不等于
  -gt	大于
  -lt	小于
  -ge	大于等于
  -le	小于等于
  -f filename	文件存在且为普通文件
  -d dirname	目录存在
  -x filename	可执行文件

3. 循环语句

• for 循环：

1
2
3

for i in 1 2 3 4 5; do
    echo "第 $i 次循环"
done

• while 循环：

1
2
3
4
5

count=1
while [ $count -le 5 ]; do
    echo "计数 $count"
    count=$((count+1))
done

• until 循环：

1
2
3
4
5

count=1
until [ $count -gt 5 ]; do
    echo "计数 $count"
    count=$((count+1))
done

4. 函数

1
2
3
4

greet() {
    echo "Hello, $1"
}
greet "Charlotte"

• $1 表示函数传入的第一个参数
• $@ 表示所有参数
• return 返回状态码（0表示成功，非0表示失败）

5. 输入输出

• 标准输入/输出/错误：

1
2
3

echo "Hello"         # stdout
read name            # stdin
ls nonexist 2> error.log  # stderr重定向

• 管道与重定向：

1

cat file.txt | grep "hello" > result.txt

6. 脚本执行权限

1
2

chmod +x script.sh
./script.sh

7. 实用示例

1
2
3
4

#!/bin/bash
# 统计当前目录下所有文件数
count=$(ls -l | grep "^-" | wc -l)
echo "当前目录文件数量: $count"

十一、Linux 面试常问知识点（全面版）

1. 文件权限与权限管理

核心知识点：

• 权限类型：读（r）、写（w）、执行（x）
• 三类用户：
  • 拥有者（u）
  • 用户组（g）
  • 其他用户（o）
• 权限表示：
  • 符号表示法：rwxr-xr-x
  • 数字表示法：chmod 755 file → 7=rw, x; 5=r-x; 5=r-x

面试常问问题：

1. 命令 chmod、chown、chgrp 有什么作用？

   • chmod：修改权限
   • chown：修改文件所有者
   • chgrp：修改文件所属组

2. 硬链接和软链接区别？

   项目	硬链接	软链接
   inode	相同	不同
   跨分区	不行	可以
   删除原文件	内容仍存在	链接失效
   命令	ln source target	ln -s source target

3. 文件描述符和重定向

   • 0 stdin, 1 stdout, 2 stderr
   • 示例：command > out.log 2>&1 → stdout 和 stderr 都写入 out.log

2. 进程与作业管理

核心知识点：

• 查看进程：
  • ps aux、top、htop
• 结束进程：
  • kill PID、kill -9 PID、killall process_name
• 后台/前台任务：
  • &：后台执行
  • jobs：查看后台任务
  • fg %1：切换到前台
• 优先级：
  • nice、renice 设置 CPU 优先级

面试常问问题：

1. 如何查看端口被哪个进程占用？

   1 2 3

   lsof -i :8080 netstat -tulpn | grep 8080 ss -tulpn | grep 8080

2. 如何终止占用端口的进程？

   1	kill -9 PID

3. 文件系统与磁盘管理

核心知识点：

• df -h 查看磁盘空间
• du -h 查看目录大小
• lsblk 查看分区信息
• mount / umount 挂载卸载
• fdisk / parted 分区
• mkfs 格式化文件系统
• fsck 检查文件系统

面试常问问题：

1. 硬链接和软链接在文件系统中有什么区别？

2. 如何查看磁盘空间和使用情况？

   1 2	df -h du -sh /path/to/dir

4. 网络管理

核心知识点：

• 查看 IP 地址：ifconfig / ip addr
• 测试连通性：ping
• 路由追踪：traceroute / tracepath
• 查看端口和连接：netstat / ss
• 下载文件或请求 URL：wget / curl
• 远程文件传输：scp / rsync

面试常问问题：

1. 如何查看网卡信息？

   1 2	ip addr show ifconfig -a

2. 如何调试网络连通性？

   1 2	ping 8.8.8.8 traceroute www.baidu.com

3. 如何查看 8080 端口占用？

   1	ss -tulpn | grep 8080

5. 用户与组管理

核心知识点：

• 添加用户：useradd
• 删除用户：userdel
• 修改用户：usermod -aG group user
• 修改密码：passwd user
• 查看组信息：groups user
• 提权命令：sudo command

面试常问问题：

1. 如何给用户加入某个组？

   1	usermod -aG dev user

2. 如何限制用户权限？

   • 使用 chmod 设置文件权限
   • 使用 sudoers 配置命令权限

6. Shell 脚本基础

核心知识点：

• 变量、条件判断、循环、函数
• 管道、重定向、标准输入输出
• 常用脚本示例：

1
2
3
4

#!/bin/bash
for file in *.log; do
    echo "处理文件: $file"
done

面试常问问题：

1. 如何判断文件是否存在？

1
2
3

if [ -f "/path/to/file" ]; then
    echo "文件存在"
fi

1. 如何统计目录下文件数量？

1
2

count=$(ls -l | grep "^-" | wc -l)
echo $count

7. 定时任务（Crontab）

核心知识点：

• 查看：crontab -l
• 编辑：crontab -e
• 时间格式：

1
2

* * * * * command
分 时 日 月 星期

• 示例：每天凌晨 2 点备份

1

0 2 * * * /home/user/backup.sh

8. 系统日志

核心知识点：

• 常用日志路径：

  文件	内容
  /var/log/messages	系统事件
  /var/log/syslog	系统服务日志
  /var/log/auth.log	登录/认证日志
  /var/log/kern.log	内核日志
  journalctl	systemd 日志

• 查看日志：

1
2

tail -f /var/log/syslog
journalctl -xe

9. 系统管理

核心知识点：

• 系统信息：uname -a
• 内存查看：free -h
• CPU/资源统计：top / vmstat
• 服务管理：systemctl start/stop/restart/status service
• 系统启动流程：BIOS → Bootloader → Kernel → init/systemd → 多用户模式

面试常问问题：

1. 如何查看系统运行时间？

1

shelluptime

1. 如何管理系统服务？

1
2
3

systemctl restart nginx
systemctl enable nginx
systemctl status nginx

10. 综合示例（面试题）

1. 如何查找占用 CPU 前 5 的进程？

1

ps aux --sort=-%cpu | head -n 6

2.如何查找 1 小时内修改过的文件？

1

find /path/to/dir -type f -mmin -60

3.如何将错误日志和输出日志写入同一个文件？

1

command > all.log 2>&1

4.如何给用户添加 sudo 权限？

1

usermod -aG sudo username

MySQL 数据库

SQL语句

1. DML (Data Manipulation Language) — 数据操作

用于操作数据库中的数据。

1.1 SELECT 查询

1
2
3
4
5
6

-- 查询指定列，并对结果排序、分页
SELECT column1, column2
FROM table_name
WHERE condition         -- 过滤条件
ORDER BY column DESC    -- 按列排序，可 ASC 或 DESC
LIMIT offset, count;    -- 分页查询，offset: 偏移量, count: 返回行数

聚合函数

1
2
3

SELECT COUNT(*), SUM(column), AVG(column), MAX(column), MIN(column)
FROM table_name
WHERE condition;

分组查询

1
2
3
4

SELECT column, COUNT(*)
FROM table_name
GROUP BY column       -- 按 column 分组
HAVING COUNT(*) > 1; -- 分组过滤

联接查询 (JOIN)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

-- 内连接，只返回两个表中匹配的行
SELECT a.*, b.*
FROM table_a a
INNER JOIN table_b b ON a.id = b.a_id;

-- 左连接，返回左表所有行及匹配右表的行
SELECT a.*, b.*
FROM table_a a
LEFT JOIN table_b b ON a.id = b.a_id;

-- 右连接，返回右表所有行及匹配左表的行
SELECT a.*, b.*
FROM table_a a
RIGHT JOIN table_b b ON a.id = b.a_id;

-- 全连接 (MySQL 不直接支持，用 UNION ALL 模拟)
SELECT a.*, b.*
FROM table_a a
LEFT JOIN table_b b ON a.id = b.a_id
UNION ALL
SELECT a.*, b.*
FROM table_a a
RIGHT JOIN table_b b ON a.id = b.a_id
WHERE a.id IS NULL;

1.2 INSERT 插入

1
2
3
4
5
6
7

-- 指定列插入
INSERT INTO table_name (column1, column2)
VALUES (value1, value2);

-- 插入所有列
INSERT INTO table_name
VALUES (value1, value2, ...);

1.3 UPDATE 更新

1
2
3
4

UPDATE table_name
SET column1 = value1,
    column2 = value2
WHERE condition;  -- 必须加 WHERE，否则会更新所有行

1.4 DELETE 删除

1
2

DELETE FROM table_name
WHERE condition; -- 不加 WHERE 会删除所有行，比 TRUNCATE TABLE 慢

2. DDL (Data Definition Language) — 数据定义

用于创建、修改和删除数据库对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

-- 创建数据库
CREATE DATABASE database_name;

-- 创建表
CREATE TABLE table_name (
    column1 datatype constraints,
    column2 datatype constraints,
    PRIMARY KEY (column_name)
);

-- 修改表结构
ALTER TABLE table_name ADD column_name datatype;
ALTER TABLE table_name DROP COLUMN column_name;
ALTER TABLE table_name MODIFY COLUMN column_name datatype;

-- 删除表
DROP TABLE table_name;

-- 索引操作
CREATE INDEX index_name ON table_name (column_name);
DROP INDEX index_name ON table_name;

3. DCL (Data Control Language) — 数据权限控制

1
2
3
4
5

-- 授权
GRANT privileges ON database.table TO 'user'@'host';

-- 撤销权限
REVOKE privileges ON database.table FROM 'user'@'host';

4. TCL (Transaction Control Language) — 事务控制

1
2
3
4
5
6
7
8
9
10
11

-- 开始事务
START TRANSACTION; -- 或 BEGIN;

-- 提交事务
COMMIT;

-- 回滚事务
ROLLBACK;

-- 设置保存点
SAVEPOINT savepoint_name;

5. EXPLAIN 查询分析 — SQL 优化核心工具

用于分析 SELECT（或 DML）语句的执行计划，判断是否使用索引，以及优化查询性能。

1

EXPLAIN SELECT * FROM table_name WHERE condition;

5.1 EXPLAIN 核心字段解析

5.2 type 类型说明（访问方式）