\":()V\n 13: aload_1\n 14: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;\n 17: aload_2\n 18: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;\n 21: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;\n 24: astore_3\n 25: return\n```\n\n\n也就是说，上面的代码相当于：\n\n\n```java\nString a = \"hello \";\nString b = \"world!\";\nStringBuilder sb = new StringBuilder();\nsb.append(a);\nsb.append(b);\nString ab = sb.toString();\n```\n\n\n因此，如果笼统地讲，通过加号拼接字符串时会创建多个 String 对象是不准确的。因为加号拼接在编译期还会创建一个 StringBuilder 对象，最终调用 `toString()` 方法的时候再返回一个新的 String 对象。\n\n\n```java\n@Override\npublic String toString() {\n // Create a copy, don't share the array\n return new String(value, 0, count);\n}\n```\n\n\n那除了使用 `+` 号来拼接字符串，还有 `StringBuilder.append()`、`String.join()` 等方式。\n\n#### [如何保证 String 不可变？](#如何保证-string-不可变)\n\n第一，String 类内部使用一个私有的字符数组来存储字符串数据。这个字符数组在创建字符串时被初始化，之后不允许被改变。\n\n\n```java\nprivate final char value[];\n```\n\n\n第二，String 类没有提供任何可以修改其内容的公共方法，像 concat 这些看似修改字符串的操作，实际上都是返回一个新创建的字符串对象，而原始字符串对象保持不变。\n\n\n```java\npublic String concat(String str) {\n if (str.isEmpty()) {\n return this;\n }\n int len = value.length;\n int otherLen = str.length();\n char buf[] = Arrays.copyOf(value, len + otherLen);\n str.getChars(buf, len);\n return new String(buf, true);\n}\n```\n\n\n第三，String 类本身被声明为 final，这意味着它不能被继承。这防止了子类可能通过添加修改方法来改变字符串内容的可能性。\n\n\n```java\npublic final class String\n```"
+ },
+ {
+ "id": 37,
+ "question": "intern 方法有什么作用？",
+ "answer": "JDK 源码里已经对这个方法进行了说明：\n\n\n```java\n* \n* When the intern method is invoked, if the pool already contains a\n* string equal to this {@code String} object as determined by\n* the {@link #equals(Object)} method, then the string from the pool is\n* returned. Otherwise, this {@code String} object is added to the\n* pool and a reference to this {@code String} object is returned.\n*
\n```\n\n\n意思也很好懂：\n\n* 如果当前字符串内容存在于字符串常量池（即 equals()方法为 true，也就是内容一样），直接返回字符串常量池中的字符串\n* 否则，将此 String 对象添加到池中，并返回 String 对象的引用"
+ }
+ ]
+ },
+ {
+ "id": 5,
+ "categoryName": "Integer",
+ "questions": [
+ {
+ "id": 38,
+ "question": "Integer a= 127，Integer b = 127；Integer c= 128，Integer d = 128；相等吗?",
+ "answer": "a 和 b 相等，c 和 d 不相等。\n\n这个问题涉及到 Java 的自动装箱机制以及`Integer`类的缓存机制。\n\n对于第一对：\n\n\n```java\nInteger a = 127;\nInteger b = 127;\n```\n\n\n`a`和`b`是相等的。这是因为 Java 在自动装箱过程中，会使用`Integer.valueOf()`方法来创建`Integer`对象。\n\n`Integer.valueOf()`方法会针对数值在-128 到 127 之间的`Integer`对象使用缓存。因此，`a`和`b`实际上引用了常量池中相同的`Integer`对象。\n\n对于第二对：\n\n\n```java\nInteger c = 128;\nInteger d = 128;\n```\n\n\n`c`和`d`不相等。这是因为 128 超出了`Integer`缓存的范围(-128 到 127)。\n\n因此，自动装箱过程会为`c`和`d`创建两个不同的`Integer`对象，它们有不同的引用地址。\n\n可以通过`==`运算符来检查它们是否相等：\n\n\n```java\nSystem.out.println(a == b); // 输出true\nSystem.out.println(c == d); // 输出false\n```\n\n\n要比较`Integer`对象的数值是否相等，应该使用`equals`方法，而不是`==`运算符：\n\n\n```java\nSystem.out.println(a.equals(b)); // 输出true\nSystem.out.println(c.equals(d)); // 输出true\n```\n\n\n使用`equals`方法时，`c`和`d`的比较结果为`true`，因为`equals`比较的是对象的数值，而不是引用地址。\n\n#### [什么是 Integer 缓存？](#什么是-integer-缓存)\n\n就拿 Integer 的缓存吃来说吧。根据实践发现，大部分的数据操作都集中在值比较小的范围，因此 Integer 搞了个缓存池，默认范围是 -128 到 127。\n\n\n\n当我们使用自动装箱来创建这个范围内的 Integer 对象时，Java 会直接从缓存中返回一个已存在的对象，而不是每次都创建一个新的对象。这意味着，对于这个值范围内的所有 Integer 对象，它们实际上是引用相同的对象实例。\n\nInteger 缓存的主要目的是优化性能和内存使用。对于小整数的频繁操作，使用缓存可以显著减少对象创建的数量。\n\n可以在运行的时候添加 `-Djava.lang.Integer.IntegerCache.high=1000` 来调整缓存池的最大值。\n\n\n\n引用是 Integer 类型，= 右侧是 int 基本类型时，会进行自动装箱，调用的其实是 `Integer.valueOf()`方法，它会调用 IntegerCache。\n\n\n```java\npublic static Integer valueOf(int i) {\n if (i >= IntegerCache.low && i <= IntegerCache.high)\n return IntegerCache.cache[i + (-IntegerCache.low)];\n return new Integer(i);\n}\n```\n\n\nIntegerCache 是一个静态内部类，在静态代码块中会初始化好缓存的值。\n\n\n```java\nprivate static class IntegerCache {\n ……\n static {\n //创建Integer对象存储\n for(int k = 0; k < cache.length; k++)\n cache[k] = new Integer(j++);\n ……\n }\n}\n```\n\n\n#### [new Integer(10) == new Integer(10) 相等吗](#new-integer-10-new-integer-10-相等吗)\n\n在 Java 中，使用`new Integer(10) == new Integer(10)`进行比较时，结果是 false。\n\n这是因为 new 关键字会在堆（Heap）上为每个 Integer 对象分配新的内存空间，所以这里创建了两个不同的 Integer 对象，它们有不同的内存地址。\n\n当使用==运算符比较这两个对象时，实际上比较的是它们的内存地址，而不是它们的值，因此即使两个对象代表相同的数值（10），结果也是 false。"
+ },
+ {
+ "id": 39,
+ "question": "String 怎么转成 Integer 的？原理？",
+ "answer": "PS:这道题印象中在一些面经中出场过几次。\n\nString 转成 Integer，主要有两个方法：\n\n* Integer.parseInt(String s)\n* Integer.valueOf(String s)\n\n不管哪一种，最终还是会调用 Integer 类内中的`parseInt(String s, int radix)`方法。\n\n抛去一些边界之类的看看核心代码：\n\n\n```java\npublic static int parseInt(String s, int radix)\n throws NumberFormatException\n {\n\n int result = 0;\n //是否是负数\n boolean negative = false;\n //char字符数组下标和长度\n int i = 0, len = s.length();\n ……\n int digit;\n //判断字符长度是否大于0，否则抛出异常\n if (len > 0) {\n ……\n while (i < len) {\n // Accumulating negatively avoids surprises near MAX_VALUE\n //返回指定基数中字符表示的数值。（此处是十进制数值）\n digit = Character.digit(s.charAt(i++),radix);\n //进制位乘以数值\n result *= radix;\n result -= digit;\n }\n }\n //根据上面得到的是否负数，返回相应的值\n return negative ? result : -result;\n }\n```\n\n\n去掉枝枝蔓蔓（当然这些枝枝蔓蔓可以去看看，源码 cover 了很多情况），其实剩下的就是一个简单的字符串遍历计算，不过计算方式有点反常规，是用负的值累减。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 6,
+ "categoryName": "Object",
+ "questions": [
+ {
+ "id": 40,
+ "question": "Object 类的常见方法？",
+ "answer": "在 Java 中，经常提到一个词“万物皆对象”，其中的“万物”指的是 Java 中的所有类，而这些类都是 Object 类的子类。\n\nObject 主要提供了 11 个方法，大致可以分为六类：\n\n\n\n#### [对象比较：](#对象比较)\n\n①、`public native int hashCode()` ：，用于返回对象的哈希码。\n\n\n```java\npublic native int hashCode();\n```\n\n\n按照约定，相等的对象必须具有相等的哈希码。如果重写了 equals 方法，就应该重写 hashCode 方法。可以使用 方法来生成哈希码。\n\n\n```java\npublic int hashCode() {\n return Objects.hash(name, age);\n}\n```\n\n\n②、`public boolean equals(Object obj)`：用于比较 2 个对象的内存地址是否相等。\n\n\n```java\npublic boolean equals(Object obj) {\n return (this == obj);\n}\n```\n\n\n如果比较的是两个对象的值是否相等，就要重写该方法，比如 、Integer 类等都重写了该方法。举个例子，假如有一个 Person 类，我们认为只要年龄和名字相同，就是同一个人，那么就可以这样重写 equals 方法：\n\n\n```java\nclass Person1 {\n private String name;\n private int age;\n\n // 省略 gettter 和 setter 方法\n\n public boolean equals(Object obj) {\n if (this == obj) {\n return true;\n }\n if (obj instanceof Person1) {\n Person1 p = (Person1) obj;\n return this.name.equals(p.getName()) && this.age == p.getAge();\n }\n return false;\n }\n}\n```\n\n\n#### [对象拷贝：](#对象拷贝)\n\n`protected native Object clone() throws CloneNotSupportedException`：naitive 方法，返回此对象的一个副本。默认实现只做，且类必须实现 Cloneable 接口。\n\nObject 本身没有实现 Cloneable 接口，所以在不重写 clone 方法的情况下直接直接调用该方法会发生 CloneNotSupportedException 异常。\n\n#### [对象转字符串：](#对象转字符串)\n\n`public String toString()`：返回对象的字符串表示。默认实现返回类名@哈希码的十六进制表示，但通常会被重写以返回更有意义的信息。\n\n\n```java\npublic String toString() {\n return getClass().getName() + \"@\" + Integer.toHexString(hashCode());\n}\n```\n\n\n比如说一个 Person 类，我们可以重写 toString 方法，返回一个有意义的字符串：\n\n\n```java\npublic String toString() {\n return \"Person{\" +\n \"name='\" + name + '\\'' +\n \", age=\" + age +\n '}';\n}\n```\n\n\n当然了，这项工作也可以直接交给 IDE，比如 IntelliJ IDEA，直接右键选择 Generate，然后选择 toString 方法，就会自动生成一个 toString 方法。\n\n也可以交给 ，使用 @Data 注解，它会自动生成 toString 方法。\n\n数组也是一个对象，所以通常我们打印数组的时候，会看到诸如 `[I@1b6d3586` 这样的字符串，这个就是 int 数组的哈希码。\n\n#### [多线程调度：](#多线程调度)\n\n每个对象都可以调用 Object 的 wait/notify 方法来实现等待/通知机制。我们来写一个例子：\n\n\n```java\npublic class WaitNotifyDemo {\n public static void main(String[] args) {\n Object lock = new Object();\n new Thread(() -> {\n synchronized (lock) {\n System.out.println(\"线程1：我要等待\");\n try {\n lock.wait();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.println(\"线程1：我被唤醒了\");\n }\n }).start();\n new Thread(() -> {\n synchronized (lock) {\n System.out.println(\"线程2：我要唤醒\");\n lock.notify();\n System.out.println(\"线程2：我已经唤醒了\");\n }\n }).start();\n }\n}\n```\n\n\n解释一下：\n\n* 线程 1 先执行，它调用了 `lock.wait()` 方法，然后进入了等待状态。\n* 线程 2 后执行，它调用了 `lock.notify()` 方法，然后线程 1 被唤醒了。\n\n①、`public final void wait() throws InterruptedException`：调用该方法会导致当前线程等待，直到另一个线程调用此对象的`notify()`方法或`notifyAll()`方法。\n\n②、`public final native void notify()`：唤醒在此对象监视器上等待的单个线程。如果有多个线程等待，选择一个线程被唤醒。\n\n③、`public final native void notifyAll()`：唤醒在此对象监视器上等待的所有线程。\n\n④、`public final native void wait(long timeout) throws InterruptedException`：等待 timeout 毫秒，如果在 timeout 毫秒内没有被唤醒，会自动唤醒。\n\n⑥、`public final void wait(long timeout, int nanos) throws InterruptedException`：更加精确了，等待 timeout 毫秒和 nanos 纳秒，如果在 timeout 毫秒和 nanos 纳秒内没有被唤醒，会自动唤醒。\n\n#### [反射：](#反射)\n\n`public final native Class getClass()`：用于获取对象的类信息，如类名。比如说：\n\n\n```java\npublic class GetClassDemo {\n public static void main(String[] args) {\n Person p = new Person();\n Class aClass = p.getClass();\n System.out.println(aClass.getName());\n }\n}\n```\n\n\n输出结果：\n\n\n```text\ncom.itwanger.Person\n```\n\n\n#### [垃圾回收：](#垃圾回收)\n\n`protected void finalize() throws Throwable`：当垃圾回收器决定回收对象占用的内存时调用此方法。用于清理资源，但 Java 不推荐使用，因为它不可预测且容易导致问题，Java 9 开始已被弃用。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 7,
+ "categoryName": "异常处理",
+ "questions": [
+ {
+ "id": 41,
+ "question": "Java 中异常处理体系?",
+ "answer": "Java 中的异常处理机制用于处理程序运行过程中可能发生的各种异常情况，通常通过 try-catch-finally 语句和 throw 关键字来实现。\n\n\n\n`Throwable` 是 Java 语言中所有错误和异常的基类。它有两个主要的子类：Error 和 Exception，这两个类分别代表了 Java 异常处理体系中的两个分支。\n\nError 类代表那些严重的错误，这类错误通常是程序无法处理的。比如，OutOfMemoryError 表示内存不足，StackOverflowError 表示栈溢出。这些错误通常与 JVM 的运行状态有关，一旦发生，应用程序通常无法恢复。\n\nException 类代表程序可以处理的异常。它分为两大类：编译时异常（Checked Exception）和运行时异常（Runtime Exception）。\n\n①、编译时异常（Checked Exception）：这类异常在编译时必须被显式处理（捕获或声明抛出）。\n\n如果方法可能抛出某种编译时异常，但没有捕获它（try-catch）或没有在方法声明中用 throws 子句声明它，那么编译将不会通过。例如：IOException、SQLException 等。\n\n②、运行时异常（Runtime Exception）：这类异常在运行时抛出，它们都是 RuntimeException 的子类。对于运行时异常，Java 编译器不要求必须处理它们（即不需要捕获也不需要声明抛出）。\n\n运行时异常通常是由程序逻辑错误导致的，如 NullPointerException、IndexOutOfBoundsException 等。"
+ },
+ {
+ "id": 42,
+ "question": "异常的处理方式？",
+ "answer": "\n\n①、遇到异常时可以不处理，直接通过throw 和 throws 抛出异常，交给上层调用者处理。\n\nthrows 关键字用于声明可能会抛出的异常，而 throw 关键字用于抛出异常。\n\n\n```java\npublic void test() throws Exception {\n throw new Exception(\"抛出异常\");\n}\n```\n\n\n②、使用 try-catch 捕获异常，处理异常。\n\n\n```java\ntry {\n //包含可能会出现异常的代码以及声明异常的方法\n}catch(Exception e) {\n //捕获异常并进行处理\n}finally {\n //可选，必执行的代码\n}\n```\n\n\n#### [catch和finally的异常可以同时抛出吗？](#catch和finally的异常可以同时抛出吗)\n\n如果 catch 块抛出一个异常，而 finally 块中也抛出异常，那么最终抛出的将是 finally 块中的异常。catch 块中的异常会被丢弃，而 finally 块中的异常会覆盖并向上传递。\n\n\n```java\npublic class Example {\n public static void main(String[] args) {\n try {\n throw new Exception(\"Exception in try\");\n } catch (Exception e) {\n throw new RuntimeException(\"Exception in catch\");\n } finally {\n throw new IllegalArgumentException(\"Exception in finally\");\n }\n }\n}\n```\n\n\n* try 块首先抛出一个 Exception。\n* 控制流进入 catch 块，catch 块中又抛出了一个 RuntimeException。\n* 但是在 finally 块中，抛出了一个 IllegalArgumentException，最终程序抛出的异常是 finally 块中的 IllegalArgumentException。\n\n虽然 catch 和 finally 中的异常不能同时抛出，但可以手动捕获 finally 块中的异常，并将 catch 块中的异常保留下来，避免被覆盖。常见的做法是使用一个变量临时存储 catch 中的异常，然后在 finally 中处理该异常：\n\n\n```java\npublic class Example {\n public static void main(String[] args) {\n Exception catchException = null;\n try {\n throw new Exception(\"Exception in try\");\n } catch (Exception e) {\n catchException = e;\n throw new RuntimeException(\"Exception in catch\");\n } finally {\n try {\n throw new IllegalArgumentException(\"Exception in finally\");\n } catch (IllegalArgumentException e) {\n if (catchException != null) {\n System.out.println(\"Catch exception: \" + catchException.getMessage());\n }\n System.out.println(\"Finally exception: \" + e.getMessage());\n }\n }\n }\n}\n```\n"
+ },
+ {
+ "id": 43,
+ "question": "三道经典异常处理代码题",
+ "answer": "#### [题目 1](#题目-1)\n\n\n```java\npublic class TryDemo {\n public static void main(String[] args) {\n System.out.println(test());\n }\n public static int test() {\n try {\n return 1;\n } catch (Exception e) {\n return 2;\n } finally {\n System.out.print(\"3\");\n }\n }\n}\n```\n\n\n在`test()`方法中，首先有一个`try`块，接着是一个`catch`块（用于捕获异常），最后是一个`finally`块（无论是否捕获到异常，`finally`块总会执行）。\n\n①、`try`块中包含一条`return 1;`语句。正常情况下，如果`try`块中的代码能够顺利执行，那么方法将返回数字`1`。在这个例子中，`try`块中没有任何可能抛出异常的操作，因此它会正常执行完毕，并准备返回`1`。\n\n②、由于`try`块中没有异常发生，所以`catch`块中的代码不会执行。\n\n③、无论前面的代码是否发生异常，`finally`块总是会执行。在这个例子中，`finally`块包含一条`System.out.print(\"3\");`语句，意味着在方法结束前，会在控制台打印出`3`。\n\n当执行`main`方法时，控制台的输出将会是：\n\n\n```text\n31\n```\n\n\n这是因为`finally`块确保了它包含的`System.out.print(\"3\");`会执行并打印`3`，随后`test()`方法返回`try`块中的值`1`，最终结果就是`31`。\n\n#### [题目 2](#题目-2)\n\n\n```java\npublic class TryDemo {\n public static void main(String[] args) {\n System.out.println(test1());\n }\n public static int test1() {\n try {\n return 2;\n } finally {\n return 3;\n }\n }\n}\n```\n\n\n执行结果：3。\n\ntry 返回前先执行 finally，结果 finally 里不按套路出牌，直接 return 了，自然也就走不到 try 里面的 return 了。\n\n注意：finally 里面使用 return 仅存在于面试题中，实际开发这么写要挨吊的（😂）。\n\n#### [题目 3](#题目-3)\n\n\n```java\npublic class TryDemo {\n public static void main(String[] args) {\n System.out.println(test1());\n }\n public static int test1() {\n int i = 0;\n try {\n i = 2;\n return i;\n } finally {\n i = 3;\n }\n }\n}\n```\n\n\n执行结果：2。\n\n大家可能会以为结果应该是 3，因为在 return 前会执行 finally，而 i 在 finally 中被修改为 3 了，那最终返回 i 不是应该为 3 吗？\n\n但其实，在执行 finally 之前，JVM 会先将 i 的结果暂存起来，然后 finally 执行完毕后，会返回之前暂存的结果，而不是返回 i，所以即使 i 已经被修改为 3，最终返回的还是之前暂存起来的结果 2。"
+ }
+ ]
+ },
+ {
+ "id": 8,
+ "categoryName": "I/O",
+ "questions": [
+ {
+ "id": 44,
+ "question": "Java 中 IO 流分为几种?",
+ "answer": "Java IO 流的划分可以根据多个维度进行，包括数据流的方向（输入或输出）、处理的数据单位（字节或字符）、流的功能以及流是否支持随机访问等。\n\n#### [按照数据流方向如何划分？](#按照数据流方向如何划分)\n\n* 输入流（Input Stream）：从源（如文件、网络等）读取数据到程序。\n* 输出流（Output Stream）：将数据从程序写出到目的地（如文件、网络、控制台等）。\n\n#### [按处理数据单位如何划分？](#按处理数据单位如何划分)\n\n* 字节流（Byte Streams）：以字节为单位读写数据，主要用于处理二进制数据，如音频、图像文件等。\n* 字符流（Character Streams）：以字符为单位读写数据，主要用于处理文本数据。\n\n\n\n#### [按功能如何划分？](#按功能如何划分)\n\n* 节点流（Node Streams）：直接与数据源或目的地相连，如 FileInputStream、FileOutputStream。\n* 处理流（Processing Streams）：对一个已存在的流进行包装，如缓冲流 BufferedInputStream、BufferedOutputStream。\n* 管道流（Piped Streams）：用于线程之间的数据传输，如 PipedInputStream、PipedOutputStream。\n\n#### [IO 流用到了什么设计模式？](#io-流用到了什么设计模式)\n\n其实，Java 的 IO 流体系还用到了一个设计模式——**装饰器模式**。\n\n\n\n#### [Java 缓冲区溢出，如何预防](#java-缓冲区溢出-如何预防)\n\nJava 缓冲区溢出主要是由于向缓冲区写入的数据超过其能够存储的数据量。可以采用这些措施来避免：\n\n①、**合理设置缓冲区大小**：在创建缓冲区时，应根据实际需求合理设置缓冲区的大小，避免创建过大或过小的缓冲区。\n\n②、**控制写入数据量**：在向缓冲区写入数据时，应该控制写入的数据量，确保不会超过缓冲区的容量。Java 的 ByteBuffer 类提供了`remaining()`方法，可以获取缓冲区中剩余的可写入数据量。\n\n\n```java\nimport java.nio.ByteBuffer;\n\npublic class ByteBufferExample {\n\n public static void main(String[] args) {\n // 模拟接收到的数据\n byte[] receivedData = {1, 2, 3, 4, 5};\n int bufferSize = 1024; // 设置一个合理的缓冲区大小\n\n // 创建ByteBuffer\n ByteBuffer buffer = ByteBuffer.allocate(bufferSize);\n\n // 写入数据之前检查容量是否足够\n if (buffer.remaining() >= receivedData.length) {\n buffer.put(receivedData);\n } else {\n System.out.println(\"Not enough space in buffer to write data.\");\n }\n\n // 准备读取数据：将limit设置为当前位置，position设回0\n buffer.flip();\n\n // 读取数据\n while (buffer.hasRemaining()) {\n byte data = buffer.get();\n System.out.println(\"Read data: \" + data);\n }\n\n // 清空缓冲区以便再次使用\n buffer.clear();\n }\n}\n```"
+ },
+ {
+ "id": 45,
+ "question": "既然有了字节流,为什么还要有字符流?",
+ "answer": "其实字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还比较耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。\n\n所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。\n\n#### [文本存储是字节流还是字符流，视频文件呢？](#文本存储是字节流还是字符流-视频文件呢)\n\n在计算机中，文本和视频都是按照字节存储的，只是如果是文本文件的话，我们可以通过字符流的形式去读取，这样更方面的我们进行直接处理。\n\n比如说我们需要在一个大文本文件中查找某个字符串，可以直接通过字符流来读取判断。\n\n处理视频文件时，通常使用字节流（如 Java 中的`FileInputStream`、`FileOutputStream`）来读取或写入数据，并且会尽量使用缓冲流（如`BufferedInputStream`、`BufferedOutputStream`）来提高读写效率。\n\n在项目中，对于文本，比如说文章和教程内容，是直接存储在数据库中的，而对于视频和图片等大文件，是存储在 OSS 中的。\n\n因此，无论是文本文件还是视频文件，它们在物理存储层面都是以字节流的形式存在。区别在于，我们如何通过 Java 代码来解释和处理这些字节流：作为编码后的字符还是作为二进制数据。"
+ },
+ {
+ "id": 46,
+ "question": "BIO、NIO、AIO 之间的区别？",
+ "answer": "Java 常见的 IO 模型有三种：BIO、NIO 和 AIO。\n\n\n\nBIO：采用阻塞式 I/O 模型，线程在执行 I/O 操作时被阻塞，无法处理其他任务，适用于连接数较少的场景。\n\nNIO：采用非阻塞 I/O 模型，线程在等待 I/O 时可执行其他任务，通过 Selector 监控多个 Channel 上的事件，适用于连接数多但连接时间短的场景。\n\nAIO：使用异步 I/O 模型，线程发起 I/O 请求后立即返回，当 I/O 操作完成时通过回调函数通知线程，适用于连接数多且连接时间长的场景。\n\n#### [简单说一下 BIO？](#简单说一下-bio)\n\nBIO，也就是传统的 IO，基于字节流或字符流（如 FileInputStream、BufferedReader 等）进行文件读写，基于 Socket 和 ServerSocket 进行网络通信。\n\n对于每个连接，都需要创建一个独立的线程来处理读写操作。\n\n\n\n#### [简单说下 NIO？](#简单说下-nio)\n\nNIO，JDK 1.4 时引入，放在 java.nio 包下，提供了 Channel、Buffer、Selector 等新的抽象，基于 RandomAccessFile、FileChannel、ByteBuffer 进行文件读写，基于 SocketChannel 和 ServerSocketChannel 进行网络通信。\n\n实际上，“旧”的 I/O 包已经使用 NIO 重新实现过，所以在进行文件读写时，NIO 并无法体现出比 BIO 更可靠的性能。\n\nNIO 的魅力主要体现在网络编程中，服务器可以用一个线程处理多个客户端连接，通过 Selector 监听多个 Channel 来实现多路复用，极大地提高了网络编程的性能。\n\n\n\n缓冲区 Buffer 也能极大提升一次 IO 操作的效率。\n\n\n\n#### [简单说下 AIO？](#简单说下-aio)\n\nAIO 是 Java 7 引入的，放在 java.nio.channels 包下，提供了 AsynchronousFileChannel、AsynchronousSocketChannel 等异步 Channel。\n\n它引入了异步通道的概念，使得 I/O 操作可以异步进行。这意味着线程发起一个读写操作后不必等待其完成，可以立即进行其他任务，并且当读写操作真正完成时，线程会被异步地通知。\n\n\n```java\nAsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(Paths.get(\"test.txt\"), StandardOpenOption.READ);\nByteBuffer buffer = ByteBuffer.allocate(1024);\nFuture result = fileChannel.read(buffer, 0);\nwhile (!result.isDone()) {\n // do something\n}\n```"
+ }
+ ]
+ },
+ {
+ "id": 9,
+ "categoryName": "序列化",
+ "questions": [
+ {
+ "id": 47,
+ "question": "什么是序列化？什么是反序列化？",
+ "answer": "序列化（Serialization）是指将对象转换为字节流的过程，以便能够将该对象保存到文件、数据库，或者进行网络传输。\n\n反序列化（Deserialization）就是将字节流转换回对象的过程，以便构建原始对象。\n\n\n\n#### [Serializable 接口有什么用？](#serializable-接口有什么用)\n\n`Serializable`接口用于标记一个类可以被序列化。\n\n\n```java\npublic class Person implements Serializable {\n private String name;\n private int age;\n // 省略 getter 和 setter 方法\n}\n```\n\n\n#### [serialVersionUID 有什么用？](#serialversionuid-有什么用)\n\nserialVersionUID 是 Java 序列化机制中用于标识类版本的唯一标识符。它的作用是确保在序列化和反序列化过程中，类的版本是兼容的。\n\n\n```java\nimport java.io.Serializable;\n\npublic class MyClass implements Serializable {\n private static final long serialVersionUID = 1L;\n private String name;\n private int age;\n\n // getters and setters\n}\n```\n\n\nserialVersionUID 被设置为 1L 是一种比较省事的做法，也可以使用 Intellij IDEA 进行自动生成。\n\n但只要 serialVersionUID 在序列化和反序列化过程中保持一致，就不会出现问题。\n\n如果不显式声明 serialVersionUID，Java 运行时会根据类的详细信息自动生成一个 serialVersionUID。那么当类的结构发生变化时，自动生成的 serialVersionUID 就会发生变化，导致反序列化失败。\n\n#### [Java 序列化不包含静态变量吗？](#java-序列化不包含静态变量吗)\n\n是的，序列化机制只会保存对象的状态，而静态变量属于类的状态，不属于对象的状态。\n\n#### [如果有些变量不想序列化，怎么办？](#如果有些变量不想序列化-怎么办)\n\n可以使用`transient`关键字修饰不想序列化的变量。\n\n\n```java\npublic class Person implements Serializable {\n private String name;\n private transient int age;\n // 省略 getter 和 setter 方法\n}\n```\n\n\n#### [能解释一下序列化的过程和作用吗？](#能解释一下序列化的过程和作用吗)\n\n序列化过程通常涉及到以下几个步骤：\n\n第一步，实现 Serializable 接口。\n\n\n```java\npublic class Person implements Serializable {\n private String name;\n private int age;\n\n // 省略构造方法、getters和setters\n}\n```\n\n\n第二步，使用 ObjectOutputStream 来将对象写入到输出流中。\n\n\n```java\nObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(\"person.ser\"));\n```\n\n\n第三步，调用 ObjectOutputStream 的 writeObject 方法，将对象序列化并写入到输出流中。\n\n\n```java\nPerson person = new Person(\"练习伴侣二\", 18);\nout.writeObject(person);\n```"
+ },
+ {
+ "id": 48,
+ "question": "说说有几种序列化方式？",
+ "answer": "Java 序列化方式有很多，常见的有三种：\n\n\n\n* Java 对象序列化 ：Java 原生序列化方法即通过 Java 原生流(InputStream 和 OutputStream 之间的转化)的方式进行转化，一般是对象输出流 `ObjectOutputStream`和对象输入流`ObjectInputStream`。\n* Json 序列化：这个可能是我们最常用的序列化方式，Json 序列化的选择很多，一般会使用 jackson 包，通过 ObjectMapper 类来进行一些操作，比如将对象转化为 byte 数组或者将 json 串转化为对象。\n* ProtoBuff 序列化：ProtocolBuffer 是一种轻便高效的结构化数据存储格式，ProtoBuff 序列化对象可以很大程度上将其压缩，可以大大减少数据传输大小，提高系统性能。"
+ }
+ ]
+ },
+ {
+ "id": 10,
+ "categoryName": "网络编程",
+ "questions": [
+ {
+ "id": 49,
+ "question": "了解过Socket网络套接字吗？（补充）",
+ "answer": "> 2024 年 11 月 28 日 增补\n\nSocket 是网络通信的基础，表示两台设备之间通信的一个端点。Socket 通常用于建立 TCP 或 UDP 连接，实现进程间的网络通信。\n\n\n\n一个简单的 TCP 客户端：\n\n\n```java\nclass TcpClient {\n public static void main(String[] args) throws IOException {\n Socket socket = new Socket(\"127.0.0.1\", 8080); // 连接服务器\n BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));\n PrintWriter out = new PrintWriter(socket.getOutputStream(), true);\n\n out.println(\"Hello, Server!\"); // 发送消息\n System.out.println(\"Server response: \" + in.readLine()); // 接收服务器响应\n\n socket.close();\n }\n}\n```\n\n\nTCP 服务端：\n\n\n```java\nclass TcpServer {\n public static void main(String[] args) throws IOException {\n ServerSocket serverSocket = new ServerSocket(8080); // 创建服务器端Socket\n System.out.println(\"Server started, waiting for connection...\");\n Socket socket = serverSocket.accept(); // 等待客户端连接\n System.out.println(\"Client connected: \" + socket.getInetAddress());\n\n BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));\n PrintWriter out = new PrintWriter(socket.getOutputStream(), true);\n\n String message;\n while ((message = in.readLine()) != null) {\n System.out.println(\"Received: \" + message);\n out.println(\"Echo: \" + message); // 回送消息\n }\n\n socket.close();\n serverSocket.close();\n }\n}\n```\n\n\n#### [RPC框架了解吗？](#rpc框架了解吗)\n\nRPC是一种协议，允许程序调用位于远程服务器上的方法，就像调用本地方法一样。RPC 通常基于 Socket 通信实现。\n\n> RPC，Remote Procedure Call，远程过程调用\n\nRPC 框架支持高效的序列化（如 Protocol Buffers）和通信协议（如 HTTP/2），屏蔽了底层网络通信的细节，开发者只需关注业务逻辑即可。\n\n\n\n常见的 RPC 框架包括：\n\n1. gRPC：基于 HTTP/2 和 Protocol Buffers。\n2. Dubbo：阿里开源的分布式 RPC 框架，适合微服务场景。\n3. Spring Cloud OpenFeign：基于 REST 的轻量级 RPC 框架。\n4. Thrift：Apache 的跨语言 RPC 框架，支持多语言代码生成。"
+ }
+ ]
+ },
+ {
+ "id": 11,
+ "categoryName": "泛型",
+ "questions": [
+ {
+ "id": 50,
+ "question": "Java 泛型了解么？",
+ "answer": "泛型主要用于提高代码的类型安全，它允许在定义类、接口和方法时使用类型参数，这样可以在编译时检查类型一致性，避免不必要的类型转换和类型错误。\n\n没有泛型的时候，像 List 这样的集合类存储的是 Object 类型，导致从集合中读取数据时，必须进行强制类型转换，否则会引发 ClassCastException。\n\n\n```java\nList list = new ArrayList();\nlist.add(\"hello\");\nString str = (String) list.get(0); // 必须强制类型转换\n```\n\n\n泛型一般有三种使用方式:**泛型类**、**泛型接口**、**泛型方法**。\n\n\n\n**1.泛型类**：\n\n\n```java\n//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型\n//在实例化泛型类时，必须指定T的具体类型\npublic class Generic{\n\n private T key;\n\n public Generic(T key) {\n this.key = key;\n }\n\n public T getKey(){\n return key;\n }\n}\n```\n\n\n如何实例化泛型类：\n\n\n```java\nGeneric genericInteger = new Generic(123456);\n```\n\n\n**2.泛型接口** ：\n\n\n```java\npublic interface Generator {\n public T method();\n}\n```\n\n\n实现泛型接口，指定类型：\n\n\n```java\nclass GeneratorImpl implements Generator{\n @Override\n public String method() {\n return \"hello\";\n }\n}\n```\n\n\n**3.泛型方法** ：\n\n\n```java\n public static < E > void printArray( E[] inputArray )\n {\n for ( E element : inputArray ){\n System.out.printf( \"%s \", element );\n }\n System.out.println();\n }\n```\n\n\n使用：\n\n\n```java\n// 创建不同类型数组： Integer, Double 和 Character\nInteger[] intArray = { 1, 2, 3 };\nString[] stringArray = { \"Hello\", \"World\" };\nprintArray( intArray );\nprintArray( stringArray );\n```\n\n\n#### [泛型常用的通配符有哪些？](#泛型常用的通配符有哪些)\n\n**常用的通配符为： T，E，K，V，？**\n\n* ？ 表示不确定的 java 类型\n* T (type) 表示具体的一个 java 类型\n* K V (key value) 分别代表 java 键值中的 Key Value\n* E (element) 代表 Element\n\n#### [什么是泛型擦除？](#什么是泛型擦除)\n\n所谓的泛型擦除，官方名叫“类型擦除”。\n\nJava 的泛型是伪泛型，这是因为 Java 在编译期间，所有的类型信息都会被擦掉。\n\n也就是说，在运行的时候是没有泛型的。\n\n例如这段代码，往一群猫里放条狗：\n\n\n```java\nLinkedList cats = new LinkedList();\nLinkedList list = cats; // 注意我在这里把范型去掉了，但是list和cats是同一个链表！\nlist.add(new Dog()); // 完全没问题！\n```\n\n\n因为 Java 的范型只存在于源码里，编译的时候给你静态地检查一下范型类型是否正确，而到了运行时就不检查了。上面这段代码在 JRE（Java**运行**环境）看来和下面这段没区别：\n\n\n```java\nLinkedList cats = new LinkedList(); // 注意：没有范型！\nLinkedList list = cats;\nlist.add(new Dog());\n```\n\n\n#### [为什么要类型擦除呢？](#为什么要类型擦除呢)\n\n主要是为了向下兼容，因为 JDK5 之前是没有泛型的，为了让 JVM 保持向下兼容，就出了类型擦除这个策略。"
+ }
+ ]
+ },
+ {
+ "id": 12,
+ "categoryName": "注解",
+ "questions": [
+ {
+ "id": 51,
+ "question": "说一下你对注解的理解？",
+ "answer": "**Java 注解本质上是一个标记**，可以理解成生活中的一个人的一些小装扮，比如戴什么什么帽子，戴什么眼镜。\n\n\n\n注解可以标记在类上、方法上、属性上等，标记自身也可以设置一些值，比如帽子颜色是绿色。\n\n有了标记之后，我们就可以在编译或者运行阶段去识别这些标记，然后搞一些事情，这就是注解的用处。\n\n例如我们常见的 AOP，使用注解作为切点就是运行期注解的应用；比如 lombok，就是注解在编译期的运行。\n\n注解生命周期有三大类，分别是：\n\n* RetentionPolicy.SOURCE：给编译器用的，不会写入 class 文件\n* RetentionPolicy.CLASS：会写入 class 文件，在类加载阶段丢弃，也就是运行的时候就没这个信息了\n* RetentionPolicy.RUNTIME：会写入 class 文件，永久保存，可以通过反射获取注解信息\n\n所以我上文写的是解析的时候，没写具体是解析啥，因为不同的生命周期的解析动作是不同的。\n\n像常见的：\n\n\n\n就是给编译器用的，编译器编译的时候检查没问题就 over 了，class 文件里面不会有 Override 这个标记。\n\n再比如 Spring 常见的 Autowired ，就是 RUNTIME 的，所以**在运行的时候可以通过反射得到注解的信息**，还能拿到标记的值 required 。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 13,
+ "categoryName": "反射",
+ "questions": [
+ {
+ "id": 52,
+ "question": "什么是反射？应用？原理？",
+ "answer": "反射允许 Java 在运行时检查和操作类的方法和字段。通过反射，可以动态地获取类的字段、方法、构造方法等信息，并在运行时调用方法或访问字段。\n\n比如创建一个对象是通过 new 关键字来实现的：\n\n\n```java\nPerson person = new Person();\n```\n\n\nPerson 类的信息在编译时就确定了，那假如在编译期无法确定类的信息，但又想在运行时获取类的信息、创建类的实例、调用类的方法，这时候就要用到反射。\n\n反射功能主要通过 `java.lang.Class` 类及 `java.lang.reflect` 包中的类如 Method, Field, Constructor 等来实现。\n\n\n\n比如说我们可以装来动态加载类并创建对象：\n\n\n```java\nString className = \"java.util.Date\";\nClass cls = Class.forName(className);\nObject obj = cls.newInstance();\nSystem.out.println(obj.getClass().getName());\n```\n\n\n比如说我们可以这样来访问字段和方法：\n\n\n```java\n// 加载并实例化类\nClass cls = Class.forName(\"java.util.Date\");\nObject obj = cls.newInstance();\n\n// 获取并调用方法\nMethod method = cls.getMethod(\"getTime\");\nObject result = method.invoke(obj);\nSystem.out.println(\"Time: \" + result);\n\n// 访问字段\nField field = cls.getDeclaredField(\"fastTime\");\nfield.setAccessible(true); // 对于私有字段需要这样做\nSystem.out.println(\"fastTime: \" + field.getLong(obj));\n```\n\n\n#### [反射有哪些应用场景？](#反射有哪些应用场景)\n\n①、Spring 框架就大量使用了反射来动态加载和管理 Bean。\n\n\n```java\nClass clazz = Class.forName(\"com.example.MyClass\");\nObject instance = clazz.newInstance();\n```\n\n\n②、Java 的动态代理（Dynamic Proxy）机制就使用了反射来创建代理类。代理类可以在运行时动态处理方法调用，这在实现 AOP 和拦截器时非常有用。\n\n\n```java\nInvocationHandler handler = new MyInvocationHandler();\nMyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(\n MyInterface.class.getClassLoader(),\n new Class[] { MyInterface.class },\n handler\n);\n```\n\n\n③、JUnit 和 TestNG 等测试框架使用反射机制来发现和执行测试方法。反射允许框架扫描类，查找带有特定注解（如 `@Test`）的方法，并在运行时调用它们。\n\n\n```java\nMethod testMethod = testClass.getMethod(\"testSomething\");\ntestMethod.invoke(testInstance);\n```\n\n\n#### [反射的原理是什么？](#反射的原理是什么)\n\nJava 程序的执行分为编译和运行两步，编译之后会生成字节码(.class)文件，JVM 进行类加载的时候，会加载字节码文件，将类型相关的所有信息加载进方法区，反射就是去获取这些信息，然后进行各种操作。"
+ }
+ ]
+ },
+ {
+ "id": 14,
+ "categoryName": "JDK1.8 新特性",
+ "questions": [
+ {
+ "id": 53,
+ "question": "JDK 1.8 都有哪些新特性？",
+ "answer": "JDK 1.8 新增了不少新的特性，如 Lambda 表达式、接口默认方法、Stream API、日期时间 API、Optional 类等。\n\n\n\n①、Java 8 允许在接口中添加默认方法和静态方法。\n\n\n```java\npublic interface MyInterface {\n default void myDefaultMethod() {\n System.out.println(\"My default method\");\n }\n\n static void myStaticMethod() {\n System.out.println(\"My static method\");\n }\n}\n```\n\n\n②、Lambda 表达式描述了一个代码块（或者叫匿名方法），可以将其作为参数传递给构造方法或者普通方法以便后续执行。\n\n\n```java\npublic class LamadaTest {\n public static void main(String[] args) {\n new Thread(() -> System.out.println(\"练习伴侣二\")).start();\n }\n}\n```\n\n\n《Effective Java》的作者 Josh Bloch 建议使用 Lambda 表达式时，最好不要超过 3 行。否则代码可读性会变得很差。\n\n③、Stream 是对 Java 集合框架的增强，它提供了一种高效且易于使用的数据处理方式。\n\n\n```java\nList list = new ArrayList<>();\nlist.add(\"中国加油\");\nlist.add(\"世界加油\");\nlist.add(\"世界加油\");\n\nlong count = list.stream().distinct().count();\nSystem.out.println(count);\n```\n\n\n④、Java 8 引入了一个全新的日期和时间 API，位于`java.time`包中。这个新的 API 纠正了旧版`java.util.Date`类中的许多缺陷。\n\n\n```java\nLocalDate today = LocalDate.now();\nSystem.out.println(\"Today's Local date : \" + today);\n\nLocalTime time = LocalTime.now();\nSystem.out.println(\"Local time : \" + time);\n\nLocalDateTime now = LocalDateTime.now();\nSystem.out.println(\"Current DateTime : \" + now);\n```\n\n\n⑤、引入 Optional 是为了减少空指针异常。\n\n\n```java\nOptional optional = Optional.of(\"练习伴侣二\");\noptional.isPresent(); // true\noptional.get(); // \"练习伴侣二\"\noptional.orElse(\"练习伴侣三\"); // \"bam\"\noptional.ifPresent((s) -> System.out.println(s.charAt(0))); // \"沉\"\n```"
+ },
+ {
+ "id": 54,
+ "question": "Lambda 表达式了解多少？",
+ "answer": "Lambda 表达式主要用于提供一种简洁的方式来表示匿名方法，使 Java 具备了函数式编程的特性。\n\n比如说我们可以使用 Lambda 表达式来简化线程的创建：\n\n\n```java\nnew Thread(() -> System.out.println(\"Hello World\")).start();\n```\n\n\n这比以前的匿名内部类要简洁很多。\n\n所谓的函数式编程，就是把函数作为参数传递给方法，或者作为方法的结果返回。比如说我们可以配合 Stream 流进行数据过滤：\n\n\n```java\nList numbers = Arrays.asList(1, 2, 3, 4, 5, 6);\nList evenNumbers = numbers.stream()\n .filter(n -> n % 2 == 0)\n .collect(Collectors.toList());\n```\n\n\n其中 `n -> n % 2 == 0` 就是一个 Lambda 表达式。表示传入一个参数 n，返回 `n % 2 == 0` 的结果。\n\n#### [Java8 有哪些内置函数式接口？](#java8-有哪些内置函数式接口)\n\nJDK 1.8 API 包含了很多内置的函数式接口。其中就包括我们在老版本中经常见到的 **Comparator** 和 **Runnable**，Java 8 为他们都添加了 @FunctionalInterface 注解，以用来支持 Lambda 表达式。\n\n除了这两个之外，还有 Callable、Predicate、Function、Supplier、Consumer 等等。"
+ },
+ {
+ "id": 55,
+ "question": "Optional 了解吗？",
+ "answer": "`Optional`是用于防范`NullPointerException`。\n\n可以将 `Optional` 看做是包装对象（可能是 `null`, 也有可能非 `null`）的容器。当我们定义了 一个方法，这个方法返回的对象可能是空，也有可能非空的时候，我们就可以考虑用 `Optional` 来包装它，这也是在 Java 8 被推荐使用的做法。\n\n\n```java\nOptional optional = Optional.of(\"bam\");\n\noptional.isPresent(); // true\noptional.get(); // \"bam\"\noptional.orElse(\"fallback\"); // \"bam\"\n\noptional.ifPresent((s) -> System.out.println(s.charAt(0))); // \"b\"\n```"
+ },
+ {
+ "id": 56,
+ "question": "Stream 流用过吗？",
+ "answer": "`Stream` 流，简单来说，使用 `java.util.Stream` 对一个包含一个或多个元素的集合做各种操作。这些操作可能是 *中间操作* 亦或是 *终端操作*。 终端操作会返回一个结果，而中间操作会返回一个 `Stream` 流。\n\nStream 流一般用于集合，我们对一个集合做几个常见操作：\n\n\n```java\nList stringCollection = new ArrayList<>();\nstringCollection.add(\"ddd2\");\nstringCollection.add(\"aaa2\");\nstringCollection.add(\"bbb1\");\nstringCollection.add(\"aaa1\");\nstringCollection.add(\"bbb3\");\nstringCollection.add(\"ccc\");\nstringCollection.add(\"bbb2\");\nstringCollection.add(\"ddd1\");\n```\n\n\n* **Filter 过滤**\n\n\n```java\nstringCollection\n .stream()\n .filter((s) -> s.startsWith(\"a\"))\n .forEach(System.out::println);\n\n// \"aaa2\", \"aaa1\"\n```\n\n\n* **Sorted 排序**\n\n\n```java\nstringCollection\n .stream()\n .sorted()\n .filter((s) -> s.startsWith(\"a\"))\n .forEach(System.out::println);\n\n// \"aaa1\", \"aaa2\"\n```\n\n\n* **Map 转换**\n\n\n```java\nstringCollection\n .stream()\n .map(String::toUpperCase)\n .sorted((a, b) -> b.compareTo(a))\n .forEach(System.out::println);\n\n// \"DDD2\", \"DDD1\", \"CCC\", \"BBB3\", \"BBB2\", \"AAA2\", \"AAA1\"\n```\n\n\n* **Match 匹配**\n\n\n```java\n// 验证 list 中 string 是否有以 a 开头的, 匹配到第一个，即返回 true\nboolean anyStartsWithA =\n stringCollection\n .stream()\n .anyMatch((s) -> s.startsWith(\"a\"));\n\nSystem.out.println(anyStartsWithA); // true\n\n// 验证 list 中 string 是否都是以 a 开头的\nboolean allStartsWithA =\n stringCollection\n .stream()\n .allMatch((s) -> s.startsWith(\"a\"));\n\nSystem.out.println(allStartsWithA); // false\n\n// 验证 list 中 string 是否都不是以 z 开头的,\nboolean noneStartsWithZ =\n stringCollection\n .stream()\n .noneMatch((s) -> s.startsWith(\"z\"));\n\nSystem.out.println(noneStartsWithZ); // true\n```\n\n\n* **Count 计数**\n\n`count` 是一个终端操作，它能够统计 `stream` 流中的元素总数，返回值是 `long` 类型。\n\n\n```java\n// 先对 list 中字符串开头为 b 进行过滤，让后统计数量\nlong startsWithB =\n stringCollection\n .stream()\n .filter((s) -> s.startsWith(\"b\"))\n .count();\n\nSystem.out.println(startsWithB); // 3\n```\n\n\n* **Reduce**\n\n`Reduce` 中文翻译为：*减少、缩小*。通过入参的 `Function`，我们能够将 `list` 归约成一个值。它的返回类型是 `Optional` 类型。\n\n\n```java\nOptional reduced =\n stringCollection\n .stream()\n .sorted()\n .reduce((s1, s2) -> s1 + \"#\" + s2);\n\nreduced.ifPresent(System.out::println);\n// \"aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2\"\n```\n\n\n以上是常见的几种流式操作，还有其它的一些流式操作，可以帮助我们更便捷地处理集合数据。\n\n\n> 2024 年 12 月 30 日第二版优化结束。"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 2,
+ "topicName": "Java集合",
+ "categories": [
+ {
+ "id": 15,
+ "categoryName": "引言",
+ "questions": [
+ {
+ "id": 57,
+ "question": "说说有哪些常见的集合框架？",
+ "answer": "\n\n集合框架可以分为两条大的支线：\n\n①、第一条支线 Collection，主要由 List、Set、Queue 组成：\n\n* List 代表有序、可重复的集合，典型代表就是封装了动态数组的 和封装了链表的 ；\n* Set 代表无序、不可重复的集合，典型代表就是 HashSet 和 TreeSet；\n* Queue 代表队列，典型代表就是双端队列 ，以及优先级队列 。\n\n②、第二条支线 Map，代表键值对的集合，典型代表就是 。\n\n另外一个回答版本：\n\n①、Collection 接口：最基本的集合框架表示方式，提供了添加、删除、清空等基本操作，它主要有三个子接口：\n\n* `List`：一个有序的集合，可以包含重复的元素。实现类包括 ArrayList、LinkedList 等。\n* `Set`：一个不包含重复元素的集合。实现类包括 HashSet、LinkedHashSet、TreeSet 等。\n* `Queue`：一个用于保持元素队列的集合。实现类包括 PriorityQueue、ArrayDeque 等。\n\n②、`Map` 接口：表示键值对的集合，一个键映射到一个值。键不能重复，每个键只能对应一个值。Map 接口的实现类包括 HashMap、LinkedHashMap、TreeMap 等。\n\n#### [集合框架有哪几个常用工具类？](#集合框架有哪几个常用工具类)\n\n集合框架位于 java.util 包下，提供了两个常用的工具类：\n\n* ：提供了一些对集合进行排序、二分查找、同步的静态方法。\n* ：提供了一些对数组进行排序、打印、和 List 进行转换的静态方法。\n\n#### [简单介绍一下队列](#简单介绍一下队列)\n\nJava 中的队列主要通过 Queue 接口和并发包下的 BlockingQueue 两个接口来实现。\n\n优先级队列 PriorityQueue 实现了 Queue 接口，是一个无界队列，它的元素按照自然顺序排序或者 Comparator 比较器进行排序。\n\n\n\n双端队列 ArrayDeque 也实现了 Queue 接口，是一个基于数组的，可以在两端插入和删除元素的队列。\n\n\n\nLinkedList 实现了 Queue 接口的子类 Deque，所以也可以当做双端队列来使用。\n\n\n\n#### [用过哪些集合类，它们的优劣？](#用过哪些集合类-它们的优劣)\n\n我常用的集合类有 ArrayList、LinkedList、HashMap、LinkedHashMap。\n\n1. ArrayList 可以看作是一个动态数组，可以在需要时动态扩容数组的容量，只不过需要复制元素到新的数组。优点是访问速度快，可以通过索引直接查找到元素。缺点是插入和删除元素可能需要移动或者复制元素。\n2. LinkedList 是一个双向链表，适合频繁的插入和删除操作。优点是插入和删除元素的时候只需要改变节点的前后指针，缺点是访问元素时需要遍历链表。\n3. HashMap 是一个基于哈希表的键值对集合。优点是可以根据键的哈希值快速查找到值，但有可能会发生哈希冲突，并且不保留键值对的插入顺序。\n4. LinkedHashMap 在 HashMap 的基础上增加了一个双向链表来保持键值对的插入顺序。\n\n#### [队列和栈的区别了解吗？](#队列和栈的区别了解吗)\n\n队列是一种先进先出（FIFO, First-In-First-Out）的数据结构，第一个加入队列的元素会成为第一个被移除的元素。\n\n\n\n栈是一种后进先出（LIFO, Last-In-First-Out）的数据结构，最后一个加入栈的元素会成为第一个被移除的元素。\n\n\n\n#### [哪些是线程安全的容器？](#哪些是线程安全的容器)\n\n像 Vector、Hashtable、ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentLinkedQueue、ArrayBlockingQueue、LinkedBlockingQueue 都是线程安全的。\n\n#### [Collection 继承了哪些接口？](#collection-继承了哪些接口)\n\nCollection 继承了 Iterable 接口，这意味着所有实现 Collection 接口的类都必须实现 `iterator()` 方法，之后就可以使用增强型 for 循环遍历集合中的元素了。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 16,
+ "categoryName": "List",
+ "questions": [
+ {
+ "id": 58,
+ "question": "ArrayList 和 LinkedList 有什么区别？",
+ "answer": "ArrayList 是基于数组实现的，LinkedList 是基于链表实现的。\n\n\n\n#### [ArrayList 和 LinkedList 的用途有什么不同？](#arraylist-和-linkedlist-的用途有什么不同)\n\n多数情况下，ArrayList 更利于查找，LinkedList 更利于增删。\n\n①、由于 ArrayList 是基于数组实现的，所以 `get(int index)` 可以直接通过数组下标获取，时间复杂度是 O(1)；LinkedList 是基于链表实现的，`get(int index)` 需要遍历链表，时间复杂度是 O(n)。\n\n当然，`get(E element)` 这种查找，两种集合都需要遍历通过 equals 比较获取元素，所以时间复杂度都是 O(n)。\n\n②、ArrayList 如果增删的是数组的尾部，时间复杂度是 O(1)；如果 add 的时候涉及到扩容，时间复杂度会上升到 O(n)。\n\n但如果插入的是中间的位置，就需要把插入位置后的元素向前或者向后移动，甚至还有可能触发扩容，效率就会低很多，变成 O(n)。\n\n\n\nLinkedList 因为是链表结构，插入和删除只需要改变前置节点、后置节点和插入节点的引用，因此不需要移动元素。\n\n如果是在链表的头部插入或者删除，时间复杂度是 O(1)；如果是在链表的中间插入或者删除，时间复杂度是 O(n)，因为需要遍历链表找到插入位置；如果是在链表的尾部插入或者删除，时间复杂度是 O(1)。\n\n\n\n#### [ArrayList 和 LinkedList 是否支持随机访问？](#arraylist-和-linkedlist-是否支持随机访问)\n\n①、ArrayList 是基于数组的，也实现了 RandomAccess 接口，所以它支持随机访问，可以通过下标直接获取元素。\n\n\n\n②、LinkedList 是基于链表的，所以它没法根据下标直接获取元素，不支持随机访问。\n\n\n\n#### [ArrayList 和 LinkedList 内存占用有何不同？](#arraylist-和-linkedlist-内存占用有何不同)\n\nArrayList 是基于数组的，是一块连续的内存空间，所以它的内存占用是比较紧凑的；但如果涉及到扩容，就会重新分配内存，空间是原来的 1.5 倍。\n\n\n\nLinkedList 是基于链表的，每个节点都有一个指向下一个节点和上一个节点的引用，于是每个节点占用的内存空间比 ArrayList 稍微大一点。\n\n#### [ArrayList 和 LinkedList 的使用场景有什么不同？](#arraylist-和-linkedlist-的使用场景有什么不同)\n\nArrayList 适用于：\n\n* 随机访问频繁：需要频繁通过索引访问元素的场景。\n* 读取操作远多于写入操作：如存储不经常改变的列表。\n* 末尾添加元素：需要频繁在列表末尾添加元素的场景。\n\nLinkedList 适用于：\n\n* 频繁插入和删除：在列表中间频繁插入和删除元素的场景。\n* 不需要快速随机访问：顺序访问多于随机访问的场景。\n* 队列和栈：由于其双向链表的特性，LinkedList 可以实现队列（FIFO）和栈（LIFO）。\n\n#### [链表和数组有什么区别？](#链表和数组有什么区别)\n\n* 数组在内存中占用的是一块连续的存储空间，因此我们可以通过数组下标快速访问任意元素。数组在创建时必须指定大小，一旦分配内存，数组的大小就固定了。\n* 链表的元素存储在于内存中的任意位置，每个节点通过指针指向下一个节点。\n\n"
+ },
+ {
+ "id": 59,
+ "question": "ArrayList 的扩容机制了解吗？",
+ "answer": "了解。当往 ArrayList 中添加元素时，会先检查是否需要扩容，如果当前容量+1 超过数组长度，就会进行扩容。\n\n\n\n扩容后的新数组长度是原来的 1.5 倍，然后再把原数组的值拷贝到新数组中。\n\n\n```java\nprivate void grow(int minCapacity) {\n // overflow-conscious code\n int oldCapacity = elementData.length;\n int newCapacity = oldCapacity + (oldCapacity >> 1);\n if (newCapacity - minCapacity < 0)\n newCapacity = minCapacity;\n if (newCapacity - MAX_ARRAY_SIZE > 0)\n newCapacity = hugeCapacity(minCapacity);\n // minCapacity is usually close to size, so this is a win:\n elementData = Arrays.copyOf(elementData, newCapacity);\n}\n```"
+ },
+ {
+ "id": 60,
+ "question": "ArrayList 怎么序列化的知道吗？",
+ "answer": "在 ArrayList 中，writeObject 方法被重写了，用于自定义序列化逻辑：只序列化有效数据，因为 elementData 数组的容量一般大于实际的元素数量，声明的时候也加了 transient 关键字。\n\n\n\n#### [为什么 ArrayList 不直接序列化元素数组呢？](#为什么-arraylist-不直接序列化元素数组呢)\n\n出于效率的考虑，数组可能长度 100，但实际只用了 50，剩下的 50 没用到，也就不需要序列化。\n\n\n```java\nprivate void writeObject(java.io.ObjectOutputStream s)\n throws java.io.IOException {\n // 将当前 ArrayList 的结构进行序列化\n int expectedModCount = modCount;\n s.defaultWriteObject(); // 序列化非 transient 字段\n // 序列化数组的大小\n s.writeInt(size);\n // 序列化每个元素\n for (int i = 0; i < size; i++) {\n s.writeObject(elementData[i]);\n }\n // 检查是否在序列化期间发生了并发修改\n if (modCount != expectedModCount) {\n throw new ConcurrentModificationException();\n }\n}\n```"
+ },
+ {
+ "id": 61,
+ "question": "快速失败fail-fast了解吗？",
+ "answer": "fail—fast 是 Java 集合的一种错误检测机制。\n\n在用迭代器遍历集合对象时，如果线程 A 遍历过程中，线程 B 对集合对象的内容进行了修改，就会抛出 Concurrent Modification Exception。\n\n迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 `modCount` 变量。集合在被遍历期间如果内容发生变化，就会改变`modCount`的值。每当迭代器使用 `hashNext()/next()`遍历下一个元素之前，都会检测 modCount 变量是否为 expectedmodCount 值，是的话就返回遍历；否则抛出异常，终止遍历。\n\n异常的抛出条件是检测到 `modCount！=expectedmodCount` 这个条件。如果集合发生变化时修改 modCount 值刚好又设置为了 expectedmodCount 值，则异常不会抛出。因此，不能依赖于这个异常是否抛出而进行并发操作的编程，这个异常只建议用于检测并发修改的 bug。\n\njava.util 包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改），比如 ArrayList 类。\n\n#### [什么是安全失败（fail—safe）呢？](#什么是安全失败-fail—safe-呢)\n\n采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。\n\n原理：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发 Concurrent Modification Exception。\n\n缺点：基于拷贝内容的优点是避免了 Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。\n\n场景：java.util.concurrent 包下的容器都是安全失败，可以在多线程下并发使用，并发修改，比如 CopyOnWriteArrayList 类。"
+ },
+ {
+ "id": 62,
+ "question": "有哪几种实现 ArrayList 线程安全的方法？",
+ "answer": "常用的有两种。\n\n可以使用 `Collections.synchronizedList()` 方法，它可以返回一个线程安全的 List。\n\n\n```java\nSynchronizedList list = Collections.synchronizedList(new ArrayList());\n```\n\n\n内部是通过 加锁来实现的。\n\n也可以直接使用 ，它是线程安全的 ArrayList，遵循写时复制的原则，每当对列表进行修改时，都会创建一个新副本，这个新副本会替换旧的列表，而对旧列表的所有读取操作仍然在原有的列表上进行。\n\n\n```java\nCopyOnWriteArrayList list = new CopyOnWriteArrayList();\n```\n\n\n通俗的讲，CopyOnWrite 就是当我们往一个容器添加元素的时候，不直接往容器中添加，而是先复制出一个新的容器，然后在新的容器里添加元素，添加完之后，再将原容器的引用指向新的容器。多个线程在读的时候，不需要加锁，因为当前容器不会添加任何元素。这样就实现了线程安全。\n\n#### [ArrayList 和 Vector 的区别？](#arraylist-和-vector-的区别)\n\nVector 属于 JDK 1.0 时期的遗留类，不推荐使用，仍然保留着是因为 Java 希望向后兼容。\n\nArrayList 是在 JDK 1.2 时引入的，用于替代 Vector 作为主要的非同步动态数组实现。因为 Vector 所有的方法都使用了 synchronized 关键字进行同步，所以单线程环境下效率较低。\n\n"
+ },
+ {
+ "id": 63,
+ "question": "CopyOnWriteArrayList 了解多少？",
+ "answer": "CopyOnWriteArrayList 就是线程安全版本的 ArrayList。\n\n`CopyOnWrite`——写时复制，已经明示了它的原理。\n\nCopyOnWriteArrayList 采用了一种读写分离的并发策略。CopyOnWriteArrayList 容器允许并发读，读操作是无锁的。至于写操作，比如说向容器中添加一个元素，首先将当前容器复制一份，然后在新副本上执行写操作，结束之后再将原容器的引用指向新容器。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 17,
+ "categoryName": "Map",
+ "questions": [
+ {
+ "id": 64,
+ "question": "能说一下 HashMap 的底层数据结构吗？",
+ "answer": "JDK 8 中 HashMap 的数据结构是`数组`+`链表`+`红黑树`。\n\n\n\n数组用来存储键值对，每个键值对可以通过索引直接拿到，索引是通过对键的哈希值进行进一步的 `hash()` 处理得到的。\n\n当多个键经过哈希处理后得到相同的索引时，需要通过链表来解决哈希冲突——将具有相同索引的键值对通过链表存储起来。\n\n不过，链表过长时，查询效率会比较低，于是当链表的长度超过 8 时（且数组的长度大于 64），链表就会转换为红黑树。红黑树的查询效率是 O(logn)，比链表的 O(n) 要快。\n\n`hash()` 方法的目标是尽量减少哈希冲突，保证元素能够均匀地分布在数组的每个位置上。\n\n\n```java\nstatic final int hash(Object key) {\n int h;\n return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```\n\n\n如果键的哈希值已经在数组中存在，其对应的值将被新值覆盖。\n\nHashMap 的初始容量是 16，随着元素的不断添加，HashMap 就需要进行扩容，阈值是`capacity * loadFactor`，capacity 为容量，loadFactor 为负载因子，默认为 0.75。\n\n扩容后的数组大小是原来的 2 倍，然后把原来的元素重新计算哈希值，放到新的数组中。"
+ },
+ {
+ "id": 65,
+ "question": "你对红黑树了解多少？",
+ "answer": "红黑树是一种自平衡的二叉查找树：\n\n1. 每个节点要么是红色，要么是黑色；\n2. 根节点永远是黑色；\n3. 所有的叶子节点都是是黑色的（下图中的 NULL 节点）；\n4. 红色节点的子节点一定是黑色的；\n5. 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。\n\n\n\n#### [为什么不用二叉树？](#为什么不用二叉树)\n\n二叉树是最基本的树结构，每个节点最多有两个子节点，但是二叉树容易出现极端情况，比如插入的数据是有序的，那么二叉树就会退化成链表，查询效率就会变成 O(n)。\n\n#### [为什么不用平衡二叉树？](#为什么不用平衡二叉树)\n\n平衡二叉树比红黑树的要求更高，每个节点的左右子树的高度最多相差 1，这种高度的平衡保证了极佳的查找效率，但在进行插入和删除操作时，可能需要频繁地进行旋转来维持树的平衡，维护成本更高。\n\n#### [为什么用红黑树？](#为什么用红黑树)\n\n链表的查找时间复杂度是 `O(n)`，当链表长度较长时，查找性能会下降。红黑树是一种折中的方案，查找、插入、删除的时间复杂度都是 `O(log n)`。"
+ },
+ {
+ "id": 66,
+ "question": "红黑树怎么保持平衡的？",
+ "answer": "`旋转`和`染色`。\n\n①、通过左旋和右旋来调整树的结构，避免某一侧过深。\n\n\n\n②、染⾊，修复红黑规则，从而保证树的高度不会失衡。\n\n"
+ },
+ {
+ "id": 67,
+ "question": "HashMap 的 put 流程知道吗？",
+ "answer": "哈希寻址 → 处理哈希冲突（链表还是红黑树）→ 判断是否需要扩容 → 插入/覆盖节点。\n\n\n\n详细版：\n\n第一步，通过 hash 方法进一步扰动哈希值，以减少哈希冲突。\n\n\n```java\nstatic final int hash(Object key) {\n int h;\n return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```\n\n\n第二步，进行第一次的数组扩容；并使用哈希值和数组长度进行取模运算，确定索引位置。\n\n\n```java\nif ((tab = table) == null || (n = tab.length) == 0)\n n = (tab = resize()).length;\n\nif ((p = tab[i = (n - 1) & hash]) == null)\n tab[i] = newNode(hash, key, value, null);\n```\n\n\n如果当前位置为空，直接将键值对插入该位置；否则判断当前位置的第一个节点是否与新节点的 key 相同，如果相同直接覆盖 value，如果不同，说明发生哈希冲突。\n\n如果是链表，将新节点添加到链表的尾部；如果链表长度大于等于 8，则将链表转换为红黑树。\n\n\n```java\npublic V put(K key, V value) {\n return putVal(hash(key), key, value, false, true);\n}\n\nfinal V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {\n Node[] tab; Node p; int n, i;\n // 如果 table 为空，先进行初始化\n if ((tab = table) == null || (n = tab.length) == 0)\n n = (tab = resize()).length;\n \n // 计算索引位置，并找到对应的桶\n if ((p = tab[i = (n - 1) & hash]) == null)\n tab[i] = newNode(hash, key, value, null); // 如果桶为空，直接插入\n else {\n Node e; K k;\n // 检查第一个节点是否匹配\n if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))\n e = p; // 覆盖\n // 如果是树节点，放入树中\n else if (p instanceof TreeNode)\n e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);\n // 如果是链表，遍历插入到尾部\n else {\n for (int binCount = 0; ; ++binCount) {\n if ((e = p.next) == null) {\n p.next = newNode(hash, key, value, null);\n // 如果链表长度达到阈值，转换为红黑树\n if (binCount >= TREEIFY_THRESHOLD - 1)\n treeifyBin(tab, hash);\n break;\n }\n if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))\n break; // 覆盖\n p = e;\n }\n }\n if (e != null) { // 如果找到匹配的 key，则覆盖旧值\n V oldValue = e.value;\n if (!onlyIfAbsent || oldValue == null)\n e.value = value;\n afterNodeAccess(e);\n return oldValue;\n }\n }\n ++modCount; // 修改计数器\n if (++size > threshold)\n resize(); // 检查是否需要扩容\n afterNodeInsertion(evict);\n return null;\n}\n```\n\n\n每次插入新元素后，检查是否需要扩容，如果当前元素个数大于阈值（`capacity * loadFactor`），则进行扩容，扩容后的数组大小是原来的 2 倍；并且重新计算每个节点的索引，进行数据重新分布。\n\n#### [只重写元素的 equals 方法没重写 hashCode，put 的时候会发生什么?](#只重写元素的-equals-方法没重写-hashcode-put-的时候会发生什么)\n\n如果只重写 equals 方法，没有重写 hashCode 方法，那么会导致 equals 相等的两个对象，hashCode 不相等，这样的话，两个对象会被 put 到数组中不同的位置，导致 get 的时候，无法获取到正确的值。"
+ },
+ {
+ "id": 68,
+ "question": "HashMap 怎么查找元素的呢？",
+ "answer": "通过哈希值定位索引 → 定位桶 → 检查第一个节点 → 遍历链表或红黑树查找 → 返回结果。\n\n"
+ },
+ {
+ "id": 69,
+ "question": "HashMap 的 hash 函数是怎么设计的?",
+ "answer": "先拿到 key 的哈希值，是一个 32 位的 int 类型数值，然后再让哈希值的高 16 位和低 16 位进行异或操作，这样能保证哈希分布均匀。\n\n\n```java\nstatic final int hash(Object key) {\n int h;\n // 如果 key 为 null，返回 0；否则，使用 hashCode 并进行扰动\n return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```"
+ },
+ {
+ "id": 70,
+ "question": "为什么 hash 函数能减少哈希冲突？",
+ "answer": "快速回答：哈希表的索引是通过 `h & (n-1)` 计算的，n 是底层数组的容量；n-1 和某个哈希值做 `&` 运算，相当于截取了最低的四位。如果数组的容量很小，只取 h 的低位很容易导致哈希冲突。\n\n通过异或操作将 h 的高位引入低位，可以增加哈希值的随机性，从而减少哈希冲突。\n\n解释一下。\n\n\n\n以初始长度 16 为例，16-1=15。2 进制表示是`0000 0000 0000 0000 0000 0000 0000 1111`。只取最后 4 位相等于哈希值的高位都丢弃了。\n\n\n\n比如说 1111 1111 1111 1111 1111 1111 1111 1111，取最后 4 位，也就是 1111。\n\n1110 1111 1111 1111 1111 1111 1111 1111，取最后 4 位，也是 1111。\n\n不就发生哈希冲突了吗？\n\n这时候 hash 函数 `(h = key.hashCode()) ^ (h >>> 16)` 就派上用场了。\n\n\n\n将哈希值无符号右移 16 位，意味着原哈希值的高 16 位被移到了低 16 位的位置。这样，原始哈希值的高 16 位和低 16 位就可以参与到最终用于索引计算的低位中。\n\n选择 16 位是因为它是 32 位整数的一半，这样处理既考虑了高位的信息，又没有完全忽视低位原本的信息，从而达到了一种微妙的平衡状态。\n\n举个例子（数组长度为 16）。\n\n* 第一个键值对的键：h1 = 0001 0010 0011 0100 0101 0110 0111 1000\n* 第二个键值对的键：h2 = 0001 0010 0011 0101 0101 0110 0111 1000\n\n如果没有 hash 函数，直接取低 4 位，那么 h1 和 h2 的低 4 位都是 1000，也就是说两个键值对都会放在数组的第 8 个位置。\n\n来看一下 hash 函数的处理过程。\n\n①、对于第一个键`h1`的计算：\n\n\n```text\n原始: 0001 0010 0011 0100 0101 0110 0111 1000\n右移: 0000 0000 0000 0000 0001 0010 0011 0100\n异或: ---------------------------------------\n结果: 0001 0010 0011 0100 0100 0100 0100 1100\n```\n\n\n②、对于第二个键`h2`的计算：\n\n\n```text\n原始: 0001 0010 0011 0101 0101 0110 0111 1000\n右移: 0000 0000 0000 0000 0001 0010 0011 0101\n异或: ---------------------------------------\n结果: 0001 0010 0011 0101 0100 0100 0100 1101\n```\n\n\n通过上述计算，我们可以看到`h1`和`h2`经过`h ^ (h >>> 16)`操作后得到了不同的结果。\n\n现在，考虑数组长度为 16 时（需要最低 4 位来确定索引）：\n\n* 对于`h1`的最低 4 位是`1100`（十进制中为 12）\n* 对于`h2`的最低 4 位是`1101`（十进制中为 13）\n\n这样，`h1`和`h2`就会被分别放在数组的第 12 个位置和第 13 个位置上，从而避免了哈希冲突。"
+ },
+ {
+ "id": 71,
+ "question": "为什么 HashMap 的容量是 2 的幂次方？",
+ "answer": "是为了快速定位元素在底层数组中的下标。\n\nHashMap 是通过 `hash & (n-1)` 来定位元素下标的，n 为数组的大小，也就是 HashMap 底层数组的容量。\n\n数组长度-1 正好相当于一个“低位掩码”——掩码的低位最好全是 1，这样 & 运算才有意义，否则结果一定是 0。\n\n2 幂次方刚好是偶数，偶数-1 是奇数，奇数的二进制最后一位是 1，也就保证了 `hash &(length-1)` 的最后一位可能为 0，也可能为 1（取决于 hash 的值），这样可以保证哈希值的均匀分布。\n\n换句话说，& 操作的结果就是将哈希值的高位全部归零，只保留低位值。\n\n> a&b 的结果是：a、b 中对应位同时为 1，则结果为 1，否则为 0。例如 5&3=1，5 的二进制是 0101，3 的二进制是 0011，5&3=0001=1。\n\n假设某哈希值的二进制为 `10100101 11000100 00100101`，用它来做 & 运算，我们来看一下结果。\n\n已知 HashMap 的初始长度为 16，16-1=15，二进制是 `00000000 00000000 00001111`（高位用 0 来补齐）：\n\n\n```text\n\t 10100101 11000100 00100101\n&\t 00000000 00000000 00001111\n----------------------------------\n\t 00000000 00000000 00000101\n```\n\n\n因为 15 的高位全部是 0，所以 & 运算后的高位结果肯定也是 0，只剩下 4 个低位 `0101`，也就是十进制的 5。\n\n这样，哈希值为 `10100101 11000100 00100101` 的键就会放在数组的第 5 个位置上。\n\n#### [对数组长度取模定位数组下标，这块有没有优化策略？](#对数组长度取模定位数组下标-这块有没有优化策略)\n\n快速回答：HashMap 的策略是将取模运算 `hash % table.length` 优化为位运算 `hash & (length - 1)`。\n\n因为当数组的长度是 2 的 N 次幂时，`hash & (length - 1) = hash % length`。\n\n比如说 9 % 4 = 1，9 的二进制是 1001，4 - 1 = 3，3 的二进制是 0011，9 & 3 = 1001 & 0011 = 0001 = 1。\n\n再比如说 10 % 4 = 2，10 的二进制是 1010，4 - 1 = 3，3 的二进制是 0011，10 & 3 = 1010 & 0011 = 0010 = 2。\n\n当数组的长度不是 2 的 n 次方时，`hash % length` 和 `hash & (length - 1)` 的结果就不一致了。\n\n比如说 7 % 3 = 1，7 的二进制是 0111，3 - 1 = 2，2 的二进制是 0010，7 & 2 = 0111 & 0010 = 0010 = 2。\n\n从二进制角度来看，hash / length = hash / 2n = hash >> n，即把 hash 右移 n 位，此时得到了 hash / 2n 的商。\n\n而被移调的部分，则是 hash % 2n，也就是余数。\n\n2n 的二进制形式为 1，后面跟着 n 个 0，那 2n - 1 的二进制则是 n 个 1。例如 8 = 23，二进制是 1000，7 = 23 - 1，二进制为 0111。\n\n`hash % length`的操作是求 hash 除以 2n 的余数。在二进制中，这个操作的结果就是 hash 的二进制表示中最低 n 位的值。\n\n因为在 2n 取模的操作中，高于 2n 表示位的所有数值对结果没有贡献，只有低于这个阈值的部分才决定余数。\n\n比如说 26 的二进制是 11010，要计算 26 % 8，8 是 23，所以我们关注的是 26 的二进制表示中最低 3 位：11010 的最低 3 位是 010。\n\n010 对应于十进制中的 2，26 % 8 的结果是 2。\n\n当执行`hash & (length - 1)`时，实际上是保留 hash 二进制表示的最低 n 位，其他高位都被清零。\n\n举个例子，hash 为 14，n 为 3，也就是数组长度为 23，也就是 8。\n\n\n```text\n 1110 (hash = 14)\n& 0111 (length - 1 = 7)\n ----\n 0110 (结果 = 6)\n```\n\n\n保留 14 的最低 3 位，高位被清零。\n\n从此，两个运算 `hash % length` 和 `hash & (length - 1)` 有了完美的闭环。在计算机中，位运算的速度要远高于取余运算，因为计算机本质上就是二进制嘛。\n\n#### [说说什么是取模运算？](#说说什么是取模运算)\n\n在 Java 中，通常使用 % 运算符来表示取余，用 `Math.floorMod()` 来表示取模。\n\n当操作数都是正数的话，取模运算和取余运算的结果是一样的；只有操作数出现负数的情况下，结果才会不同。\n\n**取模运算的商向负无穷靠近；取余运算的商向 0 靠近**。这是导致它们两个在处理有负数情况下，结果不同的根本原因。\n\n当数组的长度是 2 的 n 次幂时，取模运算/取余运算可以用位运算来代替，效率更高，毕竟计算机本身只认二进制。\n\n比如说，7 对 3 取余，和 7 对 3 取模，结果都是 1。因为两者都是基于除法运算的，7 / 3 的商是 2，余数是 1。\n\n对于 HashMap 来说，它需要通过 `hash % table.length` 来确定元素在数组中的位置。\n\n比如说，数组长度是 3，hash 是 7，那么 7 % 3 的结果就是 1，也就是此时可以把元素放在下标为 1 的位置。\n\n当 hash 是 8，8 % 3 的结果就是 2，也就是可以把元素放在下标为 2 的位置。\n\n当 hash 是 9，9 % 3 的结果就是 0，也就是可以把元素放在下标为 0 的位置上。\n\n是不是很奇妙，数组的大小为 3，刚好 3 个位置都利用上了。"
+ },
+ {
+ "id": 72,
+ "question": "如果初始化 HashMap，传一个 17 的容量，它会怎么处理？",
+ "answer": "HashMap 会将容量调整到大于等于 17 的最小的 2 的幂次方，也就是 32。\n\n\n\n这是因为哈希表的大小最好是 2 的 N 次幂，这样可以通过 `(n - 1) & hash` 高效计算出索引值。\n\n解释一下。\n\n在 HashMap 的初始化构造方法中，有这样⼀段代码：\n\n\n```java\npublic HashMap(int initialCapacity, float loadFactor) {\n ...\n this.loadFactor = loadFactor;\n this.threshold = tableSizeFor(initialCapacity);\n}\n```\n\n\n阀值 threshold 会通过⽅法 `tableSizeFor()` 进⾏计算。\n\n\n```java\nstatic final int tableSizeFor(int cap) {\n int n = cap - 1;\n n |= n >>> 1;\n n |= n >>> 2;\n n |= n >>> 4;\n n |= n >>> 8;\n n |= n >>> 16;\n return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;\n}\n```\n\n\n①、`int n = cap - 1;` 避免刚好是 2 的幂次方时，容量直接翻倍。\n\n②、接下来通过不断右移（`>>>`）并与自身进行或运算（`|=`），将 n 的二进制表示中的所有低位设置为 1。\n\n* `n |= n >>> 1;` 将最高位的 1 扩展到下一位。\n* `n |= n >>> 2;` 扩展到后两位。\n* 依此类推，直到 `n |= n >>> 16;`，扩展到后十六位，这样从最高位的 1 到最低位，就都变成了 1。\n\n③、如果 n 小于 0，说明 cap 是负数，直接返回 1。\n\n如果 n 大于或等于 MAXIMUM\\_CAPACITY（通常是230），则返回 MAXIMUM\\_CAPACITY。\n\n否则，返回 n + 1，这是因为 n 的所有低位都是 1，所以 n + 1 就是大于 cap 的最小的 2 的幂次方。\n\n#### [初始化 HashMap 的时候需要传入容量吗？](#初始化-hashmap-的时候需要传入容量吗)\n\n如果预先知道 Map 将存储大量键值对，提前指定一个足够大的初始容量可以减少因扩容导致的重哈希操作。\n\n因为每次扩容时，HashMap 需要将现有的元素插入到新的数组中，这个过程相对耗时，尤其是当 Map 中已有大量数据时。\n\n当然了，过大的初始容量会浪费内存，特别是当实际存储的元素远少于初始容量时。如果不指定初始容量，HashMap 将使用默认的初始容量 16。"
+ },
+ {
+ "id": 73,
+ "question": "你还知道哪些哈希函数的构造方法呢？",
+ "answer": "①、**除留取余法**：`H(key)=key%p(p<=N)`，关键字除以一个不大于哈希表长度的正整数 p，所得余数为地址，当然 HashMap 里进行了优化改造，效率更高，散列也更均衡。\n\n除此之外，还有这几种常见的哈希函数构造方法：\n\n②、**直接定址法**：直接根据`key`来映射到对应的数组位置，例如 1232 放到下标 1232 的位置。\n\n③、**数字分析法**：取`key`的某些数字（例如十位和百位）作为映射的位置\n\n④、**平方取中法**：取`key`平方的中间几位作为映射的位置\n\n⑤、将`key`分割成位数相同的几段，然后把它们的叠加和作为映射的位置。\n\n"
+ },
+ {
+ "id": 74,
+ "question": "解决哈希冲突有哪些方法？",
+ "answer": "简版回答：我知道的有 3 种，再哈希法、开放地址法和拉链法。\n\n#### [什么是再哈希法？](#什么是再哈希法)\n\n准备两套哈希算法，当发生哈希冲突的时候，使用另外一种哈希算法，直到找到空槽为止。对哈希算法的设计要求比较高。\n\n#### [什么是开放地址法？](#什么是开放地址法)\n\n遇到哈希冲突的时候，就去寻找下一个空的槽。有 3 种方法：\n\n* 线性探测：从冲突的位置开始，依次往后找，直到找到空槽。\n* 二次探测：从冲突的位置 x 开始，第一次增加 12 个位置，第二次增加 22，直到找到空槽。\n* 双重哈希：和再哈希法类似，准备多个哈希函数，发生冲突的时候，使用另外一个哈希函数。\n\n\n\n#### [什么是拉链法？](#什么是拉链法)\n\n也就是链地址法，当发生哈希冲突的时候，使用链表将冲突的元素串起来。HashMap 采用的正是拉链法。\n\n#### [怎么判断 key 相等呢？](#怎么判断-key-相等呢)\n\n依赖于`key`的`equals()`方法和`hashCode()`方法。\n\n\n```java\nif (e.hash == hash &&\n((k = e.key) == key || (key != null && key.equals(k))))\n```\n\n\n①、**hashCode()** ：使用`key`的`hashCode()`方法计算`key`的哈希码。\n\n②、**equals()** ：当两个`key`的哈希码相同时，`HashMap`还会调用`key`的`equals()`方法进行精确比较。只有当`equals()`方法返回`true`时，两个`key`才被认为是完全相同的。\n\n如果两个`key`的引用指向了同一个对象，那么它们的`hashCode()`和`equals()`方法都会返回`true`，所以在 equals 判断之前可以先使用`==`运算符判断一次。"
+ },
+ {
+ "id": 75,
+ "question": "为什么 HashMap 链表转红黑树的阈值为 8 呢？",
+ "answer": "树化发生在 table 数组的长度大于 64，且链表的长度大于 8 的时候。\n\n为什么是 8 呢？源码的注释也给出了答案。\n\n\n\n红黑树节点的大小大概是普通节点大小的两倍，所以转红黑树，牺牲了空间换时间，更多的是一种兜底的策略，保证极端情况下的查找效率。\n\n阈值为什么要选 8 呢？和统计学有关。理想情况下，使用随机哈希码，链表里的节点符合泊松分布，出现节点个数的概率是递减的，节点个数为 8 的情况，发生概率仅为`0.00000006`。\n\n至于红黑树转回链表的阈值为什么是 6，而不是 8？是因为如果这个阈值也设置成 8，假如发生碰撞，节点增减刚好在 8 附近，会发生链表和红黑树的不断转换，导致资源浪费。"
+ },
+ {
+ "id": 76,
+ "question": "HashMap扩容发生在什么时候呢？",
+ "answer": "当键值对数量超过阈值，也就是容量 \\* 负载因子时。\n\n\n\n#### [默认的负载因子是多少？](#默认的负载因子是多少)\n\n0.75。\n\n#### [初始容量是多少？](#初始容量是多少)\n\n16。\n\n1 左移 4 位，`0000 0001 → 0001 0000`，也就是 2 的 4 次方。\n\n\n```java\nstatic final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16\n```\n\n\n#### [为什么使用 1 << 4 而不是直接写 16？](#为什么使用-1-4-而不是直接写-16)\n\n写 `1<<4` 主要是为了强调这个值是 2 的幂次方，而不是一个完全随机的选择。\n\n无论 HashMap 是否扩容，其底层的数组长度都应该是 2 的幂次方，因为这样可以通过位运算快速计算出元素的索引。\n\n#### [为什么选择 0.75 作为 HashMap 的默认负载因子呢？](#为什么选择-0-75-作为-hashmap-的默认负载因子呢)\n\n这是一个经验值。如果设置得太低，如 0.5，会浪费空间；如果设置得太高，如 0.9，会增加哈希冲突。\n\n\n\n0.75 是 JDK 作者经过大量验证后得出的最优解，能够最大限度减少 rehash 的次数。"
+ },
+ {
+ "id": 77,
+ "question": "HashMap的扩容机制了解吗？",
+ "answer": "扩容时，HashMap 会创建一个新的数组，其容量是原来的两倍。然后遍历旧哈希表中的元素，将其重新分配到新的哈希表中。\n\n如果当前桶中只有一个元素，那么直接通过键的哈希值与数组大小取模锁定新的索引位置：`e.hash & (newCap - 1)`。\n\n如果当前桶是红黑树，那么会调用 `split()` 方法分裂树节点，以保证树的平衡。\n\n如果当前桶是链表，会通过旧键的哈希值与旧的数组大小取模 `(e.hash & oldCap) == 0` 来作为判断条件，如果条件为真，元素保留在原索引的位置；否则元素移动到原索引 + 旧数组大小的位置。\n\n#### [JDK 7 扩容的时候有什么问题？](#jdk-7-扩容的时候有什么问题)\n\nJDK 7 在扩容的时候使用头插法来重新插入链表节点，这样会导致链表无法保持原有的顺序。\n\n详细解释一下。\n\nJDK 7 是通过哈希值与数组大小-1 进行与运算确定元素下标的。\n\n\n```java\nstatic int indexFor(int h, int length) {\n return h & (length-1);\n}\n```\n\n\n我们来假设：\n\n* 数组 table 的长度为 2\n* 键的哈希值为 3、7、5\n\n取模运算后，键发生了哈希冲突，它们都需要放到 `table[1]` 的桶上。那么扩容前就是这个样子：\n\n\n\n假设负载因子 loadFactor 为 1，也就是当元素的个数大于 table 的长度时进行扩容。\n\n扩容后的数组容量为 4。\n\n* key 3 取模（3%4）后是 3，放在 `table[3]` 上。\n* key 7 取模（7%4）后是 3，放在 `table[3]` 上的链表头部。\n* key 5 取模（5%4）后是 1，放在 `table[1]` 上。\n\n\n\n可以看到，由于 JDK 采用的是头插法，7 跑到 3 的前面了，原来的顺序是 3、7、5，7 在 3 的后面。\n\n\n```java\nfor (Entry e : oldTable) {\n while (null != e) {\n Entry next = e.next;\n int i = indexFor(e.hash, newCapacity);\n e.next = newTable[i];\n newTable[i] = e;\n e = next;\n }\n}\n```\n\n\n最好的情况就是，扩容后的 7 还在 3 的后面，保持原来的顺序。\n\n#### [JDK 8 是怎么解决这个问题的？](#jdk-8-是怎么解决这个问题的)\n\nJDK 8 改用了尾插法，并且当 `(e.hash & oldCap) == 0` 时，元素保留在原索引的位置；否则元素移动到原索引 + 旧数组大小的位置。\n\n\n```java\nNode loHead = null, loTail = null;\nNode hiHead = null, hiTail = null;\nNode next;\ndo {\n next = e.next;\n if ((e.hash & oldCap) == 0) {\n if (loTail == null)\n loHead = e;\n else\n loTail.next = e;\n loTail = e;\n }\n else {\n if (hiTail == null)\n hiHead = e;\n else\n hiTail.next = e;\n hiTail = e;\n }\n} while ((e = next) != null);\nif (loHead != null)\n newTab[j] = loHead;\nif (hiHead != null)\n newTab[j + oldCap] = hiHead;\n```\n\n\n由于扩容时，数组长度会翻倍，例如：16 → 32， 因此，新数组的索引范围是原索引范围的两倍。\n\n原索引 `index = (n - 1) & hash`，扩容后的新索引就是 `index = (2n - 1) & hash`。\n\n也就是说，如果 `(e.hash & oldCap) == 0`，元素在新数组中的位置与旧位置相同；否则，元素在新数组中的位置是旧位置 + 旧数组大小。\n\n假设扩容前的数组长度为 16（n-1 也就是二进制的 0000 1111，1X20+1X21+1X22+1X23=1+2+4+8=15），key1 为 5（二进制为 0000 0101），key2 为 21（二进制为 0001 0101）。\n\n* key1 和 n-1 做 & 运算后为 0000 0101，也就是 5；\n* key2 和 n-1 做 & 运算后为 0000 0101，也就是 5。\n* 此时哈希冲突了，用拉链法来解决哈希冲突。\n\n现在，HashMap 进行了扩容，容量为原来的 2 倍，也就是 32（n-1 也就是二进制的 0001 1111，1X20+1X21+1X22+1X23+1X24=1+2+4+8+16=31）。\n\n* key1 和 n-1 做 & 运算后为 0000 0101，也就是 5；\n* key2 和 n-1 做 & 运算后为 0001 0101，也就是 21=5+16，就是数组扩容前的位置+原数组的长度。\n\n\n\n这样可以避免重新计算所有元素的哈希值，只需检查高位的某一位，就可以快速确定新位置。\n\n\n\n#### [扩容的时候每个节点都要进行位运算吗？](#扩容的时候每个节点都要进行位运算吗)\n\n不需要。HashMap 会通过 `(e.hash & oldCap)` 来判断节点是否需要移动，0 的话保留原索引；1 才需要移动到新索引（原索引 + oldCap）。\n\n这样就避免了 hashCode 的重新计算，大大提升了扩容的性能。\n\n所以，哪怕有几十万条数据，可能只有一半的数据才需要移动到新位置。另外，位运算的计算速度非常快，因此，尽管扩容操作涉及到遍历整个哈希表并对每个节点进行判断，但这部分操作的计算成本是相对较低的。"
+ },
+ {
+ "id": 78,
+ "question": "JDK 8 对 HashMap 做了哪些优化呢？",
+ "answer": "①、底层数据结构由数组 + 链表改成了数组 + 链表或红黑树的结构。\n\n如果多个键映射到了同一个哈希值，链表会变得很长，在最坏的情况下，当所有的键都映射到同一个桶中时，性能会退化到 O(n)，而红黑树的时间复杂度是 O(logn)。\n\n②、链表的插入方式由头插法改为了尾插法。头插法在扩容后容易改变原来链表的顺序。\n\n③、扩容的时机由插入时判断改为插入后判断，这样可以避免在每次插入时都进行不必要的扩容检查，因为有可能插入后仍然不需要扩容。\n\n\n\n④、哈希扰动算法也进行了优化。JDK 7 是通过多次移位和异或运算来实现的。\n\n\n\nJDK 8 让 hash 值的高 16 位和低 16 位进行了异或运算，让高位的信息也能参与到低位的计算中，这样可以极大程度上减少哈希碰撞。\n\n"
+ },
+ {
+ "id": 79,
+ "question": "你能自己设计实现一个 HashMap 吗？",
+ "answer": "> 这道题**快手**常考。红黑树版咱们多半是写不出来的，但是数组+链表版还是问题不大，详细可见： [手写 HashMap，快手面试官直呼内行！](https://mp.weixin.qq.com/s/Z9yoRZW5itrtgbS-cj0bUg)。\n\n可以，我先说一下整体的设计思路：\n\n* 第一步，实现一个 hash 函数，对键的 hashCode 进行扰动\n* 第二步，实现一个拉链法的方法来解决哈希冲突\n* 第三步，扩容后，重新计算哈希值，将元素放到新的数组中\n\n\n\n完整代码：\n\n"
+ },
+ {
+ "id": 80,
+ "question": "HashMap 是线程安全的吗？",
+ "answer": "HashMap 不是线程安全的，主要有以下几个问题：\n\n①、多线程下扩容会死循环。JDK7 中的 HashMap 使用的是头插法来处理链表，在多线程环境下扩容会出现环形链表，造成死循环。\n\n\n\n不过，JDK 8 时通过尾插法修复了这个问题，扩容时会保持链表原来的顺序。\n\n②、多线程在进行 put 元素的时候，可能会导致元素丢失。因为计算出来的位置可能会被其他线程覆盖掉，比如说一个县城 put 3 的时候，另外一个线程 put 了 7，就把 3 给弄丢了。\n\n\n\n③、put 和 get 并发时，可能导致 get 为 null。线程 1 执行 put 时，因为元素个数超出阈值而扩容，线程 2 此时执行 get，就有可能出现这个问题。\n\n\n\n因为线程 1 执行完 table = newTab 之后，线程 2 中的 table 已经发生了改变，比如说索引 3 的键值对移动到了索引 7 的位置，此时线程 2 去 get 索引 3 的元素就 get 不到了。"
+ },
+ {
+ "id": 81,
+ "question": "怎么解决 HashMap 线程不安全的问题呢？",
+ "answer": "在早期的 JDK 版本中，可以用 Hashtable 来保证线程安全。Hashtable 在方法上加了 。\n\n\n\n另外，可以通过 `Collections.synchronizedMap` 方法返回一个线程安全的 Map，内部是通过 synchronized 对象锁来保证线程安全的，比在方法上直接加 synchronized 关键字更轻量级。\n\n\n\n更优雅的解决方案是使用并发工具包下的 ，使用了+ 来保证线程安全。\n\n"
+ },
+ {
+ "id": 82,
+ "question": "HashMap 内部节点是有序的吗？",
+ "answer": "无序的，根据 hash 值随机插入。"
+ },
+ {
+ "id": 83,
+ "question": "讲讲 LinkedHashMap 怎么实现有序的？",
+ "answer": "LinkedHashMap 在 HashMap 的基础上维护了一个双向链表，通过 before 和 after 标识前置节点和后置节点。\n\n\n\n从而实现插入的顺序或访问顺序。\n\n"
+ },
+ {
+ "id": 84,
+ "question": "讲讲 TreeMap 怎么实现有序的？",
+ "answer": "TreeMap 通过 key 的比较器来决定元素的顺序，如果没有指定比较器，那么 key 必须实现 。\n\n\n\nTreeMap 的底层是红黑树，红黑树是一种自平衡的二叉查找树，每个节点都大于其左子树中的任何节点，小于其右子节点树种的任何节点。\n\n\n\n插入或者删除元素时通过旋转和染色来保持树的平衡。\n\n查找的时候从根节点开始，利用二叉查找树的特点，逐步向左子树或者右子树递归查找，直到找到目标元素。"
+ },
+ {
+ "id": 85,
+ "question": "TreeMap 和 HashMap 的区别",
+ "answer": "①、HashMap 是基于数组+链表+红黑树实现的，put 元素的时候会先计算 key 的哈希值，然后通过哈希值计算出元素在数组中的存放下标，然后将元素插入到指定的位置，如果发生哈希冲突，会使用链表来解决，如果链表长度大于 8，会转换为红黑树。\n\n②、TreeMap 是基于红黑树实现的，put 元素的时候会先判断根节点是否为空，如果为空，直接插入到根节点，如果不为空，会通过 key 的比较器来判断元素应该插入到左子树还是右子树。\n\n在没有发生哈希冲突的情况下，HashMap 的查找效率是 `O(1)`。适用于查找操作比较频繁的场景。\n\nTreeMap 的查找效率是 `O(logn)`。并且保证了元素的顺序，因此适用于需要大量范围查找或者有序遍历的场景。"
+ }
+ ]
+ },
+ {
+ "id": 18,
+ "categoryName": "Set",
+ "questions": [
+ {
+ "id": 86,
+ "question": "讲讲 HashSet 的底层实现？",
+ "answer": "HashSet 是由 HashMap 实现的，只不过值由一个固定的 Object 对象填充，而键用于操作。\n\n\n```java\npublic class HashSet\n extends AbstractSet\n implements Set, Cloneable, java.io.Serializable\n{\n static final long serialVersionUID = -5024744406713321676L;\n private transient HashMap map;\n // Dummy value to associate with an Object in the backing Map\n private static final Object PRESENT = new Object();\n // ……\n}\n```\n\n\n实际开发中，HashSet 并不常用，比如，如果我们需要按照顺序存储一组元素，那么 ArrayList 和 LinkedList 更适合；如果我们需要存储键值对并根据键进行查找，那么 HashMap 可能更适合。\n\nHashSet 主要用于去重，比如，我们需要统计一篇文章中有多少个不重复的单词，就可以使用 HashSet 来实现。\n\n\n```java\n// 创建一个 HashSet 对象\nHashSet set = new HashSet<>();\n\n// 添加元素\nset.add(\"practice-mate\");\nset.add(\"练习伴侣二\");\nset.add(\"陈清扬\");\nset.add(\"practice-mate\");\n\n// 输出 HashSet 的元素个数\nSystem.out.println(\"HashSet size: \" + set.size()); // output: 3\n\n// 遍历 HashSet\nfor (String s : set) {\n System.out.println(s);\n}\n```\n\n\nHashSet 会自动去重，因为它是用 HashMap 实现的，HashMap 的键是唯一的，相同键会覆盖掉原来的键，于是第二次 add 一个相同键的元素会直接覆盖掉第一次的键。\n\n\n\n#### [HashSet 和 ArrayList 的区别](#hashset-和-arraylist-的区别)\n\n* ArrayList 是基于动态数组实现的，HashSet 是基于 HashMap 实现的。\n* ArrayList 允许重复元素和 null 值，可以有多个相同的元素；HashSet 保证每个元素唯一，不允许重复元素，基于元素的 hashCode 和 equals 方法来确定元素的唯一性。\n* ArrayList 保持元素的插入顺序，可以通过索引访问元素；HashSet 不保证元素的顺序，元素的存储顺序依赖于哈希算法，并且可能随着元素的添加或删除而改变。\n\n#### [HashSet 怎么判断元素重复，重复了是否 put](#hashset-怎么判断元素重复-重复了是否-put)\n\nHashSet 的 add 方法是通过调用 HashMap 的 put 方法实现的：\n\n\n```java\npublic boolean add(E e) {\n return map.put(e, PRESENT)==null;\n}\n```\n\n\n所以 HashSet 判断元素重复的逻辑底层依然是 HashMap 的底层逻辑：\n\n\n\nHashMap 在插入元素时，通常需要三步：\n\n第一步，通过 hash 方法计算 key 的哈希值。\n\n\n```java\nstatic final int hash(Object key) {\n int h;\n return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```\n\n\n第二步，数组进行第一次扩容。\n\n\n```java\nif ((tab = table) == null || (n = tab.length) == 0)\n n = (tab = resize()).length;\n```\n\n\n第三步，根据哈希值计算 key 在数组中的下标，如果对应下标正好没有存放数据，则直接插入。\n\n\n```java\nif ((p = tab[i = (n - 1) & hash]) == null)\n tab[i] = newNode(hash, key, value, null);\n```\n\n\n如果对应下标已经有数据了，就需要判断是否为相同的 key，是则覆盖 value，否则需要判断是否为树节点，是则向树中插入节点，否则向链表中插入数据。\n\n\n```java\nelse {\n Node e; K k;\n if (p.hash == hash &&\n ((k = p.key) == key || (key != null && key.equals(k))))\n e = p;\n else if (p instanceof TreeNode)\n e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);\n else {\n for (int binCount = 0; ; ++binCount) {\n if ((e = p.next) == null) {\n p.next = newNode(hash, key, value, null);\n if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st\n treeifyBin(tab, hash);\n break;\n }\n if (e.hash == hash &&\n ((k = e.key) == key || (key != null && key.equals(k))))\n break;\n p = e;\n }\n }\n}\n```\n\n\n也就是说，HashSet 通过元素的哈希值来判断元素是否重复，如果重复了，会覆盖原来的值。\n\n\n```java\nif (e != null) { // existing mapping for key\n V oldValue = e.value;\n if (!onlyIfAbsent || oldValue == null)\n e.value = value;\n afterNodeAccess(e);\n return oldValue;\n}\n```"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 3,
+ "topicName": "Java并发",
+ "categories": [
+ {
+ "id": 19,
+ "categoryName": "基础",
+ "questions": [
+ {
+ "id": 87,
+ "question": "并行跟并发有什么区别？",
+ "answer": "* 并行是多核 CPU 上的多任务处理，多个任务在同一时间真正地同时执行。\n* 并发是单核 CPU 上的多任务处理，多个任务在同一时间段内交替执行，通过时间片轮转实现交替执行，用于解决 IO 密集型任务的瓶颈。\n\n\n\n举个例子，就好像我们去食堂打饭，并行就是每个人对应一个阿姨，同时打饭；而并发就是一个阿姨，轮流给每个人打饭，假如有个人磨磨唧唧，阿姨就会吆喝下一个人，这样就能提高食堂的打饭效率。\n\n\n\n#### [你是如何理解线程安全的？](#你是如何理解线程安全的)\n\n如果一段代码块或者一个方法被多个线程同时执行，还能够正确地处理共享数据，那么这段代码块或者这个方法就是线程安全的。\n\n可以从三个要素来确保线程安全：\n\n**①、原子性**：一个操作要么完全执行，要么完全不执行，不会出现中间状态。\n\n\n\n可以通过同步关键字 synchronized 或原子操作，如 AtomicInteger 来保证原子性。\n\n\n```java\nAtomicInteger count = new AtomicInteger(0);\ncount.incrementAndGet(); // 原子操作\n```\n\n\n**②、可见性**：当一个线程修改了共享变量，其他线程能够立即看到变化。\n\n\n\n可以通过 volatile 关键字来保证可见性。\n\n\n```java\nprivate volatile String itwanger = \"练习伴侣二\";\n```\n\n\n**③、有序性**：要确保线程不会因为死锁、饥饿、活锁等问题导致无法继续执行。\n\n"
+ },
+ {
+ "id": 88,
+ "question": "说说进程和线程的区别？",
+ "answer": "进程说简单点就是我们在电脑上启动的一个个应用。它是操作系统分配资源的最小单位。\n\n线程是进程中的独立执行单元。多个线程可以共享同一个进程的资源，如内存；每个线程都有自己独立的栈和寄存器。\n\n\n\n#### [如何理解协程？](#如何理解协程)\n\n协程被视为比线程更轻量级的并发单元，可以在单线程中实现并发执行，由我们开发者显式调度。\n\n协程是在用户态进行调度的，避免了线程切换时的内核态开销。\n\nJava 自身是不支持携程的，我们可以使用 Quasar、Kotlin 等框架来实现协程。\n\n\n```java\nfun main() = runBlocking {\n launch {\n delay(1000L)\n println(\"World!\")\n }\n println(\"Hello,\")\n}\n```\n\n\n#### [线程间是如何进行通信的？](#线程间是如何进行通信的)\n\n原则上可以通过消息传递和共享内存两种方法来实现。Java 采用的是共享内存的并发模型。\n\n这个模型被称为 Java 内存模型，简写为 JMM，它决定了一个线程对共享变量的写入，何时对另外一个线程可见。当然了，本地内存是 JMM 的一个抽象概念，并不真实存在。\n\n用一句话来概括就是：共享变量存储在主内存中，每个线程的私有本地内存，存储的是这个共享变量的副本。\n\n\n\n线程 A 与线程 B 之间如要通信，需要要经历 2 个步骤：\n\n* 线程 A 把本地内存 A 中的共享变量副本刷新到主内存中。\n* 线程 B 到主内存中读取线程 A 刷新过的共享变量，再同步到自己的共享变量副本中。\n\n"
+ },
+ {
+ "id": 89,
+ "question": "说说线程有几种创建方式？",
+ "answer": "有三种，分别是继承 Thread 类、实现 Runnable 接口、实现 Callable 接口。\n\n\n\n第一种需要重写父类 Thread 的 `run()` 方法，并且调用 `start()` 方法启动线程。\n\n\n```java\nclass ThreadTask extends Thread {\n public void run() {\n System.out.println(\"看完练习伴侣，上岸了!\");\n }\n\n public static void main(String[] args) {\n ThreadTask task = new ThreadTask();\n task.start();\n }\n}\n```\n\n\n这种方法的缺点是，如果 ThreadTask 已经继承了另外一个类，就不能再继承 Thread 类了，因为 Java 不支持多重继承。\n\n第二种需要重写 Runnable 接口的 `run()` 方法，并将实现类的对象作为参数传递给 Thread 对象的构造方法，最后调用 `start()` 方法启动线程。\n\n\n```java\nclass RunnableTask implements Runnable {\n public void run() {\n System.out.println(\"看完练习伴侣，上岸了!\");\n }\n\n public static void main(String[] args) {\n RunnableTask task = new RunnableTask();\n Thread thread = new Thread(task);\n thread.start();\n }\n}\n```\n\n\n这种方法的优点是可以避免 Java 的单继承限制，并且更符合面向对象的编程思想，因为 Runnable 接口将任务代码和线程控制的代码解耦了。\n\n第三种需要重写 Callable 接口的 `call()` 方法，然后创建 FutureTask 对象，参数为 Callable 实现类的对象；紧接着创建 Thread 对象，参数为 FutureTask 对象，最后调用 `start()` 方法启动线程。\n\n\n```java\nclass CallableTask implements Callable {\n public String call() {\n return \"看完练习伴侣，上岸了!\";\n }\n\n public static void main(String[] args) throws ExecutionException, InterruptedException {\n CallableTask task = new CallableTask();\n FutureTask futureTask = new FutureTask<>(task);\n Thread thread = new Thread(futureTask);\n thread.start();\n System.out.println(futureTask.get());\n }\n}\n```\n\n\n这种方法的优点是可以获取线程的执行结果。\n\n#### [一个 8G 内存的系统最多能创建多少个线程?](#一个-8g-内存的系统最多能创建多少个线程)\n\n理论上大约 8000 个。\n\n创建线程的时候，至少需要分配一个虚拟机栈，在 64 位操作系统中，默认大小为 1M，因此一个线程大约需要 1M 的内存。\n\n但 JVM、操作系统本身的运行就要占一定的内存空间，所以实际上可以创建的线程数远比 8000 少。\n\n详细解释一下。\n\n可以通过 `java -XX:+PrintFlagsFinal -version | grep ThreadStackSize` 命令查看 JVM 栈的默认大小。\n\n\n\n其中 ThreadStackSize 的单位是 KB，也就是说默认的 JVM 栈大小是 1024 KB，也就是 1M。\n\n#### [启动一个 Java 程序，你能说说里面有哪些线程吗？](#启动一个-java-程序-你能说说里面有哪些线程吗)\n\n首先是 main 线程，这是程序执行的入口。\n\n然后是垃圾回收线程，它是一个后台线程，负责回收不再使用的对象。\n\n还有编译器线程，比如 JIT，负责把一部分热点代码编译后放到 codeCache 中。\n\n\n\n可以通过下面的代码进行检测：\n\n\n```java\nclass ThreadLister {\n public static void main(String[] args) {\n // 获取所有线程的堆栈跟踪\n Map threads = Thread.getAllStackTraces();\n for (Thread thread : threads.keySet()) {\n System.out.println(\"Thread: \" + thread.getName() + \" (ID=\" + thread.getId() + \")\");\n }\n }\n}\n```\n\n\n结果如下所示：\n\n\n```text\nThread: Monitor Ctrl-Break (ID=5)\nThread: Reference Handler (ID=2)\nThread: main (ID=1)\nThread: Signal Dispatcher (ID=4)\nThread: Finalizer (ID=3)\n```\n\n\n简单解释下：\n\n* `Thread: main (ID=1)` - 主线程，Java 程序启动时由 JVM 创建。\n* `Thread: Reference Handler (ID=2)` - 这个线程是用来处理引用对象的，如软引用、弱引用和虚引用。负责清理被 JVM 回收的对象。\n* `Thread: Finalizer (ID=3)` - 终结器线程，负责调用对象的 finalize 方法。对象在垃圾回收器标记为可回收之前，由该线程执行其 finalize 方法，用于执行特定的资源释放操作。\n* `Thread: Signal Dispatcher (ID=4)` - 信号调度线程，处理来自操作系统的信号，将它们转发给 JVM 进行进一步处理，例如响应中断、停止等信号。\n* `Thread: Monitor Ctrl-Break (ID=5)` - 监视器线程，通常由一些特定的 IDE 创建，用于在开发过程中监控和管理程序执行或者处理中断。"
+ },
+ {
+ "id": 90,
+ "question": "调用 start 方法时会执行 run 方法，那怎么不直接调用 run方法？",
+ "answer": "调用 `start()` 会创建一个新的线程，并异步执行 `run()` 方法中的代码。\n\n直接调用 `run()` 方法只是一个普通的同步方法调用，所有代码都在当前线程中执行，不会创建新线程。没有新的线程创建，也就达不到多线程并发的目的。\n\n通过敲代码体验一下。\n\n\n```java\nclass MyThread extends Thread {\n public void run() {\n System.out.println(Thread.currentThread().getName());\n }\n\n public static void main(String[] args) {\n MyThread t1 = new MyThread();\n t1.start(); // 正确的方式，创建一个新线程，并在新线程中执行 run()\n t1.run(); // 仅在主线程中执行 run()，没有创建新线程\n }\n}\n```\n\n\n来看输出结果：\n\n\n```text\nmain\nThread-0\n```\n\n\n也就是说，调用 `start()` 方法会通知 JVM，去调用底层的线程调度机制来启动新线程。\n\n\n\n调用 `start()` 后，线程进入就绪状态，等待操作系统调度；一旦调度执行，线程会执行其 `run()` 方法中的代码。"
+ },
+ {
+ "id": 91,
+ "question": "线程有哪些常用的调度方法？",
+ "answer": "比如说 start 方法用于启动线程并让操作系统调度执行；sleep 方法用于让当前线程休眠一段时间；wait 方法会让当前线程等待，notify 会唤醒一个等待的线程。\n\n\n\n#### [说说wait方法和notify方法？](#说说wait方法和notify方法)\n\n当线程 A 调用共享对象的 `wait()` 方法时，线程 A 会被阻塞挂起，直到：\n\n* 线程 B 调用了共享对象的 `notify()` 方法或者 `notifyAll()` 方法；\n* 其他线程调用线程 A 的 `interrupt()` 方法，导致线程 A 抛出 InterruptedException 异常。\n\n线程 A 调用共享对象的 `wait(timeout)`方法后，没有在指定的 timeout 时间内被其它线程唤醒，那么这个方法会因为超时而返回。\n\n当线程 A 调用共享对象的 `notify()` 方法后，会唤醒一个在这个共享对象上调用 wait 系列方法被挂起的线程。\n\n共享对象上可能会有多个线程在等待，具体唤醒哪个线程是随机的。\n\n如果调用的是 notifyAll 方法，会唤醒所有在这个共享变量上调用 wait 系列方法而被挂起的线程。\n\n#### [说说 sleep 方法？](#说说-sleep-方法)\n\n当线程 A 调用了 Thread 的 sleep 方法后，线程 A 会暂时让出指定时间的执行权。\n\n指定的睡眠时间到了后该方法会正常返回，接着参与 CPU 调度，获取到 CPU 资源后可以继续执行。\n\n#### [说说yield方法？](#说说yield方法)\n\n`yield()` 方法的目的是让当前线程让出 CPU 使用权，回到就绪状态。但是线程调度器可能会忽略。\n\n#### [说说interrupt方法？](#说说interrupt方法)\n\n`interrupt()` 方法用于通知线程停止，但不会直接终止线程，需要线程自行处理中断标志。\n\n常与 `isInterrupted()` 或 `Thread.interrupted()` 配合使用。\n\n\n```java\nThread thread = new Thread(() -> {\n while (!Thread.currentThread().isInterrupted()) {\n System.out.println(\"Running\");\n }\n System.out.println(\"Interrupted\");\n});\nthread.start();\nthread.interrupt(); // 中断线程\n```\n\n\n#### [说说 stop 方法？](#说说-stop-方法)\n\nstop 方法用来强制停止线程，目前已经处于废弃状态，因为 stop 方法可能会在不一致的状态下释放锁，破坏对象的一致性。\n\n"
+ },
+ {
+ "id": 92,
+ "question": "线程有几种状态？",
+ "answer": "6 种。\n\nnew 代表线程被创建但未启动；runnable 代表线程处于就绪或正在运行状态，由操作系统调度；blocked 代表线程被阻塞，等待获取锁；waiting 代表线程等待其他线程的通知或中断；timed\\_waiting 代表线程会等待一段时间，超时后自动恢复；terminated 代表线程执行完毕，生命周期结束。\n\n\n\n也就是说，线程的生命周期可以分为五个主要阶段：新建、就绪、运行、阻塞和终止。线程在运行过程中会根据状态的变化在这些阶段之间切换。\n\n\n```java\nclass ThreadStateExample {\n public static void main(String[] args) throws InterruptedException {\n Thread thread = new Thread(() -> {\n try {\n Thread.sleep(2000); // TIMED_WAITING\n synchronized (ThreadStateExample.class) {\n ThreadStateExample.class.wait(); // WAITING\n }\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n });\n\n System.out.println(\"State after creation: \" + thread.getState()); // NEW\n\n thread.start();\n System.out.println(\"State after start: \" + thread.getState()); // RUNNABLE\n\n Thread.sleep(500);\n System.out.println(\"State while sleeping: \" + thread.getState()); // TIMED_WAITING\n\n synchronized (ThreadStateExample.class) {\n ThreadStateExample.class.notify(); // 唤醒线程\n }\n\n thread.join();\n System.out.println(\"State after termination: \" + thread.getState()); // TERMINATED\n }\n}\n```\n\n\n用一个表格来做个总结：\n\n| 状态 | 说明 |\n| --- | --- |\n| NEW | 当线程被创建后，如通过`new Thread()`，它处于新建状态。此时，线程已经被分配了必要的资源，但还没有开始执行。 |\n| RUNNABLE | 当调用线程的`start()`方法后，线程进入可运行状态。在这个状态下，线程可能正在运行也可能正在等待获取 CPU 时间片，具体取决于线程调度器的调度策略。 |\n| BLOCKED | 线程在试图获取一个锁以进入同步块/方法时，如果锁被其他线程持有，线程将进入阻塞状态，直到它获取到锁。 |\n| WAITING | 线程进入等待状态是因为调用了如下方法之一：`Object.wait()`或`LockSupport.park()`。在等待状态下，线程需要其他线程显式地唤醒，否则不会自动执行。 |\n| TIME\\_WAITING | 当线程调用带有超时参数的方法时，如`Thread.sleep(long millis)`、`Object.wait(long timeout)` 或`LockSupport.parkNanos()`，它将进入超时等待状态。线程在指定的等待时间过后会自动返回可运行状态。 |\n| TERMINATED | 当线程的`run()`方法执行完毕后，或者因为一个未捕获的异常终止了执行，线程进入终止状态。一旦线程终止，它的生命周期结束，不能再被重新启动。 |\n\n#### [如何强制终止线程？](#如何强制终止线程)\n\n第一步，调用线程的 `interrupt()` 方法，请求终止线程。\n\n第二步，在线程的 `run()` 方法中检查中断状态，如果线程被中断，就退出线程。\n\n\n```java\nclass MyTask implements Runnable {\n @Override\n public void run() {\n while (!Thread.currentThread().isInterrupted()) {\n try {\n System.out.println(\"Running...\");\n Thread.sleep(1000); // 模拟工作\n } catch (InterruptedException e) {\n // 捕获中断异常后，重置中断状态\n Thread.currentThread().interrupt();\n System.out.println(\"Thread interrupted, exiting...\");\n break;\n }\n }\n }\n}\n\npublic class Main {\n public static void main(String[] args) throws InterruptedException {\n Thread thread = new Thread(new MyTask());\n thread.start();\n Thread.sleep(3000); // 主线程等待3秒\n thread.interrupt(); // 请求终止线程\n }\n}\n```\n\n\n中断结果：\n\n"
+ },
+ {
+ "id": 93,
+ "question": "什么是线程上下文切换？",
+ "answer": "线程上下文切换是指 CPU 从一个线程切换到另一个线程执行时的过程。\n\n在线程切换的过程中，CPU 需要保存当前线程的执行状态，并加载下一个线程的上下文。\n\n之所以要这样，是因为 CPU 在同一时刻只能执行一个线程，为了实现多线程并发执行，需要不断地在多个线程之间切换。\n\n\n\n为了让用户感觉多个线程是在同时执行的， CPU 资源的分配采用了时间片轮转的方式，线程在时间片内占用 CPU 执行任务。当线程使用完时间片后，就会让出 CPU 让其他线程占用。\n\n\n\n#### [线程可以被多核调度吗？](#线程可以被多核调度吗)\n\n多核处理器提供了并行执行多个线程的能力。每个核心可以独立执行一个或多个线程，操作系统的任务调度器会根据策略和算法，如优先级调度、轮转调度等，决定哪个线程何时在哪个核心上运行。"
+ },
+ {
+ "id": 94,
+ "question": "守护线程了解吗？",
+ "answer": "了解，守护线程是一种特殊的线程，它的作用是为其他线程提供服务。\n\nJava 中的线程分为两类，一种是守护线程，另外一种是用户线程。\n\nJVM 启动时会调用 main 方法，main 方法所在的线程就是一个用户线程。在 JVM 内部，同时还启动了很多守护线程，比如垃圾回收线程。\n\n#### [守护线程和用户线程有什么区别呢？](#守护线程和用户线程有什么区别呢)\n\n区别之一是当最后一个非守护线程束时， JVM 会正常退出，不管当前是否存在守护线程，也就是说守护线程是否结束并不影响 JVM 退出。\n\n换而言之，只要有一个用户线程还没结束，正常情况下 JVM 就不会退出。"
+ },
+ {
+ "id": 95,
+ "question": "线程间有哪些通信方式？",
+ "answer": "线程之间传递信息的方式有多种，比如说使用 volatile 和 synchronized 关键字共享对象、使用 `wait()` 和 `notify()` 方法实现生产者-消费者模式、使用 Exchanger 进行数据交换、使用 Condition 实现线程间的协调等。\n\n#### [简单说说 volatile 和 synchronized 的使用方式？](#简单说说-volatile-和-synchronized-的使用方式)\n\n多个线程可以通过 volatile 和 synchronized 关键字访问和修改同一个对象，从而实现信息的传递。\n\n可以用来修饰成员变量，告知程序任何对该变量的访问均需要从共享内存中获取，并同步刷新回共享内存，保证所有线程对变量访问的可见性。\n\n可以修饰方法，或者同步代码块，确保多个线程在同一个时刻只有一个线程在执行方法或代码块。\n\n\n```java\nclass SharedObject {\n private String message;\n private boolean hasMessage = false;\n\n public synchronized void writeMessage(String message) {\n while (hasMessage) {\n try {\n wait();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n this.message = message;\n hasMessage = true;\n notifyAll();\n }\n\n public synchronized String readMessage() {\n while (!hasMessage) {\n try {\n wait();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n hasMessage = false;\n notifyAll();\n return message;\n }\n}\n\npublic class Main {\n public static void main(String[] args) {\n SharedObject sharedObject = new SharedObject();\n\n Thread writer = new Thread(() -> {\n sharedObject.writeMessage(\"Hello from Writer!\");\n });\n\n Thread reader = new Thread(() -> {\n String message = sharedObject.readMessage();\n System.out.println(\"Reader received: \" + message);\n });\n\n writer.start();\n reader.start();\n }\n}\n```\n\n\n#### [wait() 和 notify() 方法的使用方式了解吗？](#wait-和-notify-方法的使用方式了解吗)\n\n一个线程调用共享对象的 `wait()` 方法时，它会进入该对象的等待池，释放已经持有的锁，进入等待状态。\n\n一个线程调用 `notify()` 方法时，它会唤醒在该对象等待池中等待的一个线程，使其进入锁池，等待获取锁。\n\n\n```java\nclass MessageBox {\n private String message;\n private boolean empty = true;\n\n public synchronized void produce(String message) {\n while (!empty) {\n try {\n wait();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n empty = false;\n this.message = message;\n notifyAll();\n }\n\n public synchronized String consume() {\n while (empty) {\n try {\n wait();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n empty = true;\n notifyAll();\n return message;\n }\n}\n\npublic class Main {\n public static void main(String[] args) {\n MessageBox box = new MessageBox();\n\n Thread producer = new Thread(() -> {\n box.produce(\"Message from producer\");\n });\n\n Thread consumer = new Thread(() -> {\n String message = box.consume();\n System.out.println(\"Consumer received: \" + message);\n });\n\n producer.start();\n consumer.start();\n }\n}\n```\n\n\n也提供了类似的方法，`await()` 负责阻塞、`signal()` 和 `signalAll()` 负责通知。\n\n通常与锁 一起使用，为线程提供了一种等待某个条件成真的机制，并允许其他线程在该条件变化时通知等待线程。\n\n#### [Exchanger 的使用方式了解吗？](#exchanger-的使用方式了解吗)\n\nExchanger 是一个同步点，可以在两个线程之间交换数据。一个线程调用 `exchange()` 方法，将数据传递给另一个线程，同时接收另一个线程的数据。\n\n\n```java\nclass Main {\n public static void main(String[] args) {\n Exchanger exchanger = new Exchanger<>();\n\n Thread thread1 = new Thread(() -> {\n try {\n String message = \"Message from thread1\";\n String response = exchanger.exchange(message);\n System.out.println(\"Thread1 received: \" + response);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n });\n\n Thread thread2 = new Thread(() -> {\n try {\n String message = \"Message from thread2\";\n String response = exchanger.exchange(message);\n System.out.println(\"Thread2 received: \" + response);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n });\n\n thread1.start();\n thread2.start();\n }\n}\n```\n\n\n#### [CompletableFuture 的使用方式了解吗？](#completablefuture-的使用方式了解吗)\n\nCompletableFuture 是 Java 8 引入的一个类，支持异步编程，允许线程在完成计算后将结果传递给其他线程。\n\n\n```java\nclass Main {\n public static void main(String[] args) {\n CompletableFuture future = CompletableFuture.supplyAsync(() -> {\n // 模拟长时间计算\n return \"Message from CompletableFuture\";\n });\n\n future.thenAccept(message -> {\n System.out.println(\"Received: \" + message);\n });\n }\n}\n```"
+ },
+ {
+ "id": 96,
+ "question": "请说说 sleep 和 wait 的区别？（补充）",
+ "answer": "> 2024 年 03 月 21 日增补\n\nsleep 会让当前线程休眠，不需要获取对象锁，属于 Thread 类的方法；wait 会让获得对象锁的线程等待，要提前获得对象锁，属于 Object 类的方法。\n\n详细解释下。\n\n①、所属类不同\n\n* `sleep()` 方法专属于 `Thread` 类。\n* `wait()` 方法专属于 `Object` 类。\n\n②、锁行为不同\n\n如果一个线程在持有某个对象锁时调用了 sleep 方法，它在睡眠期间仍然会持有这个锁。\n\n\n```java\nclass SleepDoesNotReleaseLock {\n\n private static final Object lock = new Object();\n\n public static void main(String[] args) throws InterruptedException {\n Thread sleepingThread = new Thread(() -> {\n synchronized (lock) {\n System.out.println(\"Thread 1 会继续持有锁，并且进入睡眠状态\");\n try {\n Thread.sleep(5000);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.println(\"Thread 1 醒来了，并且释放了锁\");\n }\n });\n\n Thread waitingThread = new Thread(() -> {\n synchronized (lock) {\n System.out.println(\"Thread 2 进入同步代码块\");\n }\n });\n\n sleepingThread.start();\n Thread.sleep(1000);\n waitingThread.start();\n }\n}\n```\n\n\n输出结果：\n\n\n```text\nThread 1 会继续持有锁，并且进入睡眠状态\nThread 1 醒来了，并且释放了锁\nThread 2 进入同步代码块\n```\n\n\n从输出中我们可以看到，waitingThread 必须等待 sleepingThread 完成睡眠后才能进入同步代码块。\n\n而当线程执行 wait 方法时，它会释放持有的对象锁，因此其他线程也有机会获取该对象的锁。\n\n\n```java\nclass WaitReleasesLock {\n\n private static final Object lock = new Object();\n\n public static void main(String[] args) throws InterruptedException {\n Thread waitingThread = new Thread(() -> {\n synchronized (lock) {\n try {\n System.out.println(\"Thread 1 持有锁，准备等待 5 秒\");\n lock.wait(5000);\n System.out.println(\"Thread 1 醒来了，并且退出同步代码块\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n });\n\n Thread notifyingThread = new Thread(() -> {\n synchronized (lock) {\n System.out.println(\"Thread 2 尝试唤醒等待中的线程\");\n lock.notify();\n System.out.println(\"Thread 2 执行完了 notify\");\n }\n });\n\n waitingThread.start();\n Thread.sleep(1000);\n notifyingThread.start();\n }\n}\n```\n\n\n输出结果：\n\n\n```text\nThread 1 持有锁，准备等待 5 秒\nThread 2 尝试唤醒等待中的线程\nThread 2 执行完了 notify\nThread 1 醒来了，并且退出同步代码块\n```\n\n\n这表明 waitingThread 在调用 wait 后确实释放了锁。\n\n③、使用条件不同\n\n* `sleep()` 方法可以在任何地方被调用。\n* `wait()` 方法必须在同步代码块或同步方法中被调用，这是因为调用 `wait()` 方法的前提是当前线程必须持有对象的锁。否则会抛出 `IllegalMonitorStateException` 异常。\n\n\n\n④、唤醒方式不同\n\n* 调用 sleep 方法后，线程会进入 TIMED\\_WAITING 状态，即在指定的时间内暂停执行。当指定的时间结束后，线程会自动恢复到 RUNNABLE 状态，等待 CPU 调度再次执行。\n* 调用 wait 方法后，线程会进入 WAITING 状态，直到有其他线程在同一对象上调用 notify 或 notifyAll 方法，线程才会从 WAITING 状态转变为 RUNNABLE 状态，准备再次获得 CPU 的执行权。\n\n我们来通过代码再感受一下 `sleep()` 和 `wait()` 在用法上的区别，先看 `sleep()` 的用法：\n\n\n```java\nclass SleepExample {\n public static void main(String[] args) {\n Thread thread = new Thread(() -> {\n System.out.println(\"线程准备休眠 2 秒\");\n try {\n Thread.sleep(2000); // 线程将睡眠2秒\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.println(\"线程醒来了\");\n });\n\n thread.start();\n }\n}\n```\n\n\n再来看 `wait()` 的用法：\n\n\n```java\nclass WaitExample {\n public static void main(String[] args) {\n final Object lock = new Object();\n\n Thread thread = new Thread(() -> {\n synchronized (lock) {\n try {\n System.out.println(\"线程准备等待 2 秒\");\n lock.wait(2000); // 线程会等待2秒，或者直到其他线程调用 lock.notify()/notifyAll()\n System.out.println(\"线程结束等待\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n });\n\n thread.start();\n }\n}\n```"
+ },
+ {
+ "id": 97,
+ "question": "怎么保证线程安全？（补充）",
+ "answer": "> 2024 年 05 月 01 日增补\n\n线程安全是指在并发环境下，多个线程访问共享资源时，程序能够正确地执行，而不会出现数据不一致的问题。\n\n为了保证线程安全，可以使用 对方法加锁，对代码块加锁。线程在执行同步方法、同步代码块时，会获取类锁或者对象锁，其他线程就会阻塞并等待锁。\n\n如果需要更细粒度的锁，可以使用 等。\n\n如果需要保证变量的内存可见性，可以使用 。\n\n对于简单的原子变量操作，还可以使用 。\n\n对于线程独立的数据，可以使用 来为每个线程提供专属的变量副本。\n\n对于需要并发容器的地方，可以使用 、 等。\n\n#### [有个int的变量为0，十个线程轮流对其进行++操作（循环10000次），结果大于10 万还是小于等于10万，为什么？](#有个int的变量为0-十个线程轮流对其进行-操作-循环10000次-结果大于10-万还是小于等于10万-为什么)\n\n在这个场景中，最终的结果会小于 100000，原因是多线程环境下，++ 操作并不是一个原子操作，而是分为读取、加 1、写回三个步骤。\n\n1. 读取变量的值。\n2. 将读取到的值加 1。\n3. 将结果写回变量。\n\n这样的话，就会有多个线程读取到相同的值，然后对这个值进行加 1 操作，最终导致结果小于 100000。\n\n详细解释下。\n\n多个线程在并发执行 ++ 操作时，可能出现以下竞态条件：\n\n* 线程 1 读取变量值为 0。\n* 线程 2 也读取变量值为 0。\n* 线程 1 进行加法运算并将结果 1 写回变量。\n* 线程 2 进行加法运算并将结果 1 写回变量，覆盖了线程 1 的结果。\n\n可以通过 synchronized 关键字为 ++ 操作加锁。\n\n\n```java\nclass Main {\n private static int count = 0;\n\n public static void main(String[] args) throws InterruptedException {\n Runnable task = () -> {\n for (int i = 0; i < 10000; i++) {\n synchronized (Main.class) {\n count++;\n }\n }\n };\n\n List threads = new ArrayList<>();\n for (int i = 0; i < 10; i++) {\n Thread thread = new Thread(task);\n threads.add(thread);\n thread.start();\n }\n\n for (Thread thread : threads) {\n thread.join();\n }\n\n System.out.println(\"Final count: \" + count);\n }\n}\n```\n\n\n或者使用 AtomicInteger 的 `incrementAndGet()` 方法来替代 ++ 操作，保证变量的原子性。\n\n\n```java\nclass Main {\n private static AtomicInteger count = new AtomicInteger(0);\n\n public static void main(String[] args) throws InterruptedException {\n Runnable task = () -> {\n for (int i = 0; i < 10000; i++) {\n count.incrementAndGet();\n }\n };\n\n List threads = new ArrayList<>();\n for (int i = 0; i < 10; i++) {\n Thread thread = new Thread(task);\n threads.add(thread);\n thread.start();\n }\n\n for (Thread thread : threads) {\n thread.join();\n }\n\n System.out.println(\"Final count: \" + count.get());\n }\n}\n```\n\n\n#### [场景:有一个 key 对应的 value 是一个json 结构，json 当中有好几个子任务，这些子任务如果对 key 进行修改的话，会不会存在线程安全的问题？](#场景-有一个-key-对应的-value-是一个json-结构-json-当中有好几个子任务-这些子任务如果对-key-进行修改的话-会不会存在线程安全的问题)\n\n会。\n\n在单节点环境中，可以使用 synchronized 关键字或 ReentrantLock 来保证对 key 的修改操作是原子的。\n\n\n```java\nclass KeyManager {\n private final ReentrantLock lock = new ReentrantLock();\n\n private String key = \"{\\\"tasks\\\": [\\\"task1\\\", \\\"task2\\\"]}\";\n\n public String readKey() {\n lock.lock();\n try {\n return key;\n } finally {\n lock.unlock();\n }\n }\n\n public void updateKey(String newKey) {\n lock.lock();\n try {\n this.key = newKey;\n } finally {\n lock.unlock();\n }\n }\n}\n```\n\n\n在多节点环境中，可以使用分布式锁 Redisson 来保证对 key 的修改操作是原子的。\n\n\n```java\nclass DistributedKeyManager {\n private final RedissonClient redisson;\n\n public DistributedKeyManager() {\n Config config = new Config();\n config.useSingleServer().setAddress(\"redis://127.0.0.1:6379\");\n this.redisson = Redisson.create(config);\n }\n\n public void updateKey(String key, String newValue) {\n RLock lock = redisson.getLock(key);\n lock.lock();\n try {\n // 模拟读取和更新操作\n String currentValue = readFromDatabase(key); // 假设读取 JSON 数据\n String updatedValue = modifyJson(currentValue, newValue); // 修改 JSON\n writeToDatabase(key, updatedValue); // 写回数据库\n } finally {\n lock.unlock();\n }\n }\n\n private String readFromDatabase(String key) {\n // 模拟从数据库读取\n return \"{\\\"tasks\\\": [\\\"task1\\\", \\\"task2\\\"]}\";\n }\n\n private String modifyJson(String json, String newValue) {\n // 使用 JSON 库解析并修改\n return json.replace(\"task1\", newValue);\n }\n\n private void writeToDatabase(String key, String value) {\n // 模拟写回数据库\n }\n}\n```\n\n\n#### [说一个线程安全的使用场景？](#说一个线程安全的使用场景)\n\n单例模式。在多线程环境下，如果多个线程同时尝试创建实例，单例类必须确保只创建一个实例，并提供一个全局访问点。\n\n饿汉式是一种比较直接的实现方式，它通过在类加载时就立即初始化单例对象来保证线程安全。\n\n\n```java\nclass Singleton {\n private static final Singleton instance = new Singleton();\n\n private Singleton() {\n }\n\n public static Singleton getInstance() {\n return instance;\n }\n}\n```\n\n\n懒汉式单例则在第一次使用时初始化单例对象，这种方式需要使用双重检查锁定来确保线程安全，volatile 关键字用来保证可见性，syncronized 关键字用来保证同步。\n\n\n```java\nclass LazySingleton {\n private static volatile LazySingleton instance;\n\n private LazySingleton() {}\n\n public static LazySingleton getInstance() {\n if (instance == null) { // 第一次检查\n synchronized (LazySingleton.class) {\n if (instance == null) { // 第二次检查\n instance = new LazySingleton();\n }\n }\n }\n return instance;\n }\n}\n```\n\n\n#### [能说一下 Hashtable 的底层数据结构吗？](#能说一下-hashtable-的底层数据结构吗)\n\n与 HashMap 类似，Hashtable 的底层数据结构也是一个数组加上链表的方式，然后通过 synchronized 加锁来保证线程安全。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 20,
+ "categoryName": "ThreadLocal",
+ "questions": [
+ {
+ "id": 98,
+ "question": "ThreadLocal 是什么？",
+ "answer": "是一种用于实现线程局部变量的工具类。它允许每个线程都拥有自己的独立副本，从而实现线程隔离。\n\n\n\n使用 ThreadLocal 通常分为四步：\n\n①、创建 ThreadLocal\n\n\n```java\n//创建一个ThreadLocal变量\npublic static ThreadLocal localVariable = new ThreadLocal<>();\n```\n\n\n②、设置 ThreadLocal 的值\n\n\n```java\n//设置ThreadLocal变量的值\nlocalVariable.set(\"练习伴侣二是沙雕\");\n```\n\n\n③、获取 ThreadLocal 的值\n\n\n```java\n//获取ThreadLocal变量的值\nString value = localVariable.get();\n```\n\n\n④、删除 ThreadLocal 的值\n\n\n```java\n//删除ThreadLocal变量的值\nlocalVariable.remove();\n```\n\n\n在 Web 应用中，可以使用 ThreadLocal 存储用户会话信息，这样每个线程在处理用户请求时都能方便地访问当前用户的会话信息。\n\n在数据库操作中，可以使用 ThreadLocal 存储数据库连接对象，每个线程有自己独立的数据库连接，从而避免了多线程竞争同一数据库连接的问题。\n\n在格式化操作中，例如日期格式化，可以使用 ThreadLocal 存储 SimpleDateFormat 实例，避免多线程共享同一实例导致的线程安全问题。\n\n#### [ThreadLocal 有哪些优点？](#threadlocal-有哪些优点)\n\n每个线程访问的变量副本都是独立的，避免了共享变量引起的线程安全问题。由于 ThreadLocal 实现了变量的线程独占，使得变量不需要同步处理，因此能够避免资源竞争。\n\nThreadLocal 可用于跨方法、跨类时传递上下文数据，不需要在方法间传递参数。"
+ },
+ {
+ "id": 99,
+ "question": "你在工作中用到过 ThreadLocal 吗？",
+ "answer": "有用到过，用来存储用户信息。\n\n是典型的 MVC 架构，登录后的用户每次访问接口，都会在请求头中携带一个 token，在控制层可以根据这个 token，解析出用户的基本信息。\n\n假如在服务层和持久层也要用到用户信息，就可以在控制层拦截请求把用户信息存入 ThreadLocal。\n\n这样我们在任何一个地方，都可以取出 ThreadLocal 中存的用户信息。\n\n很多其它场景的 cookie、session 等等数据隔离都可以通过 ThreadLocal 去实现。\n\n"
+ },
+ {
+ "id": 100,
+ "question": "ThreadLocal 怎么实现的呢？",
+ "answer": "当我们创建一个 ThreadLocal 对象并调用 set 方法时，其实是在当前线程中初始化了一个 ThreadLocalMap。\n\n\n\nThreadLocalMap 是 ThreadLocal 的一个静态内部类，它内部维护了一个 Entry 数组，key 是 ThreadLocal 对象，value 是线程的局部变量，这样就相当于为每个线程维护了一个变量副本。\n\n\n\nEntry 继承了 WeakReference，它限定了 key 是一个弱引用，弱引用的好处是当内存不足时，JVM 会回收 ThreadLocal 对象，并且将其对应的 Entry.value 设置为 null，这样可以在很大程度上避免内存泄漏。\n\n\n```java\nstatic class Entry extends WeakReference> {\n /** The value associated with this ThreadLocal. */\n Object value;\n\n //节点类\n Entry(ThreadLocal k, Object v) {\n //key赋值\n super(k);\n //value赋值\n value = v;\n }\n}\n```\n\n\n总结一下：\n\nThreadLocal 的实现原理是，每个线程维护一个 Map，key 为 ThreadLocal 对象，value 为想要实现线程隔离的对象。\n\n1、通过 ThreadLocal 的 set 方法将对象存入 Map 中。\n\n2、通过 ThreadLocal 的 get 方法从 Map 中取出对象。\n\n3、Map 的大小由 ThreadLocal 对象的多少决定。\n\n\n\n#### [什么是弱引用，什么是强引用？](#什么是弱引用-什么是强引用)\n\n我先说一下强引用，比如 `User user = new User(\"练习伴侣二\")` 中，user 就是一个强引用，`new User(\"练习伴侣二\")` 就是强引用对象。\n\n当 user 被置为 null 时（`user = null`），`new User(\"练习伴侣二\")` 对象就会被垃圾回收；否则即便是内存空间不足，JVM 也不会回收 `new User(\"练习伴侣二\")` 这个强引用对象，宁愿抛出 OutOfMemoryError。\n\n弱引用，比如说在使用 ThreadLocal 中，Entry 的 key 就是一个弱引用对象。\n\n\n```java\nThreadLocal userThreadLocal = new ThreadLocal<>();\nuserThreadLocal.set(new User(\"练习伴侣二\"));\n```\n\n\nuserThreadLocal 是一个强引用，`new ThreadLocal<>()` 是一个强引用对象；\n\n`new User(\"练习伴侣二\")` 是一个强引用对象。\n\n调用 set 方法后，会将 `key = new ThreadLocal<>()` 放入 ThreadLocalMap 中，此时的 key 是一个弱引用对象。当 JVM 进行垃圾回收时，如果发现了弱引用对象，就会将其回收。\n\n\n\n其关系链就是：\n\n* ThreadLocal 强引用 -> ThreadLocal 对象。\n* Thread 强引用 -> ThreadLocalMap。\n* `ThreadLocalMap[i]` 强引用了 -> Entry。\n* Entry.key 弱引用 -> ThreadLocal 对象。\n* Entry.value 强引用 -> 线程的局部变量对象。"
+ },
+ {
+ "id": 101,
+ "question": "ThreadLocal 内存泄露是怎么回事？",
+ "answer": "ThreadLocalMap 的 Key 是 弱引用，但 Value 是强引用。\n\n如果一个线程一直在运行，并且 value 一直指向某个强引用对象，那么这个对象就不会被回收，从而导致内存泄漏。\n\n\n\n#### [那怎么解决内存泄漏问题呢？](#那怎么解决内存泄漏问题呢)\n\n很简单，使用完 ThreadLocal 后，及时调用 `remove()` 方法释放内存空间。\n\n\n```java\ntry {\n threadLocal.set(value);\n // 执行业务操作\n} finally {\n threadLocal.remove(); // 确保能够执行清理\n}\n```\n\n\n`remove()` 方法会将当前线程的 ThreadLocalMap 中的所有 key 为 null 的 Entry 全部清除，这样就能避免内存泄漏问题。\n\n\n```java\nprivate void remove(ThreadLocal key) {\n Entry[] tab = table;\n int len = tab.length;\n // 计算 key 的 hash 值\n int i = key.threadLocalHashCode & (len-1);\n // 遍历数组，找到 key 为 null 的 Entry\n for (Entry e = tab[i];\n e != null;\n e = tab[i = nextIndex(i, len)]) {\n if (e.get() == key) {\n // 将 key 为 null 的 Entry 清除\n e.clear();\n expungeStaleEntry(i);\n return;\n }\n }\n}\n\npublic void clear() {\n this.referent = null;\n}\n```\n\n\n#### [那为什么 key 要设计成弱引用？](#那为什么-key-要设计成弱引用)\n\n弱引用的好处是，当内存不足的时候，JVM 能够及时回收掉弱引用的对象。\n\n比如说：\n\n\n```java\nWeakReference key = new WeakReference(new ThreadLocal());\n```\n\n\nkey 是弱引用，`new WeakReference(new ThreadLocal())` 是弱引用对象，当 JVM 进行垃圾回收时，只要发现了弱引用对象，就会将其回收。\n\n一旦 key 被回收，ThreadLocalMap 在进行 set、get 的时候就会对 key 为 null 的 Entry 进行清理。\n\n\n\n总结一下，在 ThreadLocal 被垃圾收集后，下一次访问 ThreadLocalMap 时，Java 会自动清理那些键为 null 的 entry，这个过程会在执行 `get()`、`set()`、`remove()`时触发。\n\n\n\n#### [你了解哪些 ThreadLocal 的改进方案？](#你了解哪些-threadlocal-的改进方案)\n\n在 JDK 20 Early-Access Build 28 版本中，出现了 ThreadLocal 的改进方案，即 `ScopedValue`。\n\n还有 Netty 中的 FastThreadLocal，它是 Netty 对 ThreadLocal 的优化，内部维护了一个索引常量 index，每次创建 FastThreadLocal 中都会自动+1，用来取代 hash 冲突带来的损耗，用空间换时间。\n\n\n```java\nprivate final int index;\n\npublic FastThreadLocal() {\n index = InternalThreadLocalMap.nextVariableIndex();\n}\npublic static int nextVariableIndex() {\n int index = nextIndex.getAndIncrement();\n if (index < 0) {\n nextIndex.decrementAndGet();\n }\n return index;\n}\n```\n\n\n以及阿里的 TransmittableThreadLocal，不仅实现了子线程可以继承父线程 ThreadLocal 的功能，并且还可以跨线程池传递值。\n\n\n```java\nTransmittableThreadLocal context = new TransmittableThreadLocal<>();\n\n// 在父线程中设置\ncontext.set(\"value-set-in-parent\");\n\n// 在子线程中可以读取，值是\"value-set-in-parent\"\nString value = context.get();\n```"
+ },
+ {
+ "id": 102,
+ "question": "ThreadLocalMap 的源码看过吗？",
+ "answer": "有研究过。\n\nThreadLocalMap 虽然被叫做 Map，但它并没有实现 Map 接口，是一个简单的线性探测哈希表。\n\n\n```java\nstatic class ThreadLocalMap {\n static class Entry extends WeakReference> {\n Object value;\n\n Entry(ThreadLocal k, Object v) {\n super(k); // 这里的 Key 是 WeakReference\n value = v;\n }\n }\n\n private Entry[] table; // 存储 ThreadLocal 变量的数组\n private int size; // 当前 Entry 数量\n private int threshold; // 触发扩容的阈值\n}\n```\n\n\n底层的数据结构也是数组，数组中的每个元素是一个 Entry 对象，Entry 对象继承了 WeakReference，key 是 ThreadLocal 对象，value 是线程的局部变量。\n\n\n\n当调用 `ThreadLocal.set(value)` 时，会将 value 存入 ThreadLocalMap。\n\n\n```java\npublic void set(T value) {\n Thread t = Thread.currentThread();\n ThreadLocalMap map = getMap(t);\n if (map != null) {\n map.set(this, value);\n } else {\n createMap(t, value);\n }\n}\n```\n\n\n`set()` 方法是 ThreadLocalMap 的核心方法，通过 key 的哈希码与数组长度取模，计算出 key 在数组中的位置，这一点和 HashMap 的实现类似。\n\n\n```java\nprivate void set(ThreadLocal key, Object value) {\n Entry[] tab = table;\n int len = tab.length;\n int i = key.threadLocalHashCode & (len - 1); // 计算索引\n\n for (Entry e = tab[i]; e != null; e = tab[nextIndex(i, len)]) {\n ThreadLocal k = e.get();\n if (k == key) { // 如果 key 已存在，更新 value\n e.value = value;\n return;\n }\n if (k == null) { // Key 为 null，清理无效 Entry\n replaceStaleEntry(key, value, i);\n return;\n }\n }\n \n tab[i] = new Entry(key, value); // 直接插入 Entry\n size++;\n if (size >= threshold) {\n rehash();\n }\n}\n```\n\n\nthreadLocalHashCode 的计算有点东西，每创建一个 ThreadLocal 对象，它就会新增一个**黄金分割数**，可以让哈希码**分布的非常均匀**。\n\n\n```java\nprivate static final int HASH_INCREMENT = 0x61c88647;\n\nprivate static int nextHashCode() {\n return nextHashCode.getAndAdd(HASH_INCREMENT);\n}\n```\n\n\n当调用 `ThreadLocal.get()` 时，会调用 ThreadLocalMap 的 `getEntry()` 方法，根据 key 的哈希码找到对应的线程局部变量。\n\n\n```java\nprivate Entry getEntry(ThreadLocal key) {\n int i = key.threadLocalHashCode & (table.length - 1);\n Entry e = table[i];\n\n if (e != null && e.get() == key) { // 如果 key 存在，直接返回\n return e;\n } else {\n return getEntryAfterMiss(key, i, e); // 继续查找\n }\n}\n```\n\n\n当调用 `ThreadLocal.remove()` 时，会调用 ThreadLocalMap 的 `remove()` 方法，根据 key 的哈希码找到对应的线程局部变量，将其清除，防止内存泄漏。\n\n\n```java\nprivate void remove(ThreadLocal key) {\n Entry[] tab = table;\n int len = tab.length;\n int i = key.threadLocalHashCode & (len - 1);\n \n for (Entry e = tab[i]; e != null; e = tab[nextIndex(i, len)]) {\n if (e.get() == key) {\n e.clear(); // 清除 WeakReference\n e.value = null; // 释放 Value\n expungeStaleEntries();\n return;\n }\n }\n}\n```"
+ },
+ {
+ "id": 103,
+ "question": "ThreadLocalMap 怎么解决 Hash 冲突的？",
+ "answer": "**开放定址法**。\n\n如果计算得到的槽位 i 已经被占用，ThreadLocalMap 会采用开放地址法中的线性探测来寻找下一个空闲槽位：\n\n如果 i 位置被占用，尝试 i+1。\n\n如果 i+1 也被占用，继续探测 i+2，直到找到一个空位。\n\n如果到达数组末尾，则回到数组头部，继续寻找空位。\n\n\n```java\nprivate static int nextIndex(int i, int len) {\n return ((i + 1 < len) ? i + 1 : 0);\n}\n```\n\n\n#### [为什么要用线性探测法而不是HashMap 的拉链法来解决哈希冲突？](#为什么要用线性探测法而不是hashmap-的拉链法来解决哈希冲突)\n\nThreadLocalMap 设计的目的是存储线程私有数据，不会有大量的 Key，所以采用线性探测更节省空间。\n\n拉链法还需要单独维护一个链表，甚至红黑树，不适合 ThreadLocal 这种场景。\n\n#### [开放地址法了解吗？](#开放地址法了解吗)\n\n简单来说，就是这个坑被人占了，那就接着去找空着的坑。\n\n\n\n如果我们插入一个 value=27 的数据，通过 hash 计算后应该落入第 4 个槽位，而槽位 4 已经有数据了，而且 key 和当前的不等。\n\n此时就会线性向后查找，一直找到 Entry 为 null 的槽位才会停止。"
+ },
+ {
+ "id": 104,
+ "question": "ThreadLocalMap 扩容机制了解吗？",
+ "answer": "了解。\n\n与 HashMap 不同，ThreadLocalMap 并不会直接在元素数量达到阈值时立即扩容，而是先清理被 GC 回收的 key，然后在填充率达到四分之三时进行扩容。\n\n\n```java\nprivate void rehash() {\n // 清理被 GC 回收的 key\n expungeStaleEntries();\n\n //扩容\n if (size >= threshold - threshold / 4)\n resize();\n}\n```\n\n\n清理过程会遍历整个数组，将 key 为 null 的 Entry 清除。\n\n\n```java\nprivate void expungeStaleEntries() {\n Entry[] tab = table;\n int len = tab.length;\n for (int j = 0; j < len; j++) {\n Entry e = tab[j];\n // 如果 key 为 null，清理 Entry\n if (e != null && e.get() == null)\n expungeStaleEntry(j);\n }\n}\n```\n\n\n阈值 threshold 的默认值是数组长度的三分之二。\n\n\n```java\nprivate void setThreshold(int len) {\n threshold = len * 2 / 3;\n}\n```\n\n\n扩容时，会将数组长度翻倍，然后重新计算每个 Entry 的位置，采用线性探测法来寻找新的空位，然后将 Entry 放入新的数组中。\n\n\n```java\nprivate void resize() {\n Entry[] oldTab = table;\n int oldLen = oldTab.length;\n // 扩容为原来的两倍\n int newLen = oldLen * 2;\n Entry[] newTab = new Entry[newLen];\n \n int count = 0;\n // 遍历老数组\n for (int j = 0; j < oldLen; ++j) {\n Entry e = oldTab[j];\n if (e != null) {\n ThreadLocal k = e.get();\n if (k == null) {\n e.value = null; // 释放 Value，防止内存泄漏\n } else {\n // 重新计算位置\n int h = k.threadLocalHashCode & (newLen - 1);\n while (newTab[h] != null) {\n // 线性探测寻找新位置\n h = nextIndex(h, newLen);\n }\n // 放入新数组\n newTab[h] = e;\n count++;\n }\n }\n }\n table = newTab;\n size = count;\n threshold = newLen * 2 / 3; // 重新计算扩容阈值\n}\n```\n\n\n一句话总结：ThreadLocalMap 采用的是“先清理再扩容”的策略，扩容时，数组长度翻倍，并重新计算索引，如果发生哈希冲突，采用线性探测法来解决。\n\n"
+ },
+ {
+ "id": 105,
+ "question": "父线程能用 ThreadLocal 给子线程传值吗？",
+ "answer": "不能。\n\n\n\n因为 ThreadLocal 变量存储在每个线程的 ThreadLocalMap 中，而子线程不会继承父线程的 ThreadLocalMap。\n\n可以使用 `InheritableThreadLocal`来解决这个问题。\n\n\n\n子线程在创建的时候会拷贝父线程的 InheritableThreadLocal 变量。\n\n\n\n来看一下使用示例：\n\n\n```java\nclass InheritableThreadLocalExample {\n private static final InheritableThreadLocal inheritableThreadLocal = new InheritableThreadLocal<>();\n\n public static void main(String[] args) {\n inheritableThreadLocal.set(\"父线程的值\");\n\n new Thread(() -> {\n System.out.println(\"子线程获取的值：\" + inheritableThreadLocal.get()); // 继承了父线程的值\n }).start();\n }\n}\n```\n\n\n#### [InheritableThreadLocal的原理了解吗？](#inheritablethreadlocal的原理了解吗)\n\n了解。\n\n在 Thread 类的定义中，每个线程都有两个 ThreadLocalMap：\n\n\n```java\npublic class Thread {\n /* 普通 ThreadLocal 变量存储的地方 */\n ThreadLocal.ThreadLocalMap threadLocals = null;\n\n /* InheritableThreadLocal 变量存储的地方 */\n ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;\n}\n```\n\n\n普通 ThreadLocal 变量存储在 threadLocals 中，不会被子线程继承。\n\nInheritableThreadLocal 变量存储在 inheritableThreadLocals 中，当 `new Thread()` 创建一个子线程时，Thread 的 `init()` 方法会检查父线程是否有 inheritableThreadLocals，如果有，就会拷贝 InheritableThreadLocal 变量到子线程：\n\n\n```java\nprivate void init(ThreadGroup g, Runnable target, String name, long stackSize) {\n // 获取当前父线程\n Thread parent = currentThread();\n // 复制 InheritableThreadLocal 变量\n if (parent.inheritableThreadLocals != null) {\n this.inheritableThreadLocals = \n ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);\n }\n}\n```"
+ }
+ ]
+ },
+ {
+ "id": 21,
+ "categoryName": "Java 内存模型",
+ "questions": [
+ {
+ "id": 106,
+ "question": "说一下你对 Java 内存模型的理解？",
+ "answer": "Java 内存模型是 Java 虚拟机规范中定义的一个抽象模型，用来描述多线程环境中共享变量的内存可见性。\n\n\n\n共享变量存储在`主内存`中，每个线程都有一个私有的`本地内存`，存储了共享变量的副本。\n\n* 当一个线程更改了本地内存中共享变量的副本，它需要 JVM 刷新到主内存中，以确保其他线程可以看到这些更改。\n* 当一个线程需要读取共享变量时，它一版会从本地内存中读取。如果本地内存中的副本是过时的，JVM 会将主内存中的共享变量最新值刷新到本地内存中。\n\n\n\n#### [为什么线程要用自己的内存？](#为什么线程要用自己的内存)\n\n线程从主内存拷贝变量到工作内存，可以减少 CPU 访问 RAM 的开销。\n\n每个线程都有自己的变量副本，可以避免多个线程同时修改共享变量导致的数据冲突。"
+ },
+ {
+ "id": 107,
+ "question": "i++是原子操作吗？",
+ "answer": "不是，它包括三个步骤：\n\n1. 从内存中读取 i 的值。\n2. 对 i 进行加 1 操作。\n3. 将新的值写回内存。\n\n#### [说说你对原子性、可见性、有序性的理解？](#说说你对原子性、可见性、有序性的理解)\n\n**原子性**要求一个操作是不可分割的，要么全部执行成功，要么完全不执行。\n\n举个例子：就比如说 `count++` 就不是一个原子操作，它包括读取 count 的值、加 1、写回 count 三个步骤，所以需要加锁或者使用`AtomicInteger`代替 int 来保证原子性。\n\n**可见性**要求一个线程对共享变量的修改，能够被其他线程及时看见。\n\n我通过下面的代码解释一下：\n\n\n```java\nprivate static boolean flag = true;\n\npublic static void main(String[] args) {\n new Thread(() -> {\n while (flag) {} // 线程 A 可能一直看不到 flag=false\n System.out.println(\"线程 A 退出\");\n }).start();\n\n try { Thread.sleep(1000); } catch (InterruptedException e) {}\n\n flag = false; // 线程 B 修改 flag\n}\n```\n\n\n线程 A 会在本地内存中缓存 `flag=true`，虽然线程 B 修改了 `flag=false`，但不会立即同步到主内存以及线程 A 的本地内存，因此线程 A 会一直处于死循环。\n\n解决办法就是通过 volatile 关键字来保证可见性。\n\n**有序性**是指程序执行的顺序是否按照代码编写的顺序执行。\n\n在单线程环境下，代码能够准确无误地按照编写顺序执行。但在多线程环境下，CPU 和编译器可能会进行指令重排，代码的执行顺序因此会发生变化。\n\n我通过下面的代码解释一下：\n\n\n```java\nint a = 0, b = 0;\nboolean flag = false;\n\nvoid thread1() {\n a = 1; \n flag = true; // 可能会被 CPU 优化，先执行\n}\n\nvoid thread2() {\n if (flag) {\n System.out.println(a); // 可能打印 0，而不是 1\n }\n}\n```\n\n\n由于指令重排，`flag = true` 可能会在 `a = 1` 之前执行，导致 `thread2()` 读取 `flag=true` 后，a 仍然是 0，出现不符合代码逻辑的情况。\n\n简要回答：\n\n原子性保证操作不可中断，可见性保证变量修改后线程能看到最新值，有序性保证代码执行顺序一致，可以通过 volatile、synchronized 和 CAS 机制来保证这些特性。\n\n#### [下面的代码是原子操作吗？](#下面的代码是原子操作吗)\n\n\n```java\nint i = 2;\nint j = i;\ni++;\ni = i + 1;\n```\n\n\n* 第 1 行代码是基本类型赋值，是原子性操作。\n* 第 2 行先读 i 的值，再赋值给 j，不是原子操作。\n* 第 3 和第 4 行都不是原子操作，都需要先读取 i 的值，再+1，然后再赋值给 i。"
+ },
+ {
+ "id": 108,
+ "question": "说说什么是指令重排？",
+ "answer": "指令重排是指 CPU 或编译器为了提高程序的执行效率，改变代码执行顺序的一种优化技术。\n\n从 Java 源代码到最终执行的指令序列，会经历 3 种重排序：编译器重排序、指令并行重排序、内存系统重排序。\n\n\n\n指令重排可能会导致双重检查锁失效，比如下面的单例模式代码：\n\n\n```java\npublic class Singleton {\n private static Singleton instance;\n\n public static Singleton getInstance() {\n if (instance == null) { // 第一次检查\n synchronized (Singleton.class) {\n if (instance == null) { // 第二次检查\n instance = new Singleton(); // 可能发生指令重排\n }\n }\n }\n return instance;\n }\n}\n```\n\n\n如果线程 A 执行了 `instance = new Singleton();`，但构造方法还没执行完，线程 B 可能会读取到一个未初始化的对象，导致出现空指针异常。\n\n\n\n正确的方式是给 instance 变量加上 `volatile` 关键字，禁止指令重排。\n\n\n```java\nclass Singleton {\n private static volatile Singleton instance;\n\n public static Singleton getInstance() {\n if (instance == null) {\n synchronized (Singleton.class) {\n if (instance == null) {\n instance = new Singleton(); // 由于 volatile，禁止指令重排\n }\n }\n }\n return instance;\n }\n}\n```"
+ },
+ {
+ "id": 109,
+ "question": "happens-before 了解吗？",
+ "answer": "Happens-Before 是 Java 内存模型定义的一种保证线程间可见性和有序性的规则。\n\n如果操作 A Happens-Before 操作 B，那么：\n\n1. 操作 A 的结果对操作 B 可见。\n2. 操作 A 在时间上先于操作 B 执行。\n\n换句话说，如果 A Happens-Before B，那么 A 的修改必须对 B 可见，并且 B 不能重排序到 A 之前。\n\n#### [你知道哪些 Happens-Before 规则？](#你知道哪些-happens-before-规则)\n\n\n\nJMM 规定了 6 种 Happens-Before 规则，满足这些规则的操作不会被重排序，并且保证了数据的可见性。\n\n①、程序顺序规则：单线程内，代码按顺序执行；比如 `a = 1; b = 2;`，a 先于 b 执行。\n\n②、监视器锁定规则：`unlock() Happens-Before lock()`；比如 synchronized 释放锁后，获取锁的线程能够看到最新的数据。\n\n③、volatile 变量规则：写 volatile 变量 Happens-Before 读 volatile。\n\n④、传递性规则：A Happens-Before B 且 B Happens-Before C，则 A Happens-Before C。例如 a = 1 先于 b = 2，b = 2 先于 c = 3，则 a = 1 先于 c = 3。\n\n⑤、线程启动规则：线程 A 执行操作 `ThreadB.start()`，那么 A 线程的 `ThreadB.start()` 操作 happens-before 于线程 B 中的任意操作。\n\n⑥、线程终止规则：线程的所有操作 Happens-Before `Thread.join()`；例如 `t.join();` 之后，主线程一定能看到 t 的修改。"
+ },
+ {
+ "id": 110,
+ "question": "as-if-serial 了解吗？",
+ "answer": "As-If-Serial 规则允许 CPU 和编译器优化代码顺序，但不会改变单线程的执行结果。它只适用于单线程，多线程环境仍然可能发生指令重排，需要 volatile 和 synchronized 等机制来保证有序性。\n\n来解释说明一下。\n\n\n```java\ndouble pi = 3.14; // A\ndouble r = 1.0; // B\ndouble area = pi * r * r; // C\n```\n\n\nC 依赖于 A，同时 C 也依赖着 B。\n\n\n\n因此在最终执行的指令序列中，C 不能被重排序到 A 或者 B 的前面，否则就会出现错误。\n\n但 A 和 B 之间没有依赖关系，因此编译器和处理器可以重排序 A 和 B 之间的执行顺序。\n\n所以程序可能会有两种执行顺序：\n\n\n\nHappens-Before 规则保证了多线程环境下的有序性，防止指令重排导致的并发问题。As-If-Serial 规则保证了单线程代码不会因优化而执行错误。"
+ },
+ {
+ "id": 111,
+ "question": "volatile 了解吗？",
+ "answer": "了解。\n\n第一，保证可见性，线程修改 volatile 变量后，其他线程能够立即看到最新值；第二，防止指令重排，volatile 变量的写入不会被重排序到它之前的代码。\n\n#### [volatile 怎么保证可见性的？](#volatile-怎么保证可见性的)\n\n当线程对 volatile 变量进行写操作时，JVM 会在这个变量写入之后插入一个写屏障指令，这个指令会强制将本地内存中的变量值刷新到主内存中。\n\n\n```java\nStoreStore; // 保证写入之前的操作不会重排\nvolatile_write(); // 写入 volatile 变量\nStoreLoad; // 保证写入后，其他线程立即可见\n```\n\n\n在 x86 架构下，通常会使用 `lock` 指令来实现写屏障，例如：\n\n\n```text\nmov [a], 2 ; 将值 2 写入内存地址 a\nlock add [a], 0 ; lock 指令充当写屏障，确保内存可见性\n```\n\n\n当线程对 volatile 变量进行读操作时，JVM 会插入一个读屏障指令，这个指令会强制让本地内存中的变量值失效，从而重新从主内存中读取最新的值。\n\n\n\n我们来声明一个 volatile 变量 x：\n\n\n```java\nvolatile int x = 0\n```\n\n\n线程 A 对 x 写入后会将其最新的值刷新到主内存中，线程 B 读取 x 时由于本地内存中的 x 失效了，就会从主内存中读取最新的值。\n\n\n\n#### [volatile 怎么保证有序性的？](#volatile-怎么保证有序性的)\n\nJVM 会在 volatile 变量的读写前后插入 “内存屏障”，以约束 CPU 和编译器的优化行为：\n\n* StoreStore 屏障可以禁止普通写操作与 volatile 写操作的重排\n* StoreLoad 屏障会禁止 volatile 写与 volatile 读重排\n* LoadLoad 屏障会禁止 volatile 读与后续普通读操作重排\n* LoadStore 屏障会禁止 volatile 读与后续普通写操作重排\n\n#### [volatile 和 synchronized 的区别？](#volatile-和-synchronized-的区别)\n\nvolatile 关键字用于修饰变量，确保该变量的更新操作对所有线程是可见的，即一旦某个线程修改了 volatile 变量，其他线程会立即看到最新的值。\n\nsynchronized 关键字用于修饰方法或代码块，确保同一时刻只有一个线程能够执行该方法或代码块，从而实现互斥访问。\n\n#### [volatile 加在基本类型和对象上的区别？](#volatile-加在基本类型和对象上的区别)\n\n当 `volatile` 用于基本数据类型时，能确保该变量的读写操作是直接从主内存中读取或写入的。\n\n\n```java\nprivate volatile int count = 0;\n```\n\n\n当 `volatile` 用于引用类型时，能确保引用本身的可见性，即确保引用指向的对象地址是最新的。\n\n但是，`volatile` 并不能保证引用对象内部状态的线程安全。\n\n\n```java\nprivate volatile SomeObject obj = new SomeObject();\n```\n\n\n虽然 `volatile` 确保了 `obj` 引用的可见性，但对 `obj` 引用的 `new SomeObject()` 对象并不受 `volatile` 保护。\n\n如果需要保证引用对象内部状态的线程安全，需要使用 `synchronized` 或 `ReentrantLock` 等锁机制。"
+ }
+ ]
+ },
+ {
+ "id": 22,
+ "categoryName": "锁",
+ "questions": [
+ {
+ "id": 112,
+ "question": "synchronized 用过吗？",
+ "answer": "用过，频率还很高。\n\nsynchronized 在 JDK 1.6 之后，进行了锁优化，增加了偏向锁、轻量级锁，大大提升了 synchronized 的性能。\n\n#### [synchronized 上锁的对象是什么？](#synchronized-上锁的对象是什么)\n\nsynchronized 用在普通方法上时，上锁的是执行这个方法的对象。\n\n\n```java\npublic synchronized void increment() {\n this.count++;\n}\n```\n\n\nsynchronized 用在静态方法上时，上锁的是这个类的 Class 对象。\n\n\n```java\npublic static synchronized void increment() {\n count++;\n}\n```\n\n\nsynchronized 用在代码块上时，上锁的是括号中指定的对象，比如说当前对象 this。\n\n\n```java\npublic void increment() {\n synchronized (this) {\n this.count++;\n }\n}\n```"
+ },
+ {
+ "id": 113,
+ "question": "synchronized 的实现原理了解吗？",
+ "answer": "synchronized 依赖 JVM 内部的 Monitor 对象来实现线程同步。使用的时候不用手动去 lock 和 unlock，JVM 会自动加锁和解锁。\n\nsynchronized 加锁代码块时，JVM 会通过 `monitorenter`、`monitorexit` 两个指令来实现同步：\n\n* 前者表示线程正在尝试获取 lock 对象的 Monitor；\n* 后者表示线程执行完了同步代码块，正在释放锁。\n\n使用 `javap -c -s -v -l SynchronizedDemo.class` 反编译 synchronized 代码块时，就能看到这两个指令。\n\n\n\nsynchronized 修饰普通方法时，JVM 会通过 `ACC_SYNCHRONIZED` 标记符来实现同步。\n\n\n\n#### [你对 Monitor 了解多少？](#你对-monitor-了解多少)\n\nMonitor 是 JVM 内置的同步机制，每个对象在内存中都有一个对象头——Mark Word，用于存储锁的状态，以及 Monitor 对象的指针。\n\n\n\nsynchronized 依赖对象头的 Mark Word 进行状态管理，支持无锁、偏向锁、轻量级锁，以及重量级锁。\n\n在 Hotspot 虚拟机中，Monitor 由 ObjectMonitor 实现：\n\n\n```java\nObjectMonitor() {\n _count = 0; // 记录线程获取锁的次数\n _owner = NULL; // 指向持有ObjectMonitor对象的线程\n _WaitSet = NULL; // 处于wait状态的线程，会被加入到_WaitSet\n _cxq = NULL ;\n _EntryList = NULL ; // 处于等待锁block状态的线程，会被加入到该列表\n }\n```\n\n\n* \\_owner：当前持有 ObjectMonitor 的线程，初始值为 null，表示没有线程持有锁。线程成功获取锁后，该值更新为线程 ID，释放锁后重置为 null。\n* \\_count：记录当前线程获取锁的次数（可重入锁），每次成功加锁 `_count + 1`，释放锁 `_count - 1`。\n* \\_WaitSet：等待队列，调用 `wait()` 方法后，线程会释放锁，并加入 \\_WaitSet，进入 WAITING 状态，等待 `notify()` 唤醒。\n* \\_cxq：阻塞队列，用于存放刚进入 Monitor 的线程（还未进入 \\_EntryList）。\n* \\_EntryList：竞争队列，所有等待获取锁的线程（BLOCKED 状态）会进入 \\_EntryList，等待锁释放后竞争执行权。\n\n结构示意图：\n\n\n```text\n+----------------------+\n| ObjectMonitor |\n| ---------------- |\n| _owner = Thread-1 | // 当前持有锁的线程\n| _count = 1 | // 线程获取锁的次数\n| _WaitSet -> T3,T4 | // 执行 wait() 的线程\n| _EntryList -> T2,T5| // 竞争锁的线程\n| _cxq -> T6,T7 | // 新进入的线程\n+----------------------+\n```\n\n\n#### [会不会牵扯到 os 层面呢？](#会不会牵扯到-os-层面呢)\n\n会，synchronized 升级为重量级锁时，依赖于操作系统的互斥量——mutex 来实现，mutex 用于保证任何给定时间内，只有一个线程可以执行某一段特定的代码段。"
+ },
+ {
+ "id": 114,
+ "question": "synchronized 怎么保证可见性？",
+ "answer": "通过两步操作：\n\n* 加锁时，线程必须从主内存读取最新数据。\n* 释放锁时，线程必须将修改的数据刷回主内存，这样其他线程获取锁后，就能看到最新的数据。\n\n\n```text\n线程 A 线程 B\n ┌────────────────────┐\n │ synchronized(lock) │\n │ x = 1; │ // 1. 线程 A 修改变量 x\n └────────────────────┘\n ↓ 释放锁\n （JVM 强制刷新 x 到主内存）\n\n （线程 B 获取锁）\n ┌────────────────────┐\n │ synchronized(lock) │\n │ print(x); │ // 2. 线程 B 读取最新 x=1\n └────────────────────┘\n```\n\n\n#### [synchronized 怎么保证有序性？](#synchronized-怎么保证有序性)\n\nsynchronized 通过 JVM 指令 monitorenter 和 monitorexit，来确保加锁代码块内的指令不会被重排。\n\n来解释一下，比如说对于：\n\n\n```java\nsynchronized (lock) {\n x = 1;\n flag = true;\n}\n```\n\n\njavap 反编译后的伪代码：\n\n\n```java\nmonitorenter // 获取锁\nstore x, 1 // 变量 x = 1\nstore flag, true // 变量 flag = true\nmonitorexit // 释放锁\n```\n\n\n实际 javap 反编译后的结果：\n\n\n\n指令解释一下：\n\n| 指令 | 作用 |\n| --- | --- |\n| monitorenter | 获取锁，进入同步代码块 |\n| iconst\\_1 | 将整数 1 压入操作数栈 |\n| istore\\_1 | 存储 1 到局部变量 x |\n| iconst\\_1 | 再次将整数 1 压入操作数栈 |\n| istore\\_2 | 存储 1 到局部变量 flag |\n| aload 4 | 加载 lock 对象引用 |\n| monitorexit | 释放锁，退出同步代码块 |\n\n#### [synchronized 怎么实现可重入的呢？](#synchronized-怎么实现可重入的呢)\n\n可重入意味着同一个线程可以多次获得同一个锁，而不会被阻塞。\n\n\n\nsynchronized 之所以支持可重入，是因为 Java 的对象头包含了一个 Mark Word，用于存储对象的状态，包括锁信息。\n\n当一个线程获取对象锁时，JVM 会将该线程的 ID 写入 Mark Word，并将锁计数器设为 1。\n\n如果一个线程尝试再次获取已经持有的锁，JVM 会检查 Mark Word 中的线程 ID。如果 ID 匹配，表示的是同一个线程，锁计数器递增。\n\n当线程退出同步块时，锁计数器递减。如果计数器值为零，JVM 将锁标记为未持有状态，并清除线程 ID 信息。\n\n来解释一下：\n\n\n```java\nclass ReentrantExample {\n public synchronized void method1() {\n System.out.println(\"Method1 acquired lock\");\n method2(); // 线程已经持有锁，能继续调用 method2\n }\n\n public synchronized void method2() {\n System.out.println(\"Method2 acquired lock\");\n }\n\n public static void main(String[] args) {\n ReentrantExample example = new ReentrantExample();\n example.method1();\n }\n}\n```\n\n\n执行结果：\n\n\n```text\nMethod1 acquired lock\nMethod2 acquired lock\n```\n\n\n因为 synchronized 支持可重入，所以 method1 获取锁后，method2 仍然可以获取锁。\n\n底层是通过 Monitor 对象的 owner 和 count 字段实现的，owner 记录持有锁的线程，count 记录线程获取锁的次数。\n\n\n```text\n+----------------------+\n| ObjectMonitor |\n| ---------------- |\n| _owner = Thread-1 | // 当前持有锁的线程\n| _count = 2 | // 线程重入了 2 次\n+----------------------+\n```"
+ },
+ {
+ "id": 115,
+ "question": "synchronized 锁升级了解吗？",
+ "answer": "JDK 1.6 的时候，为了提升 synchronized 的性能，引入了锁升级机制，从低开销的锁逐步升级到高开销的锁，以最大程度减少锁的竞争。\n\n\n\n没有线程竞争时，就使用低开销的“偏向锁”，此时没有额外的 CAS 操作；轻度竞争时，使用“轻量级锁”，采用 CAS 自旋，避免线程阻塞；只有在重度竞争时，才使用“重量级锁”，由 Monitor 机制实现，需要线程阻塞。\n\n#### [了解 synchronized 四种锁状态吗？](#了解-synchronized-四种锁状态吗)\n\n了解。\n\n①、无锁状态，对象未被锁定，Mark Word 存储对象的哈希码等信息。\n\n②、偏向锁，当线程第一次获取锁时，会进入偏向模式。Mark Word 会记录线程 ID，后续同一线程再次获取锁时，可以直接进入 synchronized 加锁的代码，无需额外加锁。\n\n\n\n③、轻量级锁，当多个线程在不同时段获取同一把锁，即不存在锁竞争的情况时，JVM 会采用轻量级锁来避免线程阻塞。\n\n未持有锁的线程通过等待锁释放。\n\n\n\n当线程进入 synchronized 加锁的代码时，如果对象的锁状态为偏向锁，也就是锁类型为“01”，偏向锁标记为“0”的状态。\n\n\n\n然后采用 CAS 自旋的方式，尝试将对象头中的 Mark Word 替换为指向 Lock Record 的指针，并将 Lock Record 中的 owner 指针指向对象的 Mark Word。\n\n\n\n如果这个替换动作成功了，线程就拥有了该对象的锁，对象头 Mark Word 的锁标志位会更新为“00”，表示对象处于轻量级锁状态。\n\n④、重量级锁，如果自旋超过一定的次数，或者一个线程持有锁，一个自旋，又有第三个线程进入 synchronized 加锁的代码时，轻量级锁就会升级为重量级锁。\n\n此时，对象头的锁类型会更新为“10”，Mark Word 会存储指向 Monitor 对象的指针，其他等待锁的线程都会进入阻塞状态。\n\n#### [synchronized 做了哪些优化？](#synchronized-做了哪些优化)\n\n在 JDK 1.6 之前，synchronized 是直接调用 ObjectMonitor 的 enter 和 exit 指令实现的，这种锁也被称为**重量级锁**，性能较差。\n\n随着 JDK 版本的更新，synchronized 的性能得到了极大的优化：\n\n**①、偏向锁**：同一个线程可以多次获取同一把锁，无需重复加锁。\n\n**②、轻量级锁**：当没有线程竞争时，通过 CAS 自旋等待锁，避免直接进入阻塞。\n\n**③、锁消除**： 可以在运行时进行代码分析，如果发现某些锁操作不可能被多个线程同时访问，就会对这些锁进行消除，从而减少上锁开销。\n\n#### [请详细说说锁升级的过程？](#请详细说说锁升级的过程)\n\n懵逼状态下的回答：锁升级会从无锁升级为偏向锁，再升级为轻量级锁，最后升级为重量级锁。\n\n\n\n知道一点，但不深入的回答：\n\n\n\n①、偏向锁：当一个线程第一次获取锁时，JVM 会在对象头的 Mark Word 记录这个线程 ID，下次进入 synchronized 时，如果还是同一个线程，可以直接执行，无需额外加锁。\n\n②、轻量级锁：当多个线程尝试获取锁但不是同一个时段，偏向锁会升级为轻量级锁，等待锁的线程通过 CAS 自旋避免进入阻塞状态。\n\n③、重量级锁：如果自旋失败，锁会升级为重量级锁，等待锁的线程会进入阻塞状态，等待监视器 Monitor 进行调度。\n\n详细解释一下：\n\n**①、从无锁到偏向锁：**\n\n当一个线程首次访问同步代码时，如果此对象处于无锁状态且偏向锁未被禁用，JVM 会将该对象头的锁标记改为偏向锁状态，并记录当前线程 ID。此时，对象头中的 Mark Word 中存储了持有偏向锁的线程 ID。\n\n如果另一个线程尝试获取这个已被偏向的锁，JVM 会检查当前持有偏向锁的线程是否活跃。如果持有偏向锁的线程不活跃，可以将锁偏向给新的线程；否则撤销偏向锁，升级为轻量级锁。\n\n**②、偏向锁的轻量级锁：**\n\n进行偏向锁撤销时，会遍历堆栈的所有锁记录，暂停拥有偏向锁的线程，并检查锁对象。如果这个过程中发现有其他线程试图获取这个锁，JVM 会撤销偏向锁，并将锁升级为轻量级锁。\n\n当有两个或以上线程竞争同一个偏向锁时，偏向锁模式不再有效，此时偏向锁会被撤销，对象的锁状态会升级为轻量级锁。\n\n**③、轻量级锁到重量级锁：**\n\n轻量级锁通过自旋来等待锁释放。如果自旋超过预定次数（自旋次数是可调的，并且是自适应的，失败次数多自旋次数就少），表明锁竞争激烈。\n\n当自旋多次失败，或者有线程在等待队列中等待相同的轻量级锁时，轻量级锁会升级为重量级锁。在这种情况下，JVM 会在操作系统层面创建一个互斥锁——Mutex，所有进一步尝试获取该锁的线程将会被阻塞，直到锁被释放。"
+ },
+ {
+ "id": 116,
+ "question": "synchronized 和 ReentrantLock 的区别了解吗？",
+ "answer": "两句话回答： 由 JVM 内部的 Monitor 机制实现，基于 AQS 实现。\n\nsynchronized 可以自动加锁和解锁，ReentrantLock 需要手动 `lock()` 和 `unlock()`。\n\n\n\n如果面试官还想知道更多，可以继续回答：\n\n①、ReentrantLock 可以实现多路选择通知，绑定多个 ，而 synchronized 只能通过 wait 和 notify 唤醒，属于单路通知；\n\n\n```java\nReentrantLock lock = new ReentrantLock();\nCondition condition = lock.newCondition();\n```\n\n\n②、synchronized 可以在方法和代码块上加锁，ReentrantLock 只能在代码块上加锁，但可以指定是公平锁还是非公平锁。\n\n\n```java\n// synchronized 修饰方法\npublic synchronized void method() {\n // 业务代码\n}\n\n// synchronized 修饰代码块\nsynchronized (this) {\n // 业务代码\n}\n\n// ReentrantLock 加锁\nReentrantLock lock = new ReentrantLock();\nlock.lock();\ntry {\n // 业务代码\n} finally {\n lock.unlock();\n}\n```\n\n\n③、ReentrantLock 提供了一种能够中断等待锁的线程机制，通过 `lock.lockInterruptibly()` 来实现。\n\n\n```java\nReentrantLock lock = new ReentrantLock();\ntry {\n lock.lockInterruptibly();\n} catch (InterruptedException e) {\n // 处理中断异常\n}\n```\n\n\n#### [并发量大的情况下，使用 synchronized 还是 ReentrantLock？](#并发量大的情况下-使用-synchronized-还是-reentrantlock)\n\n我更倾向于 ReentrantLock，因为：\n\n* ReentrantLock 提供了超时和公平锁等特性，可以应对更复杂的并发场景。\n* ReentrantLock 允许更细粒度的锁控制，能有效减少锁竞争。\n* ReentrantLock 支持条件变量 Condition，可以实现比 synchronized 更友好的线程间通信机制。\n\n#### [Lock 了解吗？](#lock-了解吗)\n\nLock 是 JUC 中的一个接口，最常用的实现类包括可重入锁 ReentrantLock、读写锁 ReentrantReadWriteLock 等。\n\n#### [ReentrantLock 的 lock() 方法实现逻辑了解吗？](#reentrantlock-的-lock-方法实现逻辑了解吗)\n\nlock 方法的具体实现由 ReentrantLock 内部的 Sync 类来实现，涉及到线程的自旋、阻塞队列、CAS、AQS 等。\n\n\n\nlock 方法会首先尝试通过 CAS 来获取锁。如果当前锁没有被持有，会将锁状态设置为 1，表示锁已被占用。否则，会将当前线程加入到 AQS 的等待队列中。\n\n\n```java\nfinal void lock() {\n if (compareAndSetState(0, 1)) // 尝试直接获取锁\n setExclusiveOwnerThread(Thread.currentThread());\n else\n acquire(1); // 如果获取失败，进入AQS队列等待\n}\n```"
+ },
+ {
+ "id": 117,
+ "question": "AQS 了解多少？",
+ "answer": "AQS 是一个抽象类，它维护了一个共享变量 state 和一个线程等待队列，为 ReentrantLock 等类提供底层支持。\n\n\n\nAQS 的思想是，如果被请求的共享资源处于空闲状态，则当前线程成功获取锁；否则，将当前线程加入到等待队列中，当其他线程释放锁时，从等待队列中挑选一个线程，把锁分配给它。\n\n#### [AQS 的源码阅读过吗？](#aqs-的源码阅读过吗)\n\n有研究过。\n\n第一，状态 state 由 volatile 变量修饰，用于保证多线程之间的可见性；\n\n\n```java\nprivate volatile int state;\n```\n\n\n②、同步队列由内部定义的 Node 类实现，每个 Node 包含了等待状态、前后节点、线程的引用等，是一个先进先出的双向链表。\n\n\n```java\nstatic final class Node {\n static final int CANCELLED = 1;\n static final int SIGNAL = -1;\n static final int CONDITION = -2;\n static final int PROPAGATE = -3;\n\n volatile Node prev;\n\n volatile Node next;\n\n volatile Thread thread;\n}\n```\n\n\nAQS 支持两种同步方式：\n\n* 独占模式下：每次只能有一个线程持有锁，例如 ReentrantLock。\n* 共享模式下：多个线程可以同时获取锁，例如 Semaphore 和 CountDownLatch。\n\n核心方法包括：\n\n* `acquire`：获取锁，失败进入等待队列；\n* `release`：释放锁，唤醒等待队列中的线程；\n* `acquireShared`：共享模式获取锁；\n* `releaseShared`：共享模式释放锁。\n\nAQS 使用一个 CLH 队列来维护等待线程，CLH 是三个作者 Craig、Landin 和 Hagersten 的首字母缩写，是一种基于链表的自旋锁。\n\n\n\n在 CLH 中，当一个线程尝试获取锁失败后，会被添加到队列的尾部并自旋，等待前一个节点的线程释放锁。\n\n\n\nCLH 的优点是，假设有 100 个线程在等待锁，锁释放之后，只会通知队列中的第一个线程去竞争锁。避免同时唤醒大量线程，浪费 CPU 资源。"
+ },
+ {
+ "id": 118,
+ "question": "说说 ReentrantLock 的实现原理？",
+ "answer": "是基于 AQS 实现的 可重入排他锁，使用 CAS 尝试获取锁，失败的话，会进入 CLH 阻塞队列，支持公平锁、非公平锁，可以中断、超时等待。\n\n\n\n内部通过一个计数器 state 来跟踪锁的状态和持有次数。当线程调用 `lock()` 方法获取锁时，ReentrantLock 会检查 state 的值，如果为 0，通过 CAS 修改为 1，表示成功加锁。否则根据当前线程的公平性策略，加入到等待队列中。\n\n线程首次获取锁时，state 值设为 1；如果同一个线程再次获取锁时，state 加 1；每释放一次锁，state 减 1。\n\n当线程调用 `unlock()` 方法时，ReentrantLock 会将持有锁的 state 减 1，如果 `state = 0`，则释放锁，并唤醒等待队列中的线程来竞争锁。\n\n使用方式非常简单：\n\n\n```java\nclass CounterWithLock {\n private int count = 0;\n private final Lock lock = new ReentrantLock();\n\n public void increment() {\n lock.lock(); // 获取锁\n try {\n count++;\n } finally {\n lock.unlock(); // 释放锁\n }\n }\n\n public int getCount() {\n return count;\n }\n}\n```\n\n\n`new ReentrantLock()` 默认创建的是非公平锁 NonfairSync。在非公平锁模式下，锁可能会授予刚刚请求它的线程，而不考虑等待时间。当切换到公平锁模式下，锁会授予等待时间最长的线程。"
+ },
+ {
+ "id": 119,
+ "question": "ReentrantLock 怎么创建公平锁？",
+ "answer": "很简单，创建 ReentrantLock 的时候，传递参数 true 就可以了。\n\n\n```java\nReentrantLock lock = new ReentrantLock(true);\n// true 代表公平锁，false 代表非公平锁\npublic ReentrantLock(boolean fair) {\n sync = fair ? new FairSync() : new NonfairSync();\n}\n```\n\n\n#### [怎么创建一个非公平锁呢？](#怎么创建一个非公平锁呢)\n\n创建 ReentrantLock 时，不传递参数或者传递参数就好了。\n\n#### [非公平锁和公平锁有什么不同？](#非公平锁和公平锁有什么不同)\n\n两句话回答：\n\n公平锁意味着在多个线程竞争锁时，获取锁的顺序与线程请求锁的顺序相同，即先来先服务。\n\n非公平锁不保证线程获取锁的顺序，当锁被释放时，任何请求锁的线程都有机会获取锁，而不是按照请求的顺序。\n\n#### [公平锁的实现逻辑了解吗？](#公平锁的实现逻辑了解吗)\n\n公平锁的核心逻辑在 AQS 的 `hasQueuedPredecessors()` 方法中，该方法用于判断当前线程前面是否有等待的线程。\n\n\n\n如果队列前面有等待线程，当前线程就不能抢占锁，必须按照队列顺序排队。如果队列前面没有线程，或者当前线程是队列头部的线程，就可以获取锁。"
+ },
+ {
+ "id": 120,
+ "question": "CAS 了解多少？",
+ "answer": "CAS 是一种乐观锁，用于比较一个变量的当前值是否等于预期值，如果相等，则更新值，否则重试。\n\n\n\n在 CAS 中，有三个值：\n\n* V：要更新的变量(var)\n* E：预期值(expected)\n* N：新值(new)\n\n先判断 V 是否等于 E，如果等于，将 V 的值设置为 N；如果不等，说明已经有其它线程更新了 V，当前线程就放弃更新。\n\n这个比较和替换的操作需要是原子的，不可中断的。Java 中的 CAS 是由 Unsafe 类实现的。\n\nAtomicInteger 类的 compareAndSet 就是一个 CAS 方法：\n\n\n```java\nAtomicInteger atomicInteger = new AtomicInteger(0);\nint expect = 0;\nint update = 1;\natomicInteger.compareAndSet(expect, update);\n```\n\n\n它调用的是 Unsafe 的 compareAndSwapInt。\n\n\n\n#### [怎么保证 CAS 的原子性？](#怎么保证-cas-的原子性)\n\nCPU 会发出一个 LOCK 指令进行总线锁定，阻止其他处理器对内存地址进行操作，直到当前指令执行完成。\n\n\n```text\nlock cmpxchg [esi], eax ; 比较 esi 地址中的值与 eax，如果相等则替换\n```\n"
+ },
+ {
+ "id": 121,
+ "question": "CAS 有什么问题？",
+ "answer": "CAS 存在三个经典问题，ABA 问题、自旋开销大、只能操作一个变量等。\n\n\n\n#### [什么是 ABA 问题？](#什么是-aba-问题)\n\nABA 问题指的是，一个值原来是 A，后来被改为 B，再后来又被改回 A，这时 CAS 会误认为这个值没有发生变化。\n\n\n```text\n线程 1：CAS(A → B)，修改变量 A → B\n线程 2：CAS(B → A)，变量又变回 A\n线程 3：CAS(A → C)，CAS 成功，但实际数据已被修改过！\n```\n\n\n可以使用版本号/时间戳的方式来解决 ABA 问题。\n\n比如说，每次变量更新时，不仅更新变量的值，还更新一个版本号。CAS 操作时，不仅比较变量的值，还比较版本号。\n\n\n```java\nclass OptimisticLockExample {\n private int version;\n private int value;\n\n public synchronized boolean updateValue(int newValue, int currentVersion) {\n if (this.version == currentVersion) {\n this.value = newValue;\n this.version++;\n return true;\n }\n return false;\n }\n}\n```\n\n\nJava 的 AtomicStampedReference 就增加了版本号，它会同时检查引用值和 stamp 是否都相等。\n\n\n\n使用示例：\n\n\n```java\nclass ABAFix {\n private static AtomicStampedReference ref = new AtomicStampedReference<>(\"100\", 1);\n\n public static void main(String[] args) {\n new Thread(() -> {\n int stamp = ref.getStamp();\n ref.compareAndSet(\"100\", \"200\", stamp, stamp + 1);\n ref.compareAndSet(\"200\", \"100\", ref.getStamp(), ref.getStamp() + 1);\n }).start();\n\n new Thread(() -> {\n try { Thread.sleep(100); } catch (InterruptedException e) {}\n int stamp = ref.getStamp();\n System.out.println(\"CAS 结果：\" + ref.compareAndSet(\"100\", \"300\", stamp, stamp + 1));\n }).start();\n }\n}\n```\n\n\n#### [自旋开销大怎么解决？](#自旋开销大怎么解决)\n\nCAS 失败时会不断自旋重试，如果一直不成功，会给 CPU 带来非常大的执行开销。\n\n可以加一个自旋次数的限制，超过一定次数，就切换到 synchronized 挂起线程。\n\n\n```java\nint MAX_RETRIES = 10;\nint retries = 0;\nwhile (!atomicInt.compareAndSet(expect, update)) {\n retries++;\n if (retries > MAX_RETRIES) {\n synchronized (this) { // 超过次数，使用 synchronized 处理\n if (atomicInt.get() == expect) {\n atomicInt.set(update);\n }\n }\n break;\n }\n}\n```\n\n\n#### [涉及到多个变量同时更新怎么办？](#涉及到多个变量同时更新怎么办)\n\n可以将多个变量封装为一个对象，使用 AtomicReference 进行 CAS 更新。\n\n\n```java\nclass Account {\n static class Balance {\n final int money;\n final int points;\n\n Balance(int money, int points) {\n this.money = money;\n this.points = points;\n }\n }\n\n private AtomicReference balance = new AtomicReference<>(new Balance(100, 10));\n\n public void update(int newMoney, int newPoints) {\n Balance oldBalance, newBalance;\n do {\n oldBalance = balance.get();\n newBalance = new Balance(newMoney, newPoints);\n } while (!balance.compareAndSet(oldBalance, newBalance));\n }\n}\n```"
+ },
+ {
+ "id": 122,
+ "question": "Java 有哪些保证原子性的方法？",
+ "answer": "\n\n比如说以 Atomic 开头的原子类，synchronized 关键字，ReentrantLock 锁等。"
+ },
+ {
+ "id": 123,
+ "question": "原子操作类了解多少？",
+ "answer": "原子操作类是基于 CAS + volatile 实现的，底层依赖于 Unsafe 类，最常用的有 AtomicInteger、AtomicLong、AtomicReference 等。\n\n\n\n像 AtomicIntegerArray 这种以 Array 结尾的，还可以原子更新数组里的元素。\n\n\n```java\nclass AtomicArrayExample {\n public static void main(String[] args) {\n AtomicIntegerArray atomicArray = new AtomicIntegerArray(new int[]{1, 2, 3});\n\n atomicArray.incrementAndGet(1); // 对索引 1 进行自增\n System.out.println(atomicArray.get(1)); // 输出 3\n }\n}\n```\n\n\n像 AtomicStampedReference 还可以通过版本号的方式解决 CAS 中的 ABA 问题。\n\n\n```java\nclass AtomicStampedReferenceExample {\n public static void main(String[] args) {\n AtomicStampedReference ref = new AtomicStampedReference<>(100, 1);\n\n int stamp = ref.getStamp(); // 获取版本号\n ref.compareAndSet(100, 200, stamp, stamp + 1); // A → B\n ref.compareAndSet(200, 100, ref.getStamp(), ref.getStamp() + 1); // B → A\n }\n}\n```"
+ },
+ {
+ "id": 124,
+ "question": "AtomicInteger 的源码读过吗？",
+ "answer": "有读过。\n\nAtomicInteger 是基于 volatile 和 CAS 实现的，底层依赖于 Unsafe 类。核心方法包括 getAndIncrement、compareAndSet 等。\n\n\n```java\npublic final int getAndIncrement() {\n return unsafe.getAndAddInt(this, valueOffset, 1);\n}\n```"
+ },
+ {
+ "id": 125,
+ "question": "线程死锁了解吗？",
+ "answer": "死锁发生在多个线程相互等待对方释放锁时。比如说线程 1 持有锁 R1，等待锁 R2；线程 2 持有锁 R2，等待锁 R1。\n\n\n\n#### [死锁发生的四个条件了解吗？](#死锁发生的四个条件了解吗)\n\n\n\n第一条件是**互斥**：资源不能被多个线程共享，一次只能由一个线程使用。如果一个线程已经占用了一个资源，其他请求该资源的线程必须等待，直到资源被释放。\n\n第二个条件是**持有并等待**：一个线程已经持有一个资源，并且在等待获取其他线程持有的资源。\n\n第三个条件是**不可抢占**：资源不能被强制从线程中夺走，必须等线程自己释放。\n\n第四个条件是**循环等待**：存在一种线程等待链，线程 A 等待线程 B 持有的资源，线程 B 等待线程 C 持有的资源，直到线程 N 又等待线程 A 持有的资源。\n\n#### [该如何避免死锁呢？](#该如何避免死锁呢)\n\n第一，所有线程都按照固定的顺序来申请资源。例如，先申请 R1 再申请 R2。\n\n第二，如果线程发现无法获取某个资源，可以先释放已经持有的资源，重新尝试申请。"
+ },
+ {
+ "id": 126,
+ "question": "死锁问题怎么排查呢？",
+ "answer": "首先从系统级别上排查，比如说在 Linux 生产环境中，可以先使用 `top` `ps` 等命令查看进程状态，看看是否有进程占用了过多的资源。\n\n接着，使用 JDK 自带的一些性能监控工具进行排查，比如说 使用 `jps -l` 查看当前进程，然后使用 `jstack 进程号` 查看当前进程的线程堆栈信息，看看是否有线程在等待锁资源。\n\n也可以使用一些可视化的性能监控工具，比如说 JConsole、VisualVM 等，查看线程的运行状态、锁的竞争情况等。\n\n\n\n我们来通过实际代码说明一下：\n\n\n```java\nclass DeadLockDemo {\n private static final Object lock1 = new Object();\n private static final Object lock2 = new Object();\n\n public static void main(String[] args) {\n new Thread(() -> {\n synchronized (lock1) {\n System.out.println(\"线程1获取到了锁1\");\n try {\n Thread.sleep(1000);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n synchronized (lock2) {\n System.out.println(\"线程1获取到了锁2\");\n }\n }\n }).start();\n\n new Thread(() -> {\n synchronized (lock2) {\n System.out.println(\"线程2获取到了锁2\");\n try {\n Thread.sleep(1000);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n synchronized (lock1) {\n System.out.println(\"线程2获取到了锁1\");\n }\n }\n }).start();\n }\n}\n```\n\n\n创建两个线程，每个线程都试图按照不同的顺序获取两个。\n\n锁的获取顺序不一致很容易导致死锁。运行这段代码，会发现两个线程都无法继续执行，进入了死锁状态。\n\n\n\n运行 `jstack pid` 命令，可以看到死锁的线程信息。\n\n\n\n编码时，尽量使用 `tryLock()` 代替 `lock()`，`tryLock()` 可以设置超时时间，避免线程一直等待。\n\n同时，尽量避免一个线程同时获取多个锁，如果需要多个锁，可以按照固定的顺序获取。"
+ },
+ {
+ "id": 127,
+ "question": "聊聊线程同步和互斥？（补充）",
+ "answer": "同步，意味着线程之间要密切合作，按照一定的顺序来执行任务。比如说，线程 A 先执行，线程 B 再执行。\n\n互斥，意味着线程之间要抢占资源，同一时间只能有一个线程访问共享资源。比如说，线程 A 在访问共享资源时，线程 B 不能访问。\n\n同步关注的是线程之间的协作，互斥关注的是线程之间的竞争。\n\n#### [如何实现同步和互斥？](#如何实现同步和互斥)\n\n可以使用 synchronized 关键字或者 Lock 接口的实现类，如 ReentrantLock 来给资源加锁。\n\n锁在操作系统层面的意思是 Mutex，某个线程进入临界区后，也就是获取到锁后，其他线程不能再进入临界区，要阻塞等待持有锁的线程离开临界区。\n\n\n\n#### [锁要解决哪些问题？](#锁要解决哪些问题)\n\n第一，谁可以拿到锁，可以是类对象，可以是当前的 this 对象，也可以是任何其他新建的对象。\n\n\n```java\nsynchronized (this) {\n // 临界区\n}\n```\n\n\n第二，抢占锁的规则，能不能抢占多次，自己能不能反复抢。\n\n第三，抢不到怎么办，自旋？阻塞？或者超时放弃？\n\n第四，锁被释放了还在等待锁的线程怎么办？是通知所有线程一起抢或者只告诉一个线程抢？\n\n#### [说说自旋锁？](#说说自旋锁)\n\n自旋锁是指当线程尝试获取锁时，如果锁已经被占用，线程不会立即阻塞，而是**通过自旋**，也就是循环等待的方式不断尝试获取锁。\n\n\n```text\n线程1 线程2\n | |\n | 获取锁成功 | 尝试获取锁\n |------------>|（锁已被占用，自旋等待）\n | 释放锁 |\n |<------------| 获取锁成功\n | |\n```\n\n\n适用于锁持有时间短的场景，ReentrantLock 的 tryLock 方法就用到了自旋锁。\n\n\n\n自旋锁的优点是可以避免线程切换带来的开销，缺点是如果锁被占用时间过长，会导致线程空转，浪费 CPU 资源。\n\n\n```java\nclass SpinLock {\n private AtomicBoolean lock = new AtomicBoolean(false);\n\n public void lock() {\n while (!lock.compareAndSet(false, true)) {\n // 自旋等待，不断尝试获取锁\n }\n }\n\n public void unlock() {\n lock.set(false);\n }\n\n public static void main(String[] args) {\n SpinLock spinLock = new SpinLock();\n\n Runnable task = () -> {\n spinLock.lock();\n try {\n System.out.println(Thread.currentThread().getName() + \" 获取到锁\");\n } finally {\n spinLock.unlock();\n }\n };\n\n Thread t1 = new Thread(task);\n Thread t2 = new Thread(task);\n\n t1.start();\n t2.start();\n }\n}\n```\n\n\n默认情况下，自旋锁会一直等待，直到获取到锁为止。在实际开发中，需要设置自旋次数或者超时时间。如果超过阈值，线程可以放弃锁或者进入阻塞状态。\n\n#### [互斥和同步在时间上有要求吗？](#互斥和同步在时间上有要求吗)\n\n有。\n\n互斥的核心是保证同一时刻只有一个线程能访问共享资源。\n\n同步强调的是线程之间的执行顺序，特别是在多个线程需要依赖于彼此的执行结果时。\n\n例如，在 CountDownLatch 中，主线程会等待多个子线程的任务完成。\n\n\n```java\nclass SyncExample {\n public static void main(String[] args) throws InterruptedException {\n CountDownLatch latch = new CountDownLatch(3);\n \n // 创建3个子线程\n for (int i = 0; i < 3; i++) {\n new Thread(() -> {\n try {\n Thread.sleep(1000); // 模拟任务\n System.out.println(\"打完练习伴侣者了.\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n latch.countDown(); // 每个线程任务完成后计数器减1\n }\n }).start();\n }\n \n System.out.println(\"等打完三把练习伴侣者就去睡觉...\");\n latch.await(); // 主线程等待子线程完成\n System.out.println(\"好，练习伴侣者玩完了，可以睡了\");\n }\n}\n```\n\n\n所有子线程完成后，主线程才会继续执行。\n\n"
+ },
+ {
+ "id": 128,
+ "question": "聊聊悲观锁和乐观锁？（补充）",
+ "answer": "> 2024 年 05 月 01 日增补\n\n好的。\n\n悲观锁认为每次访问共享资源时都会发生冲突，所在在操作前一定要先加锁，防止其他线程修改数据。\n\n乐观锁认为冲突不会总是发生，所以在操作前不加锁，而是在更新数据时检查是否有其他线程修改了数据。如果发现数据被修改了，就会重试。\n\n#### [乐观锁发现有线程过来修改数据，怎么办？](#乐观锁发现有线程过来修改数据-怎么办)\n\n可以重新读取数据，然后再尝试更新，直到成功为止或达到最大重试次数。\n\n\n```text\n读取数据 -> 尝试更新 -> 成功（返回成功）\n |\n -> 失败 -> 重试 -> 达到最大次数 -> 返回失败\n```\n\n\n写个代码演示一下：\n\n\n```java\nclass CasRetryExample {\n private static AtomicInteger counter = new AtomicInteger(0);\n private static final int MAX_RETRIES = 5;\n\n public static void main(String[] args) {\n boolean success = false;\n int retries = 0;\n\n while (retries < MAX_RETRIES) {\n int currentValue = counter.get();\n boolean updated = counter.compareAndSet(currentValue, currentValue + 1);\n \n if (updated) {\n System.out.println(\"更新成功，当前值: \" + counter.get());\n success = true;\n break;\n } else {\n retries++;\n System.out.println(\"更新失败，进行第 \" + retries + \" 次重试\");\n }\n }\n\n if (!success) {\n System.out.println(\"达到最大重试次数，操作失败\");\n }\n }\n}\n```"
+ }
+ ]
+ },
+ {
+ "id": 23,
+ "categoryName": "并发工具类",
+ "questions": [
+ {
+ "id": 129,
+ "question": "CountDownLatch 了解吗？",
+ "answer": "CountDownLatch 是 JUC 中的一个同步工具类，用于协调多个线程之间的同步，确保主线程在多个子线程完成任务后继续执行。\n\n它的核心思想是通过一个倒计时计数器来控制多个线程的执行顺序。\n\n\n```java\nclass CountDownLatchExample {\n public static void main(String[] args) throws InterruptedException {\n int threadCount = 3;\n CountDownLatch latch = new CountDownLatch(threadCount);\n\n for (int i = 0; i < threadCount; i++) {\n new Thread(() -> {\n try {\n Thread.sleep((long) (Math.random() * 1000)); // 模拟任务执行\n System.out.println(Thread.currentThread().getName() + \" 执行完毕\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n latch.countDown(); // 线程完成后，计数器 -1\n }\n }).start();\n }\n\n latch.await(); // 主线程等待\n System.out.println(\"所有子线程执行完毕，主线程继续执行\");\n }\n}\n```\n\n\n在使用的时候，我们需要先初始化一个 CountDownLatch 对象，指定一个计数器的初始值，表示需要等待的线程数量。\n\n然后在每个子线程执行完任务后，调用 `countDown()` 方法，计数器减 1。\n\n接着主线程调用 `await()` 方法进入阻塞状态，直到计数器为 0，也就是所有子线程都执行完任务后，主线程才会继续执行。\n\n\n\n以练习伴侣者荣耀为例，我们来创建五个线程，分别代表大乔、兰陵王、安其拉、哪吒和铠。每个玩家都调用 `countDown()` 方法，表示已就位。主线程调用 `await()` 方法，等待所有玩家就位。\n\n\n```java\npublic static void main(String[] args) throws InterruptedException {\n CountDownLatch countDownLatch = new CountDownLatch(5);\n\n Thread daqiao = new Thread(() -> {\n System.out.println(\"大乔已就位！\");\n countDownLatch.countDown();\n });\n Thread lanlingwang = new Thread(() -> {\n System.out.println(\"兰陵练习伴侣已就位！\");\n countDownLatch.countDown();\n });\n Thread anqila = new Thread(() -> {\n System.out.println(\"安其拉已就位！\");\n countDownLatch.countDown();\n });\n Thread nezha = new Thread(() -> {\n System.out.println(\"哪吒已就位！\");\n countDownLatch.countDown();\n });\n Thread kai = new Thread(() -> {\n System.out.println(\"铠已就位！\");\n countDownLatch.countDown();\n });\n\n daqiao.start();\n lanlingwang.start();\n anqila.start();\n nezha.start();\n kai.start();\n\n countDownLatch.await();\n System.out.println(\"全员就位，开始游戏！\");\n}\n```\n\n\n五个玩家在倒计时结束后，一起出击。\n\n\n```java\nprivate static void waitToFight(CountDownLatch countDownLatch, String name) {\n try {\n countDownLatch.await(); // 在此等待信号再继续\n System.out.println(name + \" 收到，发起进攻！\");\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n System.out.println(name + \" 被中断\");\n }\n}\n\npublic static void main(String[] args) {\n CountDownLatch countDownLatch = new CountDownLatch(1);\n\n Thread daqiao = new Thread(() -> waitToFight(countDownLatch, \"大乔\"), \"Thread-大乔\");\n Thread lanlingwang = new Thread(() -> waitToFight(countDownLatch, \"兰陵练习伴侣\"), \"Thread-兰陵练习伴侣\");\n Thread anqila = new Thread(() -> waitToFight(countDownLatch, \"安琪拉\"), \"Thread-安琪拉\");\n Thread nezha = new Thread(() -> waitToFight(countDownLatch, \"哪吒\"), \"Thread-哪吒\");\n Thread kai = new Thread(() -> waitToFight(countDownLatch, \"凯\"), \"Thread-凯\");\n\n daqiao.start();\n lanlingwang.start();\n anqila.start();\n nezha.start();\n kai.start();\n\n try {\n Thread.sleep(5000); // 模拟准备时间\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n System.out.println(\"主线程被中断\");\n }\n\n System.out.println(\"敌军还有 5 秒到达战场，全军出击！\");\n countDownLatch.countDown(); // 发出信号\n}\n```\n\n\n#### [场景题：假如要查10万多条数据，用线程池分成20个线程去执行，怎么做到等所有的线程都查找完之后，即最后一条结果查找结束了，才输出结果？](#场景题-假如要查10万多条数据-用线程池分成20个线程去执行-怎么做到等所有的线程都查找完之后-即最后一条结果查找结束了-才输出结果)\n\n很简单，可以使用 CountDownLatch 来实现。CountDownLatch 非常适合这个场景。\n\n第一步，创建 CountDownLatch 对象，初始值设定为 20，表示 20 个线程需要完成任务。\n\n第二步，创建线程池，每个线程执行查询操作，查询完毕后调用 `countDown()` 方法，计数器减 1。\n\n第三步，主线程调用 `await()` 方法，等待所有线程执行完毕。\n\n\n```java\nclass DataQueryExample {\n\n public static void main(String[] args) throws InterruptedException {\n // 模拟10万条数据\n int totalRecords = 100000;\n int threadCount = 20;\n int batchSize = totalRecords / threadCount; // 每个线程处理的数据量\n\n // 创建线程池\n ExecutorService executor = Executors.newFixedThreadPool(threadCount);\n CountDownLatch latch = new CountDownLatch(threadCount);\n\n // 模拟查询结果\n ConcurrentLinkedQueue results = new ConcurrentLinkedQueue<>();\n\n for (int i = 0; i < threadCount; i++) {\n int start = i * batchSize;\n int end = (i == threadCount - 1) ? totalRecords : (start + batchSize);\n \n executor.execute(() -> {\n try {\n // 模拟查询操作\n for (int j = start; j < end; j++) {\n results.add(\"Data-\" + j);\n }\n System.out.println(Thread.currentThread().getName() + \" 处理数据 \" + start + \" - \" + end);\n } finally {\n latch.countDown(); // 线程任务完成，计数器减1\n }\n });\n }\n\n // 等待所有线程完成\n latch.await();\n executor.shutdown();\n\n // 输出结果\n System.out.println(\"所有线程执行完毕，查询结果总数：\" + results.size());\n }\n}\n```"
+ },
+ {
+ "id": 130,
+ "question": "CyclicBarrier 了解吗？",
+ "answer": "了解。\n\nCyclicBarrier 的字面意思是可循环使用的屏障，用于多个线程相互等待，直到所有线程都到达屏障后再同时执行。\n\n\n\n在使用的时候，我们需要先初始化一个 CyclicBarrier 对象，指定一个屏障值 N，表示需要等待的线程数量。\n\n然后每个线程执行 `await()` 方法，表示自己已经到达屏障，等待其他线程，此时屏障值会减 1。\n\n当所有线程都到达屏障后，也就是屏障值为 0 时，所有线程会继续执行。\n\n\n```java\nclass CyclicBarrierExample {\n private static final int THREAD_COUNT = 3;\n private static final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT);\n\n public static void main(String[] args) {\n for (int i = 0; i < THREAD_COUNT; i++) {\n new Thread(() -> {\n try {\n System.out.println(Thread.currentThread().getName() + \" 到达屏障\");\n barrier.await(); // 线程阻塞，直到所有线程都到达\n System.out.println(Thread.currentThread().getName() + \" 继续执行\");\n } catch (InterruptedException | BrokenBarrierException e) {\n e.printStackTrace();\n }\n }).start();\n }\n }\n}\n```"
+ },
+ {
+ "id": 131,
+ "question": "CyclicBarrier 和 CountDownLatch 有什么区别？",
+ "answer": "CyclicBarrier 让所有线程相互等待，全部到达后再继续；CountDownLatch 让主线程等待所有子线程执行完再继续。\n\n| 对比项 | CyclicBarrier | CountDownLatch |\n| --- | --- | --- |\n| 主要用途 | 让所有线程相互等待，全部到达后再继续 | 让主线程等待所有子线程执行完 |\n| 可重用性 | ✅ 可重复使用，每次屏障打开后自动重置 | ❌ 不可重复使用，计数器归零后不能恢复 |\n| 是否可执行回调 | ✅ 可以，所有线程到达屏障后可执行 barrierAction | ❌ 不能 |\n| 线程等待情况 | 所有线程互相等待，一个线程未到达，其他线程都会阻塞 | 主线程等待所有子线程完成，子线程执行完后可继续运行 |\n| 适用场景 | 线程相互依赖，需要同步执行 | 主线程等待子线程完成 |\n| 示例场景 | 计算任务拆分，所有线程都到达后才能继续 | 主线程等多个任务初始化完成 |"
+ },
+ {
+ "id": 132,
+ "question": "Semaphore 了解吗？",
+ "answer": "Semaphore——信号量，用于控制同时访问某个资源的线程数量，类似限流器，确保最多只有指定数量的线程能够访问某个资源，超过的必须等待。\n\n\n\n拿停车场来举例。\n\n停车场的车位是有限的，如果有空位，显示牌需要显示剩余的车位，车辆就可以驶入；否则就会显示数字 0，新来的车辆就得排队等待。\n\n如果有车离开，显示牌重新显示闲置的车位数量，等待的车辆按序驶入停车场。\n\n\n\n在使用 Semaphore 时，首先需要初始化一个 Semaphore 对象，指定许可证数量，表示最多允许多少个线程同时访问资源。\n\n然后在每个线程访问资源前，调用 `acquire()` 方法获取许可证，如果没有可用许可证，则阻塞等待。\n\n需要注意的是，访问完资源后，要调用 `release()` 方法释放许可证。\n\n\n```java\nclass SemaphoreExample {\n private static final int THREAD_COUNT = 5;\n private static final Semaphore semaphore = new Semaphore(2); // 最多允许 2 个线程访问\n\n public static void main(String[] args) {\n for (int i = 0; i < THREAD_COUNT; i++) {\n new Thread(() -> {\n try {\n semaphore.acquire(); // 获取许可（如果没有可用许可，则阻塞）\n System.out.println(Thread.currentThread().getName() + \" 访问资源...\");\n Thread.sleep(2000); // 模拟任务执行\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n semaphore.release(); // 释放许可\n }\n }).start();\n }\n }\n}\n```\n\n\nSemaphore 可以用于流量控制，比如数据库连接池、网络连接池等。\n\n假如有这样一个需求，要读取几万个文件的数据，因为都是 IO 密集型任务，我们可以启动几十个线程并发地读取。\n\n但是在读到内存后，需要存储到数据库，而数据库连接数是有限的，比如说只有 10 个，那我们就必须控制线程的数量，保证同时只有 10 个线程在使用数据库连接。\n\n这个时候，就可以使用 Semaphore 来做流量控制：\n\n\n```java\nclass SemaphoreTest {\n private static final int THREAD_COUNT = 30;\n private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);\n private static Semaphore s = new Semaphore(10);\n\n public static void main(String[] args) {\n for (int i = 0; i < THREAD_COUNT; i++) {\n threadPool.execute(new Runnable() {\n @Override\n public void run() {\n try {\n s.acquire();\n System.out.println(\"save data\");\n s.release();\n } catch (InterruptedException e) {\n }\n }\n });\n }\n threadPool.shutdown();\n }\n}\n```"
+ },
+ {
+ "id": 133,
+ "question": "Exchanger 了解吗？",
+ "answer": "Exchanger——交换者，用于在两个线程之间进行数据交换。\n\n\n\n支持双向数据交换，比如说线程 A 调用 `exchange(dataA)`，线程 B 调用 `exchange(dataB)`，它们会在同步点交换数据，即 A 得到 B 的数据，B 得到 A 的数据。\n\n如果一个线程先调用 `exchange()`，它会阻塞等待，直到另一个线程也调用 `exchange()`。\n\n使用 Exchanger 的时候，需要先创建一个 Exchanger 对象，然后在两个线程中调用 `exchange()` 方法，就可以进行数据交换了。\n\n\n```java\nclass ExchangerExample {\n private static final Exchanger exchanger = new Exchanger<>();\n\n public static void main(String[] args) {\n new Thread(() -> {\n try {\n String threadAData = \"数据 A\";\n System.out.println(\"线程 A 交换前的数据：\" + threadAData);\n String received = exchanger.exchange(threadAData);\n System.out.println(\"线程 A 收到的数据：\" + received);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }).start();\n\n new Thread(() -> {\n try {\n String threadBData = \"数据 B\";\n System.out.println(\"线程 B 交换前的数据：\" + threadBData);\n String received = exchanger.exchange(threadBData);\n System.out.println(\"线程 B 收到的数据：\" + received);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }).start();\n }\n}\n```\n\n\nExchanger 可以用于遗传算法，也可以用于校对工作，比如我们将纸制银行流水通过人工的方式录入到电子银行时，为了避免错误，可以录入两遍，然后通过 Exchanger 来校对两次录入的结果。\n\n\n```java\nclass ExchangerTest {\n private static final Exchanger exgr = new Exchanger();\n private static ExecutorService threadPool = Executors.newFixedThreadPool(2);\n\n public static void main(String[] args) {\n threadPool.execute(new Runnable() {\n @Override\n public void run() {\n try {\n String A = \"银行流水A\"; // A录入银行流水数据\n exgr.exchange(A);\n } catch (InterruptedException e) {\n }\n }\n });\n threadPool.execute(new Runnable() {\n @Override\n public void run() {\n try {\n String B = \"银行流水B\"; // B录入银行流水数据\n String A = exgr.exchange(\"B\");\n System.out.println(\"A和B数据是否一致：\" + A.equals(B) + \"，A录入的是：\"\n + A + \"，B录入是：\" + B);\n } catch (InterruptedException e) {\n }\n }\n });\n threadPool.shutdown();\n }\n}\n```"
+ },
+ {
+ "id": 134,
+ "question": "能说一下 ConcurrentHashMap 的实现吗？（补充）",
+ "answer": "> 2024 年 03 月 25 日增补，从集合框架篇移到这里。\n\n好的。 是 HashMap 的线程安全版本。\n\nJDK 7 采用的是分段锁，整个 Map 会被分为若干段，每个段都可以独立加锁。不同的线程可以同时操作不同的段，从而实现并发。\n\n\n\nJDK 8 使用了一种更加细粒度的锁——桶锁，再配合 CAS + synchronized 代码块控制并发写入，以最大程度减少锁的竞争。\n\n\n\n对于读操作，ConcurrentHashMap 使用了 volatile 变量来保证内存可见性。\n\n对于写操作，ConcurrentHashMap 优先使用 CAS 尝试插入，如果成功就直接返回；否则使用 synchronized 代码块进行加锁处理。\n\n#### [说一下 JDK 7 中 ConcurrentHashMap 的实现原理？](#说一下-jdk-7-中-concurrenthashmap-的实现原理)\n\n好的。\n\nJDK 7 的 ConcurrentHashMap 采用的是分段锁，整个 Map 会被分为若干段，每个段都可以独立加锁，每个段类似一个 Hashtable。\n\n\n\n每个段维护一个键值对数组 `HashEntry[] table`，HashEntry 是一个单项链表。\n\n\n```java\nstatic final class HashEntry {\n final int hash;\n final K key;\n volatile V value;\n final HashEntry next;\n}\n```\n\n\n段继承了 ReentrantLock，所以每个段都是一个可重入锁，不同的线程可以同时操作不同的段，从而实现并发。\n\n\n```java\nstatic final class Segment extends ReentrantLock {\n transient volatile HashEntry[] table;\n transient int count;\n}\n```\n\n\n#### [说一下 JDK 7 中 ConcurrentHashMap 的 put 流程？](#说一下-jdk-7-中-concurrenthashmap-的-put-流程)\n\nput 流程和 HashMap 非常类似，只不过是先定位到具体的段，再通过 ReentrantLock 去操作而已。一共可以分为 4 个步骤：\n\n第一步，计算 key 的 hash，定位到段，段如果是空就先初始化；\n\n第二步，使用 ReentrantLock 进行加锁，如果加锁失败就自旋，自旋超过次数就阻塞，保证一定能获取到锁；\n\n第三步，遍历段中的键值对 HashEntry，key 相同直接替换，key 不存在就插入。\n\n第四步，释放锁。\n\n\n\n#### [说一下 JDK 7 中 ConcurrentHashMap 的 get 流程？](#说一下-jdk-7-中-concurrenthashmap-的-get-流程)\n\nget 就更简单了，先计算 key 的 hash 找到段，再遍历段中的键值对，找到就直接返回 value。\n\nget 不用加锁，因为是 value 是 的，所以线程读取 value 时不会出现可见性问题。\n\n#### [说一下 JDK 8 中 ConcurrentHashMap 的实现原理？](#说一下-jdk-8-中-concurrenthashmap-的实现原理)\n\n好的。\n\nJDK 8 中的 ConcurrentHashMap 取消了分段锁，采用 CAS + synchronized 来实现更细粒度的桶锁，并且使用红黑树来优化链表以提高哈希冲突时的查询效率，性能比 JDK 7 有了很大的提升。\n\n#### [说一下 JDK 8 中 ConcurrentHashMap 的 put 流程？](#说一下-jdk-8-中-concurrenthashmap-的-put-流程)\n\n\n\n第一步，计算 key 的 hash，以确定桶在数组中的位置。如果数组为空，采用 CAS 的方式初始化，以确保只有一个线程在初始化数组。\n\n\n```java\n// 计算 hash\nint hash = spread(key.hashCode());\n\n// 初始化数组\nif (tab == null || (n = tab.length) == 0)\n tab = initTable();\n\n// 计算桶的位置\nint i = (n - 1) & hash;\n```\n\n\n第二步，如果桶为空，直接 CAS 插入节点。如果 CAS 操作失败，会退化为 synchronized 代码块来插入节点。\n\n\n```java\n// CAS 插入节点\nif (tabAt(tab, i) == null) {\n if (casTabAt(tab, i, null, new Node(hash, key, value, null)))\n break;\n}\n\n// 否则，使用 synchronized 代码块插入节点\nelse {\n synchronized (f) { // **只锁当前桶**\n if (tabAt(tab, i) == f) { // 确保未被其他线程修改\n if (f.hash >= 0) { // 链表处理\n for (Node e = f;;) {\n K ek;\n if (e.hash == hash && ((ek = e.key) == key || (key != null && key.equals(ek)))) {\n e.val = value;\n break;\n }\n e = e.next;\n }\n } else if (f instanceof TreeBin) { // **红黑树处理**\n ((TreeBin) f).putTreeVal(hash, key, value);\n }\n }\n }\n}\n```\n\n\n插入的过程中会判断桶的哈希是否小于 0（`f.hash >= 0`），小于 0 说明是红黑树，大于等于 0 说明是链表。\n\n这里补充一点：在 ConcurrentHashMap 的实现中，红黑树节点 TreeBin 的 hash 值固定为 -2。\n\n\n\n第三步，如果链表长度超过 8，转换为红黑树。\n\n\n```java\nif (binCount >= TREEIFY_THRESHOLD)\n treeifyBin(tab, i);\n```\n\n\n第四步，在插入新节点后，会调用 `addCount()` 方法检查是否需要扩容。\n\n\n```java\naddCount(1L, binCount);\n```\n\n\n#### [说一下 JDK 8 中 ConcurrentHashMap 的 get 流程？](#说一下-jdk-8-中-concurrenthashmap-的-get-流程)\n\nget 也是通过 key 的 hash 进行定位，如果该位置节点的哈希匹配且键相等，则直接返回值。\n\n\n\n如果节点的哈希为负数，说明是个特殊节点，比如说如树节点或者正在迁移的节点，就调用`find`方法查找。\n\n\n\n否则遍历链表查找匹配的键。如果都没找到，返回 null。\n\n#### [说一下 HashMap 和 ConcurrentHashMap 的区别？](#说一下-hashmap-和-concurrenthashmap-的区别)\n\nHashMap 是非线程安全的，多线程环境下应该使用 ConcurrentHashMap。\n\n#### [你项目中怎么使用 ConcurrentHashMap 的？](#你项目中怎么使用-concurrenthashmap-的)\n\n在中，很多地方都用到了 ConcurrentHashMap，比如说在异步工具类 AsyncUtil 中，就使用了 ConcurrentHashMap 来存储任务的名称和它们的运行时间，以便观察和分析任务的执行情况。\n\n\n\n#### [说一下 ConcurrentHashMap 对 HashMap 的改进？](#说一下-concurrenthashmap-对-hashmap-的改进)\n\n首先是 hash 的计算方法上，ConcurrentHashMap 的 spread 方法接收一个已经计算好的 hashCode，然后将这个哈希码的高 16 位与自身进行异或运算。\n\n\n```java\nstatic final int spread(int h) {\n return (h ^ (h >>> 16)) & HASH_BITS;\n}\n```\n\n\n比 HashMap 的 hash 计算多了一个 `& HASH_BITS` 的操作。这里的 HASH\\_BITS 是一个常数，值为 0x7fffffff，它确保结果是一个非负整数。\n\n\n```java\nstatic final int hash(Object key) {\n int h;\n return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```\n\n\n另外，ConcurrentHashMap 对节点 Node 做了进一步的封装，比如说用 Forwarding Node 来表示正在进行扩容的节点。\n\n\n```java\nstatic final class ForwardingNode extends Node {\n final Node[] nextTable;\n ForwardingNode(Node[] tab) {\n super(MOVED, null, null, null);\n this.nextTable = tab;\n }\n}\n```\n\n\n最后就是 put 方法，通过 CAS + synchronized 代码块来进行并发写入。\n\n\n\n#### [为什么 ConcurrentHashMap 在 JDK 1.7 中要用 ReentrantLock，而在 JDK 1.8 要用 synchronized](#为什么-concurrenthashmap-在-jdk-1-7-中要用-reentrantlock-而在-jdk-1-8-要用-synchronized)\n\nJDK 1.7 中的 ConcurrentHashMap 使用了分段锁机制，每个 Segment 都继承了 ReentrantLock，这样可以保证每个 Segment 都可以独立地加锁。\n\n而在 JDK 1.8 中，ConcurrentHashMap 取消了 Segment 分段锁，采用了更加精细化的锁——桶锁，以及 CAS 无锁算法，每个桶都可以独立地加锁，只有在 CAS 失败时才会使用 synchronized 代码块加锁，这样可以减少锁的竞争，提高并发性能。"
+ },
+ {
+ "id": 135,
+ "question": "ConcurrentHashMap 怎么保证可见性？（补充）",
+ "answer": "> 2024 年 03 月 25 日增补\n\nConcurrentHashMap 中的 Node 节点中，value 和 next 都是 volatile 的，这样就可以保证对 value 或 next 的更新会被其他线程立即看到。\n\n\n```java\nstatic class Node implements Map.Entry {\n final int hash;\n final K key;\n volatile V value;\n volatile Node next;\n}\n```"
+ },
+ {
+ "id": 136,
+ "question": "为什么 ConcurrentHashMap 比 Hashtable 效率高（补充）",
+ "answer": "> 2024 年 03 月 26 日增补，从集合框架移动到并发编程这里\n\nHashtable 在任何时刻只允许一个线程访问整个 Map，是通过对整个 Map 加锁来实现线程安全的。比如 get 和 put 方法，是直接在方法上加的 synchronized 关键字。\n\n\n```java\npublic synchronized V put(K key, V value) {\n if (value == null) throw new NullPointerException();\n int hash = key.hashCode();\n int index = (hash & 0x7FFFFFFF) % table.length;\n ...\n return oldValue;\n}\n```\n\n\n而 ConcurrentHashMap 在 JDK 8 中是采用 CAS + synchronized 实现的，仅在必要时加锁。\n\n比如说 put 的时候优先使用 CAS 尝试插入，如果失败再使用 synchronized 代码块加锁。\n\nget 的时候是完全无锁的，因为 value 是 修饰的，保证了内存可见性。\n\n\n```java\npublic V get(Object key) {\n int hash = spread(key.hashCode());\n Node[] tab = table;\n int index = (tab.length - 1) & hash;\n Node e = tabAt(tab, index);\n \n if (e != null) {\n do {\n if (e.hash == hash && (e.key == key || (key != null && key.equals(e.key)))) {\n return e.value; // 读取 volatile 变量，保证可见性\n }\n } while ((e = e.next) != null);\n }\n return null;\n}\n```"
+ },
+ {
+ "id": 137,
+ "question": "能说一下 CopyOnWriteArrayList 的实现原理吗？（补充）",
+ "answer": "CopyOnWriteArrayList 是 ArrayList 的线程安全版本，适用于读多写少的场景。它的核心思想是写操作时创建一个新数组，修改后再替换原数组，这样就能够确保读操作无锁，从而提高并发性能。\n\n\n\n内部使用 volatile 变量来修饰数组 array，以读操作的内存可见性。\n\n\n```java\nprivate transient volatile Object[] array;\n```\n\n\n写操作的时候使用 ReentrantLock 来保证线程安全。\n\n\n```java\npublic boolean add(E e) {\n final ReentrantLock lock = this.lock;\n // 加锁\n lock.lock();\n try {\n Object[] elements = getArray();\n int len = elements.length;\n // 创建一个新数组\n Object[] newElements = Arrays.copyOf(elements, len + 1);\n newElements[len] = e;\n // 替换原数组\n setArray(newElements);\n return true;\n } finally {\n // 释放锁\n lock.unlock();\n }\n}\n```\n\n\n缺点就是写操作的时候会复制一个新数组，如果数组很大，写操作的性能会受到影响。"
+ },
+ {
+ "id": 138,
+ "question": "能说一下 BlockingQueue 吗？（补充）",
+ "answer": "> 2024 年 08 月 18 日增补，从集合框架移动到并发编程这里\n\n是 JUC 包下的一个线程安全队列，支持阻塞式的“生产者-消费者”模型。\n\n当队列容器已满，生产者线程会被阻塞，直到消费者线程取走元素后为止；当队列容器为空时，消费者线程会被阻塞，直至队列非空时为止。\n\nBlockingQueue 的实现类有很多，比如说 ArrayBlockingQueue、PriorityBlockingQueue 等。\n\n| 实现类 | 数据结构 | 是否有界 | 特点 |\n| --- | --- | --- | --- |\n| ArrayBlockingQueue | 数组 | ✅ 有界 | 基于数组，固定容量，FIFO |\n| LinkedBlockingQueue | 链表 | ✅ 可有界（默认 Integer.MAX\\_VALUE） | 基于链表，吞吐量比 ArrayBlockingQueue 高 |\n| PriorityBlockingQueue | 堆（优先队列） | ❌ 无界 | 元素按优先级排序（非 FIFO） |\n| DelayQueue | 优先队列（基于 Delayed 接口） | ❌ 无界 | 元素到期后才能被取出 |\n| SynchronousQueue | 无缓冲 | ✅ 容量为 0 | 必须一对一交换数据，适用于高吞吐的任务提交 |\n| LinkedTransferQueue | 链表 | ❌ 无界 | 支持 tryTransfer()，数据立即交给消费者 |\n\n#### [阻塞队列是如何实现的？](#阻塞队列是如何实现的)\n\n阻塞队列使用 + Condition 来确保并发安全。\n\n以 ArrayBlockingQueue 为例，它内部维护了一个数组，使用两个指针分别指向队头和队尾。\n\nput 的时候先用 ReentrantLock 加锁，然后判断队列是否已满，如果已满就阻塞等待，否则插入元素。\n\n\n```java\nfinal ReentrantLock lock;\nprivate final Condition notEmpty;\nprivate final Condition notFull;\n\npublic void put(E e) throws InterruptedException {\n final ReentrantLock lock = this.lock;\n lock.lockInterruptibly(); // 🔹 加锁，确保线程安全\n try {\n while (count == items.length) { // 🔹 队列满，阻塞\n notFull.await();\n }\n enqueue(e); // 🔹 插入元素\n } finally {\n lock.unlock(); // 🔹 释放锁\n }\n}\n```"
+ }
+ ]
+ },
+ {
+ "id": 24,
+ "categoryName": "线程池",
+ "questions": [
+ {
+ "id": 139,
+ "question": "什么是线程池？",
+ "answer": "线程池是用来管理和复用线程的工具，它可以减少线程的创建和销毁开销。\n\n\n\n在 Java 中，ThreadPoolExecutor 是线程池的核心实现，它通过核心线程数、最大线程数、任务队列和拒绝策略来控制线程的创建和执行。\n\n举个例子：就像你开了一家餐厅，线程池就相当于固定数量的服务员，顾客（任务）来了就安排空闲的服务员（线程）处理，避免了频繁招人和解雇的成本。"
+ },
+ {
+ "id": 140,
+ "question": "你在项目中有用到线程池吗？",
+ "answer": "有，用到过很多次。\n\n比如说在当中， 我们就封装了一个异步工具类 AsyncUtil，内置了可配置的线程池，基于 ThreadPoolExecutor，适用于 IO 密集型任务。\n\n其中 corePoolSize 为 CPU 核心数的两倍，因为技术派中的大多数任务都是 IO 密集型的，maxPoolSize 设置为 50，是一个比较理想的值，尤其是在本地环境中；阻塞队列为 SynchronousQueue，意味着任务被创建后可以直接提交给等待的线程处理。"
+ },
+ {
+ "id": 141,
+ "question": "说一下线程池的工作流程？",
+ "answer": "可以简单总结为：\n\n任务提交 → 核心线程执行 → 任务队列缓存 → 非核心线程执行 → 拒绝策略处理。\n\n第一步，线程池通过 `submit()` 提交任务。\n\n\n```java\nExecutorService threadPool = Executors.newFixedThreadPool(5);\nthreadPool.submit(() -> {\n System.out.println(Thread.currentThread().getName() + \"\\t\" + \"办理业务\");\n});\n```\n\n\n第二步，线程池会先创建核心线程来执行任务。\n\n\n```java\nif (workerCountOf(c) < corePoolSize) {\n if (addWorker(command, true)) {\n return;\n }\n}\n```\n\n\n第三步，如果核心线程都在忙，任务会被放入任务队列中。\n\n\n```java\nworkQueue.offer(task);\n```\n\n\n第四步，如果任务队列已满，且当前线程数量小于最大线程数，线程池会创建新的线程来处理任务。\n\n\n```java\nif (!addWorker(command, false))\n```\n\n\n第五步，如果线程池中的线程数量已经达到最大线程数，且任务队列已满，线程池会执行拒绝策略。\n\n\n```java\nhandler.rejectedExecution(command, this);\n```\n\n\n另外一版回答。\n\n第一步，创建线程池。\n\n第二步，调用线程池的 `execute()`方法，准备执行任务。\n\n* 如果正在运行的线程数量小于 corePoolSize，那么线程池会创建一个新的线程来执行这个任务；\n* 如果正在运行的线程数量大于或等于 corePoolSize，那么线程池会将这个任务放入等待队列；\n* 如果等待队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么线程池会创建新的线程来执行这个任务；\n* 如果等待队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会执行拒绝策略。\n\n\n\n第三步，线程执行完毕后，线程并不会立即销毁，而是继续保持在池中等待下一个任务。\n\n第四步，当线程空闲时间超出指定时间，且当前线程数量大于核心线程数时，线程会被回收。\n\n#### [能用一个生活中的例子说明下吗？](#能用一个生活中的例子说明下吗)\n\n可以。有个名叫“你一定暴富”的银行，该银行有 6 个窗口，现在开放了 3 个窗口，坐着 3 个小姐姐在办理业务。\n\n靓仔小二去办理业务，会遇到什么情况呢？\n\n第一情况，小二发现有个空闲的小姐姐，正在翘首以盼，于是小二就快马加鞭跑过去办理了。\n\n\n\n第二种情况，小姐姐们都在忙，接待员小美招呼小二去排队区区取号排队，让小二稍安勿躁。\n\n\n\n第三种情况，不仅小姐姐们都在忙，排队区也满了，小二着急用钱，于是脾气就上来了，和接待员小美对线了起来，要求开放另外 3 个空闲的窗口。\n\n小美迫于小二的压力，开放了另外 3 个窗口，排队区的人立马就冲了过去。\n\n\n\n第四种情况，6 个窗口的小姐姐都在忙，排队区也满了。。。\n\n\n\n接待员小美给了小二 4 个选项：\n\n1. 对不起，我们暴富银行系统瘫痪了。\n2. 没看忙着呢，谁叫你来办的你找谁去！\n3. 靓仔，看你比较急，去队里偷偷加个塞。\n4. 不好意思，今天没办法，你改天再来吧。\n\n这个流程和线程池不能说一模一样，简直就是一模一样：\n\n1. corePoolSize 对应营业窗口数 3\n2. maximumPoolSize 对应最大窗口数 6\n3. workQueue 对应排队区\n4. handler 对应接待员小美\n\n\n```java\nclass ThreadPoolDemo {\n public static void main(String[] args) {\n // 创建一个线程池\n ExecutorService threadPool = new ThreadPoolExecutor(\n 3, // 核心线程数\n 6, // 最大线程数\n 0, // 线程空闲时间\n TimeUnit.SECONDS, // 时间单位\n new LinkedBlockingQueue<>(10), // 等待队列\n Executors.defaultThreadFactory(), // 线程工厂\n new ThreadPoolExecutor.AbortPolicy() // 拒绝策略\n );\n // 模拟 10 个顾客来银行办理业务\n try {\n for (int i = 1; i <= 10; i++) {\n final int tempInt = i;\n threadPool.execute(() -> {\n System.out.println(Thread.currentThread().getName() + \"\\t\" + \"办理业务\" + tempInt);\n });\n }\n } catch (Exception e) {\n e.printStackTrace();\n } finally {\n threadPool.shutdown();\n }\n }\n}\n```"
+ },
+ {
+ "id": 142,
+ "question": "线程池的主要参数有哪些？",
+ "answer": "线程池有 7 个参数，需要重点关注的有核心线程数、最大线程数、等待队列、拒绝策略。\n\n\n\n**①、corePoolSize**：核心线程数，长期存活，执行任务的主力。\n\n**②、maximumPoolSize**：线程池允许的最大线程数。\n\n**③、workQueue**：任务队列，存储等待执行的任务。\n\n**④、handler**：拒绝策略，任务超载时的处理方式。也就是线程数达到 maximumPoolSiz，任务队列也满了的时候，就会触发拒绝策略。\n\n**⑤、threadFactory**：线程工厂，用于创建线程，可自定义线程名。\n\n**⑥、keepAliveTime**：非核心线程的存活时间，空闲时间超过该值就销毁。\n\n**⑦、unit**：keepAliveTime 参数的时间单位：\n\n* TimeUnit.DAYS; 天\n* TimeUnit.HOURS; 小时\n* TimeUnit.MINUTES; 分钟\n* TimeUnit.SECONDS; 秒\n* TimeUnit.MILLISECONDS; 毫秒\n* TimeUnit.MICROSECONDS; 微秒\n* TimeUnit.NANOSECONDS; 纳秒\n\n#### [能简单说一下参数之间的关系吗？](#能简单说一下参数之间的关系吗)\n\n一句话：任务优先使用核心线程执行，满了进入等待队列，队列满了启用非核心线程备用，线程池达到最大线程数量后触发拒绝策略，非核心线程的空闲时间超过存活时间就被回收。\n\n#### [核心线程数不够会怎么进行处理？](#核心线程数不够会怎么进行处理)\n\n当提交的任务数超过了 corePoolSize，但是小于 maximumPoolSize 时，线程池会创建新的线程来处理任务。\n\n当提交的任务数超过了 maximumPoolSize 时，线程池会根据拒绝策略来处理任务。\n\n#### [举个例子说一下这些参数的变化？](#举个例子说一下这些参数的变化)\n\n假设一个场景，线程池的配置如下：\n\n\n```java\ncorePoolSize = 5\nmaximumPoolSize = 10\nkeepAliveTime = 60秒\nworkQueue = LinkedBlockingQueue（容量为100）\nhandler = ThreadPoolExecutor.AbortPolicy()\n```\n\n\n**场景一**：当系统启动后，有 10 个任务提交到线程池。\n\n* 前 5 个任务会立即执行，因为核心线程数足够容纳它们。\n* 随后的 5 个任务会被放入等待队列。\n\n**场景二**：如果此时再有 100 个任务提交到线程池。\n\n* 工作队列已满，线程池会创建额外的线程来执行这些任务，直到线程总数达到 10。\n* 如果任务继续增加，超过了工作队列+最大线程数的限制，新来的任务会被 AbortPolicy 拒绝，抛出 RejectedExecutionException 异常。\n\n**场景三**：如果任务突然减少：\n\n核心线程会一直运行，而超出核心线程数的线程，会在 60 秒后回收。"
+ },
+ {
+ "id": 143,
+ "question": "线程池的拒绝策略有哪些？",
+ "answer": "有四种：\n\n* AbortPolicy：默认的拒绝策略，会抛 RejectedExecutionException 异常。\n* CallerRunsPolicy：让提交任务的线程自己来执行这个任务，也就是调用 execute 方法的线程。\n* DiscardOldestPolicy：等待队列会丢弃队列中最老的一个任务，也就是队列中等待最久的任务，然后尝试重新提交被拒绝的任务。\n* DiscardPolicy：丢弃被拒绝的任务，不做任何处理也不抛出异常。\n\n\n\n分别对应着小二去银行办理业务被经理“薄纱”的四个场景：“我们系统瘫痪了”、“谁叫你来办的你找谁去”、“看你比较急，去队里加个塞”、“今天没办法，不行你看改一天”。\n\n当线程池无法接受新的任务时，也就是线程数达到 maximumPoolSize，任务队列也满了的时候，就会触发拒绝策略。\n\n如果默认策略不能满足需求，可以通过实现 RejectedExecutionHandler 接口来定义自己的淘汰策略。例如：记录被拒绝任务的日志。\n\n\n```java\nclass CustomRejectedHandler {\n public static void main(String[] args) {\n // 自定义拒绝策略\n RejectedExecutionHandler rejectedHandler = (r, executor) -> {\n System.out.println(\"Task \" + r.toString() + \" rejected. Queue size: \" \n + executor.getQueue().size());\n };\n\n // 自定义线程池\n ThreadPoolExecutor executor = new ThreadPoolExecutor(\n 2, // 核心线程数\n 4, // 最大线程数\n 10, // 空闲线程存活时间\n TimeUnit.SECONDS,\n new ArrayBlockingQueue<>(2), // 阻塞队列容量\n Executors.defaultThreadFactory(),\n rejectedHandler // 自定义拒绝策略\n );\n\n for (int i = 0; i < 10; i++) {\n final int taskNumber = i;\n executor.execute(() -> {\n System.out.println(\"Executing task \" + taskNumber);\n try {\n Thread.sleep(1000); // 模拟任务耗时\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n });\n }\n\n executor.shutdown();\n }\n}\n```"
+ },
+ {
+ "id": 144,
+ "question": "线程池有哪几种阻塞队列？",
+ "answer": "常用的有五种，有界队列 ArrayBlockingQueue；无界队列 LinkedBlockingQueue；优先级队列 PriorityBlockingQueue；延迟队列 DelayQueue；同步队列 SynchronousQueue。\n\n\n\n①、ArrayBlockingQueue：一个有界的先进先出的阻塞队列，底层是一个数组，适合固定大小的线程池。\n\n\n```java\nArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(10, true);\n```\n\n\n②、LinkedBlockingQueue：底层是链表，如果不指定大小，默认大小是 Integer.MAX\\_VALUE，几乎相当于一个无界队列。\n\n中，就使用了 LinkedBlockingQueue 来配置 RabbitMQ 的消息队列。\n\n③、PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。任务按照其自然顺序或 Comparator 来排序。\n\n适用于需要按照给定优先级处理任务的场景，比如优先处理紧急任务。\n\n④、DelayQueue：类似于 PriorityBlockingQueue，由二叉堆实现的无界优先级阻塞队列。\n\nExecutors 中的 `newScheduledThreadPool()` 就使用了 DelayQueue 来实现延迟执行。\n\n\n```java\npublic ScheduledThreadPoolExecutor(int corePoolSize) {\n super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,\n new DelayedWorkQueue());\n}\n```\n\n\n⑤、SynchronousQueue：每个插入操作必须等待另一个线程的移除操作，同样，任何一个移除操作都必须等待另一个线程的插入操作。\n\n`Executors.newCachedThreadPool()` 就使用了 SynchronousQueue，这个线程池会根据需要创建新线程，如果有空闲线程则会重复使用，线程空闲 60 秒后会被回收。\n\n\n```java\npublic static ExecutorService newCachedThreadPool() {\n return new ThreadPoolExecutor(0, Integer.MAX_VALUE,\n 60L, TimeUnit.SECONDS,\n new SynchronousQueue());\n}\n```"
+ },
+ {
+ "id": 145,
+ "question": "线程池提交 execute 和 submit 有什么区别？",
+ "answer": "execute 方法没有返回值，适用于不关心结果和异常的简单任务。\n\n\n```java\nthreadsPool.execute(new Runnable() {\n @Override public void run() {\n System.out.println(\"execute() 方法提交的任务\");\n }\n});\n```\n\n\nsubmit 有返回值，适用于需要获取结果或处理异常的场景。\n\n\n```java\nFuture future = executor.submit(harReturnValuetask);\ntry { Object s = future.get(); } \ncatch (InterruptedException e | ExecutionException e) {\n // 处理无法执行任务异常\n} finally {\n // 关闭线程池 executor.shutdown();\n}\n```"
+ },
+ {
+ "id": 146,
+ "question": "线程池怎么关闭知道吗？",
+ "answer": "可以调用线程池的`shutdown`或`shutdownNow`方法来关闭线程池。\n\nshutdown 不会立即停止线程池，而是等待所有任务执行完毕后再关闭线程池。\n\n\n```java\nExecutorService executor = Executors.newFixedThreadPool(3);\nexecutor.execute(() -> System.out.println(\"Task 1\"));\nexecutor.execute(() -> System.out.println(\"Task 2\"));\n\nexecutor.shutdown(); // 不会立刻关闭，而是等待所有任务执行完毕\n```\n\n\nshutdownNow 会尝试通过一系列动作来停止线程池，包括停止接收外部提交的任务、忽略队列里等待的任务、尝试将正在跑的任务 interrupt 中断。\n\n\n```java\nExecutorService executor = Executors.newFixedThreadPool(3);\nexecutor.execute(() -> {\n try {\n Thread.sleep(5000); // 模拟长时间运行任务\n System.out.println(\"Task executed\");\n } catch (InterruptedException e) {\n System.out.println(\"任务被中断\");\n }\n});\n\nList unexecutedTasks = executor.shutdownNow(); // 立即关闭线程池\nSystem.out.println(\"未执行的任务数: \" + unexecutedTasks.size());\n```\n\n\n需要注意的是，shutdownNow 不会真正终止正在运行的任务，只是给任务线程发送 interrupt 信号，任务是否能真正终止取决于线程是否响应 InterruptedException。"
+ },
+ {
+ "id": 147,
+ "question": "线程池的线程数应该怎么配置？",
+ "answer": "首先，我会分析线程池中执行的任务类型是 CPU 密集型还是 IO 密集型？\n\n①、对于 CPU 密集型任务，我的目标是尽量减少线程上下文切换，以优化 CPU 使用率。一般来说，核心线程数设置为处理器的核心数或核心数加一是较理想的选择。\n\n> +1 是为了以备不时之需，如果某线程因等待系统资源而阻塞时，可以有多余的线程顶上去，不至于影响整体性能。\n\n②、对于 IO 密集型任务，由于线程经常处于等待状态，等待 IO 操作完成，所以可以设置更多的线程来提高并发，比如说 CPU 核心数的两倍。\n\n\n> 核心数可以通过 Java 的`Runtime.getRuntime().availableProcessors()`方法获取。\n\n最后，我会根据业务需求和系统资源来调整线程池的其他参数，比如最大线程数、任务队列容量、非核心线程的空闲存活时间等。\n\n\n```java\nThreadPoolExecutor executor = new ThreadPoolExecutor(\n cores, // 核心线程数设置为CPU核心数\n cores * 2, // 最大线程数为核心数的两倍\n 60L, TimeUnit.SECONDS, // 非核心线程的空闲存活时间\n new LinkedBlockingQueue<>(100) // 任务队列容量\n);\n```\n\n\n#### [如何知道你设置的线程数多了还是少了？](#如何知道你设置的线程数多了还是少了)\n\n可以通过监控和调试来判断线程数是多还是少。\n\n比如说通过 top 命令观察 CPU 的使用率，如果 CPU 使用率较低，可能是线程数过少；如果 CPU 使用率接近 100%，但吞吐量未提升，可能是线程数过多。\n\n然后再通过 VisualVM 或 Arthas 分析线程运行情况，查看线程的状态、等待时间、运行时间等信息。\n\n也可以使用 jstack 命令查看线程堆栈信息，查看线程是否处于阻塞状态。\n\n\n```java\njstack | grep -A 20 \"BLOCKED\" // 查看阻塞线程\n```\n\n\n如果有大量的 BLOCKED 线程，说明线程数可能过多，竞争比较激烈。"
+ },
+ {
+ "id": 148,
+ "question": "有哪几种常见的线程池？",
+ "answer": "主要有四种：\n\n固定大小的线程池 `Executors.newFixedThreadPool(int nThreads);`，适合用于任务数量确定，且对线程数有明确要求的场景。例如，IO 密集型任务、数据库连接池等。\n\n缓存线程池 `Executors.newCachedThreadPool();`，适用于短时间内任务量波动较大的场景。例如，短时间内有大量的文件处理任务或网络请求。\n\n定时任务线程池 `Executors.newScheduledThreadPool(int corePoolSize);`，适用于需要定时执行任务的场景。例如，定时发送邮件、定时备份数据等。\n\n单线程线程池 `Executors.newSingleThreadExecutor();`，适用于需要按顺序执行任务的场景。例如，日志记录、文件处理等。"
+ },
+ {
+ "id": 149,
+ "question": "能说一下四种常见线程池的原理吗？",
+ "answer": "不管是 FixedThreadPool、CachedThreadPool，还是 SingleThreadExecutor 和 ScheduledThreadPoolExecutor，它们本质上都是 ThreadPoolExecutor 的不同配置。\n\n#### [说说固定大小线程池的原理？](#说说固定大小线程池的原理)\n\n线程池大小是固定的，`corePoolSize == maximumPoolSize`，默认使用 LinkedBlockingQueue 作为阻塞队列，适用于任务量稳定的场景，如数据库连接池、RPC 处理等。\n\n\n```java\nnew ThreadPoolExecutor(4, 4, 0L, TimeUnit.MILLISECONDS,\n new LinkedBlockingQueue<>());\n```\n\n\n新任务提交时，如果线程池有空闲线程，直接执行；如果没有，任务进入 LinkedBlockingQueue 等待。缺点是任务队列默认无界，可能导致任务堆积，甚至 OOM。\n\n\n\n#### [说说缓存线程池的原理？](#说说缓存线程池的原理)\n\n线程池大小不固定，`corePoolSize = 0`，`maximumPoolSize = Integer.MAX_VALUE`。空闲线程超过 60 秒会被销毁，使用 SynchronousQueue 作为阻塞队列，适用于短时间内有大量任务的场景。\n\n\n```java\nnew ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,\n new SynchronousQueue<>());\n```\n\n\n提交任务时，如果线程池没有空闲线程，直接新建线程执行任务；如果有，复用线程执行任务。线程空闲 60 秒后销毁，减少资源占用。缺点是线程数没有上限，在高并发情况下可能导致 OOM。\n\n\n\n#### [说说单线程线程池的原理？](#说说单线程线程池的原理)\n\n线程池只有 1 个线程，保证任务按提交顺序执行，使用 LinkedBlockingQueue 作为阻塞队列，适用于需要按顺序执行任务的场景。\n\n\n```java\nnew ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,\n new LinkedBlockingQueue<>());\n```\n\n\n始终只创建 1 个线程，新任务必须等待前一个任务完成后才能执行，其他任务都被放入 LinkedBlockingQueue 排队执行。缺点是无法并行处理任务。\n\n\n\n#### [说说定时任务线程池的原理？](#说说定时任务线程池的原理)\n\n定时任务线程池的大小可配置，支持定时 & 周期性任务执行，使用 DelayedWorkQueue 作为阻塞队列，适用于周期性执行任务的场景。\n\n\n```java\npublic ScheduledThreadPoolExecutor(int corePoolSize) {\n super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,\n new DelayedWorkQueue());\n}\n```\n\n\n执行定时任务时，`schedule()` 方法可以将任务延迟一定时间后执行一次；`scheduleAtFixedRate()` 方法可以将任务延迟一定时间后以固定频率执行；`scheduleWithFixedDelay()` 方法可以将任务延迟一定时间后以固定延迟执行。\n\n\n\n缺点是，如果任务执行时间 `>` 设定时间间隔，scheduleAtFixedRate 可能会导致任务堆积。\n\n\n\n#### [使用无界队列的线程池会出现什么问题？](#使用无界队列的线程池会出现什么问题)\n\n如果线程获取一个任务后，任务的执行时间比较长，会导致队列的任务越积越多，导致内存使用不断飙升，最终出现 OOM。"
+ },
+ {
+ "id": 150,
+ "question": "线程池异常怎么处理知道吗？",
+ "answer": "常见的处理方式有，使用 try-catch 捕获、使用 Future 获取异常、自定义ThreadPoolExecutor 重写 afterExecute 方法、使用 UncaughtExceptionHandler 捕获异常。\n\n\n\n①、try-catch 是最简单的方法。\n\n\n```java\nexecutor.execute(() -> {\n try {\n System.out.println(\"任务开始\");\n int result = 1 / 0; // 除零异常\n } catch (Exception e) {\n System.err.println(\"捕获异常：\" + e.getMessage());\n }\n});\n```\n\n\n②、使用 Future 获取异常。\n\n\n```java\nFuture future = executor.submit(() -> {\n System.out.println(\"任务开始\");\n int result = 1 / 0; // 除零异常\n return result;\n});\n\ntry {\n future.get();\n} catch (InterruptedException | ExecutionException e) {\n System.err.println(\"捕获异常：\" + e.getMessage());\n}\n```\n\n\n③、自定义 ThreadPoolExecutor 重写 afterExecute 方法。\n\n\n```java\nThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS,\n new LinkedBlockingQueue()) {\n @Override\n protected void afterExecute(Runnable r, Throwable t) {\n super.afterExecute(r, t);\n if (t != null) {\n System.err.println(\"捕获异常：\" + t.getMessage());\n }\n }\n};\n\nexecutor.execute(() -> {\n System.out.println(\"任务开始\");\n int result = 1 / 0; // 除零异常\n});\n```\n\n\n④、使用 UncaughtExceptionHandler 捕获异常。\n\n\n```java\nThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS,\n new LinkedBlockingQueue());\nexecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());\nexecutor.setThreadFactory(new ThreadFactory() {\n @Override\n public Thread newThread(Runnable r) {\n Thread thread = new Thread(r);\n thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {\n @Override\n public void uncaughtException(Thread t, Throwable e) {\n System.err.println(\"捕获异常：\" + e.getMessage());\n }\n });\n return thread;\n }\n});\n\nexecutor.execute(() -> {\n System.out.println(\"任务开始\");\n int result = 1 / 0; // 除零异常\n});\n```\n\n\n如果项目使用 `execute()`，不关心任务返回值，建议使用 UncaughtExceptionHandler：\n\n\n```java\nthread.setUncaughtExceptionHandler((t, e) -> \n System.err.println(\"线程 \" + t.getName() + \" 捕获到异常：\" + e.getMessage()));\n```\n\n\n如果项目使用 `submit()`，关心任务返回值，建议使用 Future：\n\n\n```java\nFuture future = executor.submit(task);\ntry {\n future.get();\n} catch (ExecutionException e) {\n System.err.println(\"捕获异常：\" + e.getCause());\n}\n```\n\n\n如果想要全局捕获所有任务异常，建议重写 afterExecute 方法：\n\n\n```java\nclass MyThreadPoolExecutor extends ThreadPoolExecutor {\n @Override\n protected void afterExecute(Runnable r, Throwable t) {\n if (t == null && r instanceof Future) {\n try { ((Future) r).get(); } catch (Exception e) { System.err.println(\"任务异常：\" + e.getCause()); }\n }\n }\n}\n```"
+ },
+ {
+ "id": 151,
+ "question": "能说一下线程池有几种状态吗？",
+ "answer": "有 5 种状态，它们的转换遵循严格的状态流转规则，不同状态控制着线程池的任务调度和关闭行为。\n\n状态由 RUNNING → SHUTDOWN → STOP → TIDYING → TERMINATED 依次流转。\n\n\n\n**RUNNING** 状态的线程池可以接收新任务，并处理阻塞队列中的任务；**SHUTDOWN** 状态的线程池不会接收新任务，但会处理阻塞队列中的任务；**STOP** 状态的线程池不会接收新任务，也不会处理阻塞队列中的任务，并且会尝试中断正在执行的任务；**TIDYING** 状态表示所有任务已经终止；**TERMINATED** 状态表示线程池完全关闭，所有线程销毁。\n\n| 状态 | 状态码 | 是否接收新任务 | 是否执行队列中的任务 | 是否中断正在执行的任务 |\n| --- | --- | --- | --- | --- |\n| RUNNING | 111 | ✅ 是 | ✅ 是 | ❌ 否 |\n| SHUTDOWN | 000 | ❌ 否 | ✅ 是 | ❌ 否 |\n| STOP | 001 | ❌ 否 | ❌ 否 | ✅ 是 |\n| TIDYING | 010 | ❌ 否 | ❌ 否 | ❌ 否 |\n| TERMINATED | 011 | ❌ 否 | ❌ 否 | ❌ 否 |"
+ },
+ {
+ "id": 152,
+ "question": "线程池如何实现参数的动态修改？",
+ "answer": "线程池提供的 setter 方法就可以在运行时动态修改参数，比如说 setCorePoolSize 可以用来修改核心线程数、setMaximumPoolSize 可以用来修改最大线程数。\n\n\n\n需要注意的是，调用 `setCorePoolSize()` 时如果新的核心线程数比原来的大，线程池会创建新的线程；如果更小，线程池不会立即销毁多余的线程，除非有空闲线程超过 keepAliveTime。\n\n当然了，还可以利用 Nacos 配置中心，或者实现自定义的线程池，监听参数变化去动态调整参数。\n\n"
+ },
+ {
+ "id": 153,
+ "question": "线程池调优了解吗？（补充）",
+ "answer": "\n\n首先我会根据任务类型设置核心线程数参数，比如 IO 密集型任务会设置为 CPU 核心数\\*2 的经验值。\n\n其次我会结合线程池动态调整的能力，在流量波动时通过 setCorePoolSize 平滑扩容，或者直接使用 DynamicTp 实现线程池参数的自动化调整。\n\n最后，我会通过内置的监控指标建立容量预警机制。比如通过 JMX 监控线程池的运行状态，设置阈值，当线程池的任务队列长度超过阈值时，触发告警。"
+ },
+ {
+ "id": 154,
+ "question": "线程池在使用的时候需要注意什么？（补充）",
+ "answer": "> 2024 年 03 月 16 日增补\n\n我认为有 3 个比较重要的关注点：\n\n第一个，选择合适的线程池大小。**过小**的线程池可能会导致任务一直在排队；**过大**的线程池可能会导致大家都在竞争 CPU 资源，增加上下文切换的开销\n\n第二个，选择合适的任务队列。使用有界队列可以避免资源耗尽的风险，但是可能会导致任务被拒绝；使用无界队列虽然可以避免任务被拒绝，但是可能会导致内存耗尽\n\n比如在使用 LinkedBlockingQueue 的时候，可以传入参数来限制队列中任务的数量，这样就不会出现 OOM。\n\n第三个，尽量使用自定义的线程池，而不是使用 Executors 创建的线程池。\n\n因为 newFixedThreadPool 线程池由于使用了 LinkedBlockingQueue，队列的容量默认无限大，任务过多时会导致内存溢出；newCachedThreadPool 线程池由于核心线程数无限大，当任务过多的时候会导致创建大量的线程，导致服务器负载过高宕机。"
+ },
+ {
+ "id": 155,
+ "question": "你能设计实现一个线程池吗？",
+ "answer": "线程池的主要目的是为了避免频繁地创建和销毁线程。\n\n\n\n我会把线程池看作一个工厂，里面有一群“工人”，也就是线程了，专门用来做任务。\n\n当任务来了，需要先判断有没有空闲的工人，如果有就把任务交给他们；如果没有，就把任务暂存到一个任务队列里，等工人忙完了再去处理。\n\n如果队列满了，还没有空闲的工人，就要考虑扩容，让预备的工人过来干活，但不能超过预定的最大值，防止工厂被挤爆。\n\n如果连扩容也没法解决，就需要一个拒绝策略，可能直接拒绝任务或者报个错。\n\n核心线程池类（可参考）：\n\n\n```java\nclass CustomThreadPoolExecutor {\n\n private final int corePoolSize;\n private final int maximumPoolSize;\n private final long keepAliveTime;\n private final TimeUnit unit;\n private final BlockingQueue workQueue;\n private final RejectedExecutionHandler handler;\n\n private volatile boolean isShutdown = false;\n private int currentPoolSize = 0;\n\n // 构造方法\n public CustomThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,\n BlockingQueue workQueue, RejectedExecutionHandler handler) {\n this.corePoolSize = corePoolSize;\n this.maximumPoolSize = maximumPoolSize;\n this.keepAliveTime = keepAliveTime;\n this.unit = unit;\n this.workQueue = workQueue;\n this.handler = handler;\n }\n\n // 提交任务\n public void execute(Runnable task) {\n if (isShutdown) {\n throw new IllegalStateException(\"ThreadPool is shutdown\");\n }\n\n synchronized (this) {\n // 如果当前线程数小于核心线程数，直接创建新线程\n if (currentPoolSize < corePoolSize) {\n new Worker(task).start();\n currentPoolSize++;\n return;\n }\n\n // 尝试将任务添加到队列中\n if (!workQueue.offer(task)) {\n if (currentPoolSize < maximumPoolSize) {\n new Worker(task).start();\n currentPoolSize++;\n } else {\n // 调用拒绝策略\n handler.rejectedExecution(task, null);\n }\n }\n }\n }\n\n // 关闭线程池\n public void shutdown() {\n isShutdown = true;\n }\n\n // 工作线程\n private class Worker extends Thread {\n private Runnable task;\n\n Worker(Runnable task) {\n this.task = task;\n }\n\n @Override\n public void run() {\n while (task != null || (task = getTask()) != null) {\n try {\n task.run();\n } finally {\n task = null;\n }\n }\n }\n\n // 从队列中获取任务\n private Runnable getTask() {\n try {\n return workQueue.poll(keepAliveTime, unit);\n } catch (InterruptedException e) {\n return null;\n }\n }\n }\n}\n```\n\n\n拒绝策略：\n\n\n```java\n/**\n * 拒绝策略\n */\nclass CustomRejectedExecutionHandler {\n\n // AbortPolicy 抛出异常\n public static class AbortPolicy implements RejectedExecutionHandler {\n public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {\n throw new RuntimeException(\"Task \" + r.toString() + \" rejected from \" + e.toString());\n }\n }\n\n // DiscardPolicy 什么都不做\n public static class DiscardPolicy implements RejectedExecutionHandler {\n public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {\n // Do nothing\n }\n }\n\n // DiscardOldestPolicy 丢弃队列中最旧的任务\n public static class CallerRunsPolicy implements RejectedExecutionHandler {\n public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {\n if (!e.isShutdown()) {\n r.run();\n }\n }\n }\n}\n```\n\n\n使用示例：\n\n\n```java\nclass ThreadPoolTest {\n public static void main(String[] args) {\n // 创建线程池\n CustomThreadPoolExecutor executor = new CustomThreadPoolExecutor(\n 2, 4, 10, TimeUnit.SECONDS,\n new LinkedBlockingQueue<>(2),\n new CustomRejectedExecutionHandler.AbortPolicy());\n\n // 提交任务\n for (int i = 0; i < 10; i++) {\n final int index = i;\n executor.execute(() -> {\n System.out.println(\"Task \" + index + \" is running\");\n try {\n Thread.sleep(2000);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n });\n }\n\n // 关闭线程池\n executor.shutdown();\n }\n}\n```\n\n\n执行结果：\n\n\n\n#### [手写一个数据库连接池，可以吗？](#手写一个数据库连接池-可以吗)\n\n可以的，我的思路是这样的：数据库连接池主要是为了避免每次操作数据库时都去创建连接，因为那样很浪费资源。所以我打算在初始化时预先创建好固定数量的连接，然后把它们放到一个线程安全的容器里，后续有请求的时候就从队列里拿，使用完后再归还到队列中。\n\n\n```java\nclass SimpleConnectionPool {\n // 配置\n private String jdbcUrl;\n private String username;\n private String password;\n private int maxConnections;\n private BlockingQueue connectionPool;\n\n // 构造方法\n public SimpleConnectionPool(String jdbcUrl, String username, String password, int maxConnections) throws SQLException {\n this.jdbcUrl = jdbcUrl;\n this.username = username;\n this.password = password;\n this.maxConnections = maxConnections;\n this.connectionPool = new LinkedBlockingQueue<>(maxConnections);\n\n // 初始化连接池\n for (int i = 0; i < maxConnections; i++) {\n connectionPool.add(createNewConnection());\n }\n }\n\n // 创建新连接\n private Connection createNewConnection() throws SQLException {\n return DriverManager.getConnection(jdbcUrl, username, password);\n }\n\n // 获取连接\n public Connection getConnection(long timeout, TimeUnit unit) throws InterruptedException, SQLException {\n Connection connection = connectionPool.poll(timeout, unit); // 等待指定时间获取连接\n if (connection == null) {\n throw new SQLException(\"Timeout: Unable to acquire a connection.\");\n }\n return connection;\n }\n\n // 归还连接\n public void releaseConnection(Connection connection) throws SQLException {\n if (connection != null) {\n if (connection.isClosed()) {\n // 如果连接已关闭，创建一个新连接补充到池中\n connectionPool.add(createNewConnection());\n } else {\n // 将连接归还到池中\n connectionPool.offer(connection);\n }\n }\n }\n\n // 关闭所有连接\n public void closeAllConnections() throws SQLException {\n for (Connection connection : connectionPool) {\n if (!connection.isClosed()) {\n connection.close();\n }\n }\n }\n\n // 测试用例\n public static void main(String[] args) {\n try {\n SimpleConnectionPool pool = new SimpleConnectionPool(\n \"jdbc:mysql://localhost:3306/pai_coding\", \"root\", \"\", 5\n );\n\n // 获取连接\n Connection conn = pool.getConnection(5, TimeUnit.SECONDS);\n\n // 使用连接（示例查询）\n System.out.println(\"Connection acquired: \" + conn);\n Thread.sleep(2000); // 模拟查询\n\n // 归还连接\n pool.releaseConnection(conn);\n System.out.println(\"Connection returned.\");\n\n // 关闭所有连接\n pool.closeAllConnections();\n } catch (Exception e) {\n e.printStackTrace();\n }\n }\n}\n```\n\n\n运行结果：\n\n"
+ },
+ {
+ "id": 156,
+ "question": "线程池执行中断电了应该怎么处理？",
+ "answer": "线程池本身只能在内存中进行任务调度，并不会持久化，一旦断电，线程池里的所有任务和状态都会丢失。\n\n我会考虑以下几个方面：\n\n第一，持久化任务。可以将任务持久化到数据库或者消息队列中，等电恢复后再重新执行。\n\n第二，任务幂等性，需要保证任务是幂等的，也就是无论执行多少次，结果都一致。\n\n第三，恢复策略。当系统重启时，应该有一个恢复流程：检测上次是否有未完成的任务，将这些任务重新加载到线程池中执行，确保断电前的工作能够恢复。"
+ }
+ ]
+ },
+ {
+ "id": 25,
+ "categoryName": "并发容器和框架",
+ "questions": [
+ {
+ "id": 157,
+ "question": "Fork/Join 框架了解吗？",
+ "answer": "关于 Fork/Join 框架，我了解一些，它是 Java 7 引入的一个并行框架，主要用于分治算法的并行执行。这个框架通过将大的任务递归地分解成小任务，然后并行执行，最后再合并结果，以达到最高效率处理大量数据的目的。\n\n\n\nFork/Join 框架的核心理念是**分而治之**，将大任务拆分为多个小任务并行处理，最后再将这些小任务的结果汇总。\n\n就像是一个树形结构，根节点是一个大的任务，叶子节点是最小的子任务，每个任务都可能会被分裂成更小的子任务，直到达到某个临界点，任务再逐个执行。\n\n具体来说，Fork/Join 包括两个主要的类：\n\nForkJoinPool，一个特殊的线程池，底层使用了工作窃取算法，也就是当一个线程执行完自己的任务后，它可以窃取其他线程的任务，避免线程闲置。\n\n\n\nRecursiveTask 和 RecursiveAction，分别用于有返回值和无返回值的任务，这两个类都继承自 ForkJoinTask。\n\n\n```java\nclass ForkJoinExample {\n public static void main(String[] args) {\n int[] arr = new int[100];\n for (int i = 0; i < 100; i++) {\n arr[i] = i + 1; // 填充数据 1 到 100\n }\n\n // 创建 ForkJoinPool，默认使用可用的处理器核心数\n ForkJoinPool pool = new ForkJoinPool();\n\n // 创建 ForkJoin 任务\n SumTask task = new SumTask(arr, 0, arr.length);\n\n // 执行任务\n Integer result = pool.invoke(task);\n\n System.out.println(\"数组的和是: \" + result);\n }\n\n // 自定义任务，继承 RecursiveTask\n static class SumTask extends RecursiveTask {\n private int[] arr;\n private int start;\n private int end;\n\n public SumTask(int[] arr, int start, int end) {\n this.arr = arr;\n this.start = start;\n this.end = end;\n }\n\n @Override\n protected Integer compute() {\n if (end - start <= 10) { // 如果任务足够小，就直接计算\n int sum = 0;\n for (int i = start; i < end; i++) {\n sum += arr[i];\n }\n return sum;\n } else {\n // 否则拆分任务\n int mid = (start + end) / 2;\n SumTask left = new SumTask(arr, start, mid);\n SumTask right = new SumTask(arr, mid, end);\n\n // 分别执行子任务\n left.fork();\n right.fork();\n\n // 合并结果\n int leftResult = left.join();\n int rightResult = right.join();\n\n return leftResult + rightResult; // 汇总结果\n }\n }\n }\n}\n```"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 4,
+ "topicName": "JVM",
+ "categories": [
+ {
+ "id": 26,
+ "categoryName": "引言",
+ "questions": [
+ {
+ "id": 158,
+ "question": "什么是 JVM?",
+ "answer": "JVM，也就是 Java 虚拟机，它是 Java 实现跨平台的基石。\n\n程序运行之前，需要先通过编译器将 Java 源代码文件编译成 Java 字节码文件；\n\n程序运行时，JVM 会对字节码文件进行逐行解释，翻译成机器码指令，并交给对应的操作系统去执行。\n\n\n\n这样就实现了 Java 一次编译，处处运行的特性。\n\n#### [说说 JVM 的其他特性？](#说说-jvm-的其他特性)\n\n①、JVM 可以自动管理内存，通过垃圾回收器回收不再使用的对象并释放内存空间。\n\n②、JVM 包含一个即时编译器 JIT，它可以在运行时将热点代码缓存到 codeCache 中，下次执行的时候不用再一行一行的解释，而是直接执行缓存后的机器码，执行效率会大幅提高。\n\n\n\n③、任何可以通过 Java 编译的语言，比如说 Groovy、Kotlin、Scala 等，都可以在 JVM 上运行。\n\n\n\n#### [为什么要学习 JVM？](#为什么要学习-jvm)\n\n学习 JVM 可以帮助我们开发者更好地优化程序性能、避免内存问题。\n\n比如说了解 JVM 的内存模型和垃圾回收机制，可以帮助我们更合理地配置内存、减少 GC 停顿。\n\n比如说掌握 JVM 的类加载机制可以帮助我们排查类加载冲突或异常。\n\n再比如说，JVM 还提供了很多调试和监控工具，可以帮助我们分析内存和线程的使用情况，从而解决内存溢出内存泄露等问题。"
+ },
+ {
+ "id": 159,
+ "question": "说说 JVM 的组织架构（补充）",
+ "answer": "> 增补于 2024 年 03 月 08 日。\n\nJVM 大致可以划分为三个部分：类加载器、运行时数据区和执行引擎。\n\n\n\n① 类加载器，负责从文件系统、网络或其他来源加载 Class 文件，将 Class 文件中的二进制数据读入到内存当中。\n\n② 运行时数据区，JVM 在执行 Java 程序时，需要在内存中分配空间来处理各种数据，这些内存区域按照 Java 虚拟机规范可以划分为方法区、堆、虚拟机栈、程序计数器和本地方法栈。\n\n③ 执行引擎，也是 JVM 的心脏，负责执行字节码。它包括一个虚拟处理器、即时编译器 JIT 和垃圾回收器。"
+ }
+ ]
+ },
+ {
+ "id": 27,
+ "categoryName": "内存管理",
+ "questions": [
+ {
+ "id": 160,
+ "question": "能说一下 JVM 的内存区域吗？",
+ "answer": "按照 Java 虚拟机规范，JVM 的内存区域可以细分为`程序计数器`、`虚拟机栈`、`本地方法栈`、`堆`和`方法区`。\n\n\n\n其中`方法区`和`堆`是线程共享的，`虚拟机栈`、`本地方法栈`和`程序计数器`是线程私有的。\n\n#### [介绍一下程序计数器？](#介绍一下程序计数器)\n\n程序计数器也被称为 PC 寄存器，是一块较小的内存空间。它可以看作是当前线程所执行的字节码行号指示器。\n\n#### [介绍一下 Java 虚拟机栈？](#介绍一下-java-虚拟机栈)\n\nJava 虚拟机栈的生命周期与线程相同。\n\n当线程执行一个方法时，会创建一个对应的，用于存储局部变量表、操作数栈、动态链接、方法出口等信息，然后栈帧会被压入虚拟机栈中。当方法执行完毕后，栈帧会从虚拟机栈中移除。\n\n\n\n#### [一个什么都没有的空方法，空的参数都没有，那局部变量表里有没有变量？](#一个什么都没有的空方法-空的参数都没有-那局部变量表里有没有变量)\n\n对于，由于不需要访问实例对象 this，因此在局部变量表中不会有任何变量。\n\n对于非静态方法，即使是一个完全空的方法，局部变量表中也会有一个用于存储 this 引用的变量。this 引用指向当前实例对象，在方法调用时被隐式传入。\n\n详细解释一下：\n\n比如说有这样一段代码：\n\n\n```java\npublic class VarDemo1 {\n public void emptyMethod() {\n // 什么都没有\n }\n\n public static void staticEmptyMethod() {\n // 什么都没有\n }\n}\n```\n\n\n用 `javap -v VarDemo1` 命令查看编译后的字节码，就可以在 emptyMethod 中看到这样的内容：\n\n\n\n这里的 `locals=1` 表示局部变量表有一个变量，即 this，Slot 0 位置存储了 this 引用。\n\n而在静态方法 staticEmptyMethod 中，你会看到这样的内容：\n\n\n\n这里的 locals=0 表示局部变量表为空，因为静态方法属于类级别方法，不需要 this 引用，也就没有局部变量。\n\n#### [介绍一下本地方法栈？](#介绍一下本地方法栈)\n\n本地方法栈与虚拟机栈相似，区别在于虚拟机栈是为 JVM 执行 Java 编写的方法服务的，而本地方法栈是为 Java 调用服务的，通常由 C/C++ 编写。\n\n在本地方法栈中，主要存放了 native 方法的局部变量、动态链接和方法出口等信息。当一个 Java 程序调用一个 native 方法时，JVM 会切换到本地方法栈来执行这个方法。\n\n#### [介绍一下本地方法栈的运行场景？](#介绍一下本地方法栈的运行场景)\n\n当 Java 应用需要与操作系统底层或硬件交互时，通常会用到本地方法栈。\n\n比如调用操作系统的特定功能，如内存管理、文件操作、系统时间、系统调用等。\n\n详细说明一下：\n\n比如说获取系统时间的 `System.currentTimeMillis()` 方法就是调用本地方法，来获取操作系统当前时间的。\n\n\n\n再比如 JVM 自身的一些底层功能也需要通过本地方法来实现。像 Object 类中的 `hashCode()` 方法、`clone()` 方法等。\n\n\n\n#### [native 方法解释一下？](#native-方法解释一下)\n\nnative 方法是在 Java 中通过 声明的，用于调用非 Java 语言，如 C/C++ 编写的代码。Java 可以通过 JNI，也就是 Java Native Interface 与底层系统、硬件设备、或者本地库进行交互。\n\n#### [介绍一下 Java 堆？](#介绍一下-java-堆)\n\n堆是 JVM 中最大的一块内存区域，被所有线程共享，在 JVM 启动时创建，主要用来存储 new 出来的对象。\n\n\n\nJava 中“几乎”所有的对象都会在堆中分配，堆也是管理的目标区域。\n\n从内存回收的角度来看，由于垃圾收集器大部分都是基于分代收集理论设计的，所以堆又被细分为`新生代`、`老年代`、`Eden空间`、`From Survivor空间`、`To Survivor空间`等。\n\n\n\n随着 的发展和逃逸技术的逐渐成熟，“所有的对象都会分配到堆上”就不再那么绝对了。\n\n从 JDK 7 开始，JVM 默认开启了逃逸分析，意味着如果某些方法中的对象引用没有被返回或者没有在方法体外使用，也就是未逃逸出去，那么对象可以直接在栈上分配内存。\n\n#### [堆和栈的区别是什么？](#堆和栈的区别是什么)\n\n堆属于线程共享的内存区域，几乎所有 new 出来的对象都会堆上分配，生命周期不由单个方法调用所决定，可以在方法调用结束后继续存在，直到不再被任何变量引用，最后被垃圾收集器回收。\n\n栈属于线程私有的内存区域，主要存储局部变量、方法参数、对象引用等，通常随着方法调用的结束而自动释放，不需要垃圾收集器处理。\n\n#### [介绍一下方法区？](#介绍一下方法区)\n\n方法区并不真实存在，属于 Java 虚拟机规范中的一个逻辑概念，用于存储已被 JVM 加载的类信息、常量、静态变量、即时编译器编译后的代码缓存等。\n\n在 HotSpot 虚拟机中，方法区的实现称为永久代 PermGen，但在 Java 8 及之后的版本中，已经被元空间 Metaspace 所替代。\n\n#### [变量存在堆栈的什么位置？](#变量存在堆栈的什么位置)\n\n对于局部变量，它存储在当前方法栈帧中的局部变量表中。当方法执行完毕，栈帧被回收，局部变量也会被释放。\n\n\n```java\npublic void method() {\n int localVar = 100; // 局部变量，存储在栈帧中的局部变量表里\n}\n```\n\n\n对于静态变量来说，它存储在 Java 虚拟机规范中的方法区中，在 Java 7 中是永久带，在 Java8 及以后 是元空间。\n\n\n```java\npublic class StaticVarDemo {\n public static int staticVar = 100; // 静态变量，存储在方法区中\n}\n```"
+ },
+ {
+ "id": 161,
+ "question": "说一下 JDK 1.6、1.7、1.8 内存区域的变化？",
+ "answer": "JDK 1.6 使用永久代来实现方法区：\n\n\n\nJDK 1.7 时仍然是永久带，但发生了一些细微变化，比如将字符串常量池、静态变量存放到了堆上。\n\n\n\n在 JDK 1.8 时，直接在内存中划出了一块区域，叫**元空间**，来取代之前放在 JVM 内存中的永久代，并将运行时常量池、类常量池都移动到了元空间。\n\n"
+ },
+ {
+ "id": 162,
+ "question": "为什么使用元空间替代永久代？",
+ "answer": "客观上，永久代会导致 Java 应用程序更容易出现内存溢出的问题，因为它要受到 JVM 内存大小的限制。\n\nHotSpot 虚拟机的永久代大小可以通过 `-XX：MaxPermSize` 参数来设置，32 位机器默认的大小为 64M，64 位的机器则为 85M。\n\n而 J9 和 JRockit 虚拟机就不存在这种限制，只要没有触碰到进程可用的内存上限，例如 32 位系统中的 4GB 限制，就不会出问题。\n\n主观上，当 Oracle 收购 BEA 获得了 JRockit 的所有权后，就准备把 JRockit 中的优秀功能移植到 HotSpot 中。\n\n如 Java Mission Control 管理工具。\n\n但因为两个虚拟机对方法区实现有差异，导致这项工作遇到了很多阻力。\n\n考虑到 HotSpot 虚拟机未来的发展，JDK 6 的时候，开发团队就打算放弃永久代了。\n\nJDK 7 的时候，前进了一小步，把原本放在永久代的字符串常量池、静态变量等移动到了堆中。\n\nJDK 8 就终于完成了这项移出工作，这样的好处就是，元空间的大小不再受到 JVM 内存的限制，而是可以像 J9 和 JRockit 那样，只要系统内存足够，就可以一直用。"
+ },
+ {
+ "id": 163,
+ "question": "对象创建的过程了解吗？",
+ "answer": "当我们使用 new 关键字创建一个对象时，JVM 首先会检查 new 指令的参数是否能在常量池中定位到类的符号引用，然后检查这个符号引用代表的类是否已被加载、解析和初始化。如果没有，就先执行类加载。\n\n\n\n如果已经加载，JVM 会为对象分配内存完成初始化，比如数值类型的成员变量初始值是 0，布尔类型是 false，对象类型是 null。\n\n接下来会设置对象头，里面包含了对象是哪个类的实例、对象的哈希码、对象的 GC 分代年龄等信息。\n\n最后，JVM 会执行构造方法 `` 完成赋值操作，将成员变量赋值为预期的值，比如 `int age = 18`，这样一个对象就创建完成了。\n\n#### [对象的销毁过程了解吗？](#对象的销毁过程了解吗)\n\n当对象不再被任何引用指向时，就会变成垃圾。垃圾收集器会通过可达性分析算法判断对象是否存活，如果对象不可达，就会被回收。\n\n垃圾收集器通过标记清除、标记复制、标记整理等算法来回收内存，将对象占用的内存空间释放出来。\n\n可以通过 `java -XX:+PrintCommandLineFlags -version` 和 `java -XX:+PrintGCDetails -version` 命令查看 JVM 的 GC 收集器。\n\n\n\n可以看到，我本机安装的 JDK 8 默认使用的是 `Parallel Scavenge + Parallel Old`。\n\n不同参数代表对应的垃圾收集器表单：\n\n| 新生代 | 老年代 | JVM参数 |\n| --- | --- | --- |\n| Serial | Serial | -XX:+UseSerialGC |\n| Parallel Scavenge | Serial | -XX:+UseParallelGC -XX:-UseParallelOldGC |\n| Parallel Scavenge | Parallel Old | -XX:+UseParallelGC -XX:+UseParallelOldGC |\n| Parallel New | CMS | -XX:+UseParNewGC -XX:+UseConcMarkSweepGC |\n| G1 | | -XX:+UseG1GC |"
+ },
+ {
+ "id": 164,
+ "question": "堆内存是如何分配的？",
+ "answer": "在堆中为对象分配内存时，主要使用两种策略：指针碰撞和空闲列表。\n\n\n\n指针碰撞适用于管理简单、碎片化较少的内存区域，如年轻代；而空闲列表适用于内存碎片化较严重或对象大小差异较大的场景如老年代。\n\n#### [什么是指针碰撞？](#什么是指针碰撞)\n\n假设堆内存是一个连续的空间，分为两个部分，一部分是已经被使用的内存，另一部分是未被使用的内存。\n\n在分配内存时，Java 虚拟机会维护一个指针，指向下一个可用的内存地址，每次分配内存时，只需要将指针向后移动一段距离，如果没有发生碰撞，就将这段内存分配给对象实例。\n\n#### [什么是空闲列表？](#什么是空闲列表)\n\nJVM 维护一个列表，记录堆中所有未占用的内存块，每个内存块都记录有大小和地址信息。\n\n当有新的对象请求内存时，JVM 会遍历空闲列表，寻找足够大的空间来存放新对象。\n\n分配后，如果选中的内存块未被完全利用，剩余的部分会作为一个新的内存块加入到空闲列表中。"
+ },
+ {
+ "id": 165,
+ "question": "new 对象时，堆会发生抢占吗？",
+ "answer": "会。\n\n\n\nnew 对象时，指针会向右移动一个对象大小的距离，假如一个线程 A 正在给字符串对象 s 分配内存，另外一个线程 B 同时为 ArrayList 对象 l 分配内存，两个线程就发生了抢占。\n\n#### [JVM 怎么解决堆内存分配的竞争问题？](#jvm-怎么解决堆内存分配的竞争问题)\n\n为了解决堆内存分配的竞争问题，JVM 为每个线程保留了一小块内存空间，被称为 TLAB，也就是线程本地分配缓冲区，用于存放该线程分配的对象。\n\n\n\n当线程需要分配对象时，直接从 TLAB 中分配。只有当 TLAB 用尽或对象太大需要直接在堆中分配时，才会使用全局分配指针。\n\n这里简单测试一下 TLAB。\n\n可以通过 `java -XX:+PrintFlagsFinal -version | grep TLAB` 命令查看当前 JVM 是否开启了 TLAB。\n\n\n\n如果开启了 TLAB，会看到类似以下的输出，其中 bool UseTLAB 的值为 true。\n\n我们编写一个简单的测试类，创建大量对象并强制触发垃圾回收，查看 TLAB 的使用情况。\n\n\n```java\nclass TLABDemo {\n public static void main(String[] args) {\n for (int i = 0; i < 10_000_000; i++) {\n allocate(); // 创建大量对象\n }\n System.gc(); // 强制触发垃圾回收\n }\n\n private static void allocate() {\n // 小对象分配，通常会使用 TLAB\n byte[] bytes = new byte[64];\n }\n}\n```\n\n\n在 VM 参数中添加 `-XX:+UseTLAB -XX:+PrintTLAB -XX:+PrintGCDetails -XX:+PrintGCDateStamps`，运行后可以看到这样的内容：\n\n\n\n* waste：未使用的 TLAB 空间。\n* alloc：分配到 TLAB 的空间。\n* refills：TLAB 被重新填充的次数。\n\n可以看到，当前线程的 TLAB 目标大小为 10,496 KB（`desired_size: 10496KB`）；未发生慢分配（`slow allocs: 0`）；分配效率直接拉满（`alloc: 1.00000 52494KB`）。\n\n当使用 `-XX:-UseTLAB -XX:+PrintGCDetails` 关闭 TLAB 时，会看到类似以下的输出：\n\n\n\n直接出现了两次 GC，因为没有 TLAB，Eden 区更快被填满，导致年轻代 GC。年轻代 GC 频繁触发，一部分长生命周期对象被晋升到老年代，间接导致老年代 GC 触发。"
+ },
+ {
+ "id": 166,
+ "question": "能说一下对象的内存布局吗？",
+ "answer": "好的。\n\n对象的内存布局是由 Java 虚拟机规范定义的，但具体的实现细节各有不同，如 HotSpot 和 OpenJ9 就不一样。\n\n就拿我们常用的 HotSpot 来说吧。\n\n对象在内存中包括三部分：对象头、实例数据和对齐填充。\n\n\n\n#### [说说对象头的作用？](#说说对象头的作用)\n\n对象头是对象存储在内存中的元信息，包含了Mark Word、类型指针等信息。\n\nMark Word 存储了对象的运行时状态信息，包括锁、哈希值、GC 标记等。在 64 位操作系统下占 8 个字节，32 位操作系统下占 4 个字节。\n\n类型指针指向对象所属类的元数据，也就是 Class 对象，用来支持多态、方法调用等功能。\n\n除此之外，如果对象是数组类型，还会有一个额外的数组长度字段。占 4 个字节。\n\n#### [类型指针会被压缩吗？](#类型指针会被压缩吗)\n\n类型指针可能会被压缩，以节省内存空间。比如说在开启压缩指针的情况下占 4 个字节，否则占 8 个字节。在 JDK 8 中，压缩指针默认是开启的。\n\n可以通过 `java -XX:+PrintFlagsFinal -version | grep UseCompressedOops` 命令来查看 JVM 是否开启了压缩指针。\n\n\n\n如果压缩指针开启，输出结果中的 bool UseCompressedOops 值为 true。\n\n#### [实例数据了解吗？](#实例数据了解吗)\n\n了解一些。\n\n实例数据是对象实际的字段值，也就是成员变量的值，按照字段在类中声明的顺序存储。\n\n\n```java\nclass ObjectDemo {\n int age;\n String name;\n}\n```\n\n\nJVM 会对这些数据进行对齐/重排，以提高内存访问速度。\n\n#### [对齐填充了解吗？](#对齐填充了解吗)\n\n由于 JVM 的内存模型要求对象的起始地址是 8 字节对齐（64 位 JVM 中），因此对象的总大小必须是 8 字节的倍数。\n\n如果对象头和实例数据的总长度不是 8 的倍数，JVM 会通过填充额外的字节来对齐。\n\n比如说，如果对象头 + 实例数据 = 14 字节，则需要填充 2 个字节，使总长度变为 16 字节。\n\n#### [为什么非要进行 8 字节对齐呢？](#为什么非要进行-8-字节对齐呢)\n\n因为 CPU 进行内存访问时，一次寻址的指针大小是 8 字节，正好是 L1 缓存行的大小。如果不进行内存对齐，则可能出现跨缓存行访问，导致额外的缓存行加载，CPU 的访问效率就会降低。\n\n\n\n比如说上图中 obj1 占 6 个字节，由于没有对齐，导致这一行缓存中多了 2 个字节 obj2 的数据，当 CPU 访问 obj2 的时候，就会导致缓存行刷新。\n\n也就说，8 字节对齐，是为了效率的提高，以空间换时间的一种方案。\n\n\n\n#### [new Object() 对象的内存大小是多少？](#new-object-对象的内存大小是多少)\n\n一般来说，目前的操作系统都是 64 位的，并且 JDK 8 中的压缩指针是默认开启的，因此在 64 位的 JVM 上，`new Object()`的大小是 16 字节（12 字节的对象头 + 4 字节的对齐填充）。\n\n\n\n对象头的大小是固定的，在 32 位 JVM 上是 8 字节，在 64 位 JVM 上是 16 字节；如果开启了压缩指针，就是 12 字节。\n\n实例数据的大小取决于对象的成员变量和它们的类型。对于`new Object()`来说，由于默认没有成员变量，因此我们可以认为此时的实例数据大小是 0。\n\n假如 MyObject 对象有三个成员变量，分别是 int、long 和 byte 类型，那么它们占用的内存大小分别是 4 字节、8 字节和 1 字节。\n\n\n```java\nclass MyObject {\n int a; // 4 字节\n long b; // 8 字节\n byte c; // 1 字节\n}\n```\n\n\n考虑到对齐填充，MyObject 对象的总大小为 12（对象头） + 4（a） + 8（b） + 1（c） + 7（填充） = 32 字节。\n\n#### [用过 JOL 查看对象的内存布局吗？](#用过-jol-查看对象的内存布局吗)\n\n用过。\n\n[JOL](https://openjdk.org/projects/code-tools/jol/) 是一款分析 JVM 对象布局的工具。\n\n第一步，在 pom.xml 中引入 JOL 依赖：\n\n\n```xml\n\n org.openjdk.jol \n jol-core \n 0.9 \n \n```\n\n\n第二步，使用 JOL 编写代码示例：\n\n\n```java\npublic class JOLSample {\n public static void main(String[] args) {\n // 打印JVM详细信息（可选）\n System.out.println(VM.current().details());\n\n // 创建Object实例\n Object obj = new Object();\n\n // 打印Object实例的内存布局\n String layout = ClassLayout.parseInstance(obj).toPrintable();\n System.out.println(layout);\n }\n}\n```\n\n\n第三步，运行代码，查看输出结果：\n\n\n\n可以看到有 OFFSET、SIZE、TYPE DESCRIPTION、VALUE 这几个信息。\n\n* OFFSET：偏移地址，单位字节；\n* SIZE：占用的内存大小，单位字节；\n* TYPE DESCRIPTION：类型描述，其中 object header 为对象头；\n* VALUE：对应内存中当前存储的值，二进制 32 位；\n\n从上面的结果能看到，对象头是 12 个字节，还有 4 个字节的 padding，`new Object()` 一共 16 个字节。\n\n#### [对象的引用大小了解吗？](#对象的引用大小了解吗)\n\n在 64 位 JVM 上，未开启压缩指针时，对象引用占用 8 字节；开启压缩指针时，对象引用会被压缩到 4 字节。HotSpot 虚拟机默认是开启压缩指针的。\n\n\n\n我们来验证一下：\n\n\n```java\nclass ReferenceSizeExample {\n private static class ReferenceHolder {\n Object reference;\n }\n\n public static void main(String[] args) {\n System.out.println(VM.current().details());\n System.out.println(ClassLayout.parseClass(ReferenceHolder.class).toPrintable());\n }\n}\n```\n\n\n运行代码，查看输出结果：\n\n\n\nReferenceHolder.reference 的大小为 4 字节。"
+ },
+ {
+ "id": 167,
+ "question": "JVM 怎么访问对象的？",
+ "answer": "主流的方式有两种：句柄和直接指针。\n\n两种方式的区别在于，句柄是通过一个中间的句柄表来定位对象的，而直接指针则是通过引用直接指向对象的内存地址。\n\n优点是，对象被移动时只需要修改句柄表中的指针，而不需要修改对象引用本身。\n\n\n\n在直接指针访问中，引用直接存储对象的内存地址；对象的实例数据和类型信息都存储在堆中固定的内存区域。\n\n优点是访问速度更快，因为少了一次句柄的寻址操作。缺点是如果对象在内存中移动，引用需要更新为新的地址。\n\n\n\nHotSpot 虚拟机主要使用直接指针来进行对象访问。"
+ },
+ {
+ "id": 168,
+ "question": "说一下对象有哪几种引用？",
+ "answer": "四种，分别是强引用、软引用、弱引用和虚引用。\n\n\n\n强引用是 Java 中最常见的引用类型。使用 new 关键字赋值的引用就是强引用，只要强引用关联着对象，垃圾收集器就不会回收这部分对象，即使内存不足。\n\n\n```java\n// str 就是一个强引用\nString str = new String(\"练习伴侣二\");\n```\n\n\n软引用于描述一些非必须对象，通过 SoftReference 类实现。软引用的对象在内存不足时会被回收。\n\n\n```java\n// softRef 就是一个软引用\nSoftReference softRef = new SoftReference<>(new String(\"练习伴侣二\"));\n```\n\n\n弱引用用于描述一些短生命周期的非必须对象，如 ThreadLocal 中的 Entry，就是通过 WeakReference 类实现的。弱引用的对象会在下一次垃圾回收时会被回收，不论内存是否充足。\n\n\n```java\nstatic class Entry extends WeakReference> {\n /** The value associated with this ThreadLocal. */\n Object value;\n\n //节点类\n Entry(ThreadLocal k, Object v) {\n //key赋值\n super(k);\n //value赋值\n value = v;\n }\n}\n```\n\n\n虚引用主要用来跟踪对象被垃圾回收的过程，通过 PhantomReference 类实现。虚引用的对象在任何时候都可能被回收。\n\n\n```java\n// phantomRef 就是一个虚引用\nPhantomReference phantomRef = new PhantomReference<>(new String(\"练习伴侣二\"), new ReferenceQueue<>());\n```"
+ },
+ {
+ "id": 169,
+ "question": "Java 堆的内存分区了解吗？",
+ "answer": "了解。Java 堆被划分为**新生代**和**老年代**两个区域。\n\n\n\n新生代又被划分为 Eden 空间和两个 Survivor 空间（From 和 To）。\n\n新创建的对象会被分配到 Eden 空间。当 Eden 区填满时，会触发一次 Minor GC，清除不再使用的对象。存活下来的对象会从 Eden 区移动到 Survivor 区。\n\n对象在新生代中经历多次 GC 后，如果仍然存活，会被移动到老年代。当老年代内存不足时，会触发 Major GC，对整个堆进行垃圾回收。"
+ },
+ {
+ "id": 170,
+ "question": "说一下新生代的区域划分？",
+ "answer": "新生代的垃圾收集主要采用标记-复制算法，因为新生代的存活对象比较少，每次复制少量的存活对象效率比较高。\n\n基于这种算法，虚拟机将内存分为一块较大的 Eden 空间和两块较小的 Survivor 空间，每次分配内存只使用 Eden 和其中一块 Survivor。发生垃圾收集时，将 Eden 和 Survivor 中仍然存活的对象一次性复制到另外一块 Survivor 空间上，然后直接清理掉 Eden 和已用过的那块 Survivor 空间。默认 Eden 和 Survivor 的大小比例是 8∶1。\n\n"
+ },
+ {
+ "id": 171,
+ "question": "对象什么时候会进入老年代？",
+ "answer": "对象通常会在年轻代中分配，随着时间的推移和垃圾收集的进程，某些满足条件的对象会进入到老年代中，如长期存活的对象。\n\n\n\n#### [长期存活的对象如何判断？](#长期存活的对象如何判断)\n\nJVM 会为对象维护一个“年龄”计数器，记录对象在新生代中经历 Minor GC 的次数。每次 GC 未被回收的对象，其年龄会加 1。\n\n当超过一个特定阈值，默认值是 15，就会被认为老对象了，需要重点关照。这个年龄阈值可以通过 JVM 参数`-XX:MaxTenuringThreshold`来设置。\n\n可以通过 `jinfo -flag MaxTenuringThreshold $(jps | grep -i nacos | awk '{print $1}')` 来查看当前 JVM 的年龄阈值。\n\n\n\n1. 如果应用中的对象存活时间较短，可以适当调大这个值，让对象在新生代多待一会儿\n2. 如果对象存活时间较长，可以适当调小这个值，让对象更快进入老年代，减少在新生代的复制次数\n\n#### [大对象如何判断？](#大对象如何判断)\n\n大对象是指占用内存较大的对象，如大数组、长字符串等。\n\n\n```java\nint[] array = new int[1000000];\nString str = new String(new char[1000000]);\n```\n\n\n其大小由 JVM 参数 `-XX:PretenureSizeThreshold` 控制，但在 JDK 8 中，默认值为 0，也就是说默认情况下，对象仅根据 GC 存活的次数来判断是否进入老年代。\n\n\n\nG1 垃圾收集器中，大对象会直接分配到 HUMONGOUS 区域。当对象大小超过一个 Region 容量的 50% 时，会被认为是大对象。\n\n\n\nRegion 的大小可以通过 JVM 参数 `-XX:G1HeapRegionSize` 来设置，默认情况下从 1MB 到 32MB 不等，会根据堆内存大小动态调整。\n\n可以通过 `java -XX:+UseG1GC -XX:+PrintGCDetails -version` 查看 G1 垃圾收集器的相关信息。\n\n\n\n从结果上来看，我本机上 G1 的堆大小为 2GB，Region 的大小为 4MB。\n\n#### [动态年龄判定了解吗？](#动态年龄判定了解吗)\n\n如果 Survivor 区中所有对象的总大小超过了一定比例，通常是 Survivor 区的一半，那么年龄较小的对象也可能会被提前晋升到老年代。\n\n这是因为如果年龄较小的对象在 Survivor 区中占用了较大的空间，会导致 Survivor 区中的对象复制次数增多，影响垃圾回收的效率。"
+ },
+ {
+ "id": 172,
+ "question": "STW 了解吗？",
+ "answer": "了解。\n\nJVM 进行垃圾回收的过程中，会涉及到对象的移动，为了保证对象引用在移动过程中不被修改，必须暂停所有的用户线程，像这样的停顿，我们称之为`Stop The World`。简称 STW。\n\n#### [如何暂停线程呢？](#如何暂停线程呢)\n\nJVM 会使用一个名为安全点（Safe Point）的机制来确保线程能够被安全地暂停，其过程包括四个步骤：\n\n* JVM 发出暂停信号；\n* 线程执行到安全点后，挂起自身并等待垃圾收集完成；\n* 垃圾回收器完成 GC 操作；\n* 线程恢复执行。\n\n#### [什么是安全点？](#什么是安全点)\n\n安全点是 JVM 的一种机制，常用于垃圾回收的 STW 操作，用于让线程在执行到某些特定位置时，可以被安全地暂停。\n\n通常位于方法调用、循环跳转、异常处理等位置，以保证线程暂停时数据的一致性。\n\n用个通俗的比喻，老练习伴侣去拉车，车上的东西很重，老王累的汗流浃背，但是老王不能在上坡或者下坡时休息，只能在平地上停下来擦擦汗，喝口水。\n\n\n\n推荐大家看看这个[HotSpot JVM Deep Dive - Safepoint](https://www.youtube.com/watch?v=JkbWPPNc4SI)，对 safe point 有一个比较深入地解释。\n\n"
+ },
+ {
+ "id": 173,
+ "question": "对象一定分配在堆中吗？",
+ "answer": "不一定。\n\n默认情况下，Java 对象是在堆中分配的，但 JVM 会进行逃逸分析，来判断对象的生命周期是否只在方法内部，如果是的话，这个对象可以在栈上分配。\n\n举例来说，下面的代码中，对象 `new Person()` 的生命周期只在 `testStackAllocation` 方法内部，因此 JVM 会将这个对象分配在栈上。\n\n\n```java\npublic void testStackAllocation() {\n Person p = new Person(); // 对象可能分配在栈上\n p.name = \"练习伴侣二是只狗\";\n p.age = 18;\n System.out.println(p.name);\n}\n```\n\n\n#### [什么是逃逸分析？](#什么是逃逸分析)\n\n逃逸分析是一种 JVM 优化技术，用来分析对象的作用域和生命周期，判断对象是否逃逸出方法或线程。\n\n可以通过分析对象的引用流向，判断对象是否被方法返回、赋值到全局变量、传递到其他线程等，来确定对象是否逃逸。\n\n如果对象没有逃逸，就可以进行栈上分配、同步消除、标量替换等优化，以提高程序的性能。\n\n可以通过 `java -XX:+PrintFlagsFinal -version | grep DoEscapeAnalysis` 来确认 JVM 是否开启了逃逸分析。\n\n\n\n#### [逃逸具体是指什么？](#逃逸具体是指什么)\n\n根据对象逃逸的范围，可以分为方法逃逸和线程逃逸。\n\n当对象被方法外部的代码引用，生命周期超出了方法的范围，那么对象就必须分配在堆中，由垃圾收集器管理。\n\n\n```java\npublic Person createPerson() {\n return new Person(); // 对象逃逸出方法\n}\n```\n\n\n比如说 `new Person()` 创建的对象被返回，那么这个对象就逃逸出当前方法了。\n\n\n\n再比如说，对象被另外一个线程引用，生命周期超出了当前线程，那么对象就必须分配在堆中，并且线程之间需要同步。\n\n\n```java\npublic void threadEscapeExample() {\n Person p = new Person(); // 对象逃逸到另一个线程\n new Thread(() -> {\n System.out.println(p);\n }).start();\n}\n```\n\n\n对象 `new Person()` 被另外一个线程引用了，发生了线程逃逸。\n\n#### [逃逸分析会带来什么好处？](#逃逸分析会带来什么好处)\n\n主要有三个。\n\n第一，如果确定一个对象不会逃逸，那么就可以考虑栈上分配，对象占用的内存随着栈帧出栈后销毁，这样一来，垃圾收集的压力就降低很多。\n\n第二，线程同步需要加锁，加锁就要占用系统资源，如果逃逸分析能够确定一个对象不会逃逸出线程，那么这个对象就不用加锁，从而减少线程同步的开销。\n\n第三，如果对象的字段在方法中独立使用，JVM 可以将对象分解为标量变量，避免对象分配。\n\n\n```java\npublic void scalarReplacementExample() {\n Point p = new Point(1, 2);\n System.out.println(p.getX() + p.getY());\n}\n```\n\n\n如果 Point 对象未逃逸，JVM 可以优化为：\n\n\n```java\nint x = 1;\nint y = 2;\nSystem.out.println(x + y);\n```"
+ },
+ {
+ "id": 174,
+ "question": "内存溢出和内存泄漏了解吗？",
+ "answer": "内存溢出，俗称 OOM，是指当程序请求分配内存时，由于没有足够的内存空间，从而抛出 OutOfMemoryError。\n\n\n```java\nList list = new ArrayList<>();\nwhile (true) {\n list.add(\"OutOfMemory\".repeat(1000)); // 无限增加内存\n}\n```\n\n\n可能是因为堆、元空间、栈或直接内存不足导致的。可以通过优化内存配置、减少对象分配来解决。\n\n内存泄漏是指程序在使用完内存后，未能及时释放，导致占用的内存无法再被使用。随着时间的推移，内存泄漏会导致可用内存逐渐减少，最终导致内存溢出。\n\n内存泄漏通常是因为长期存活的对象持有短期存活对象的引用，又没有及时释放，从而导致短期存活对象无法被回收而导致的。\n\n\n```java\nclass MemoryLeakExample {\n private static List staticList = new ArrayList<>();\n public void addObject() {\n staticList.add(new Object()); // 对象不会被回收\n }\n}\n```\n\n\n用一个比较有味道的比喻来形容就是，内存溢出是排队去蹲坑，发现没坑了；内存泄漏，就是有人占着茅坑不拉屎，导致坑位不够用。\n\n"
+ },
+ {
+ "id": 175,
+ "question": "能手写内存溢出的例子吗？",
+ "answer": "可以。\n\n我就拿最常见的堆内存溢出来完成吧，堆内存溢出通常是因为创建了大量的对象，且长时间无法被垃圾收集器回收，导致的。\n\n\n```java\nclass HeapSpaceErrorGenerator {\n public static void main(String[] args) {\n // 第一步，创建一个大的容器\n List bigObjects = new ArrayList<>();\n try {\n // 第二步，循环写入数据\n while (true) {\n // 第三步，创建一个大对象，一个大约 10M 的数组\n byte[] bigObject = new byte[10 * 1024 * 1024];\n // 第四步，将大对象添加到容器中\n bigObjects.add(bigObject);\n }\n } catch (OutOfMemoryError e) {\n System.out.println(\"OutOfMemoryError 发生在 \" + bigObjects.size() + \" 对象后\");\n throw e;\n }\n }\n}\n```\n\n\n很快就会发生内存溢出。\n\n这就相当于一个房子里，不断堆积不能被回收的杂物，那么房子很快就会被堆满了。\n\n也可以通过 VM 参数设置堆内存大小为 `-Xmx128M`，然后运行程序，出现的内存溢出的时间会更快。\n\n\n\n可以看到，堆内存溢出发生在 11 个对象后。\n\n"
+ },
+ {
+ "id": 176,
+ "question": "内存泄漏可能由哪些原因导致呢？",
+ "answer": "比如说：\n\n①、静态的集合中添加的对象越来越多，但却没有及时清理；静态变量的生命周期与应用程序相同，如果静态变量持有对象的引用，这些对象将无法被 GC 回收。\n\n\n```java\nclass OOM {\n static List list = new ArrayList();\n\n public void oomTests(){\n Object obj = new Object();\n\n list.add(obj);\n }\n}\n```\n\n\n②、单例模式下对象持有的外部引用无法及时释放；单例对象在整个应用程序的生命周期中存活，如果单例对象持有其他对象的引用，这些对象将无法被回收。\n\n\n```java\nclass Singleton {\n private static final Singleton INSTANCE = new Singleton();\n private List objects = new ArrayList<>();\n\n public static Singleton getInstance() {\n return INSTANCE;\n }\n}\n```\n\n\n③、数据库、IO、Socket 等连接资源没有及时关闭；\n\n\n```java\ntry {\n Connection conn = null;\n Class.forName(\"com.mysql.jdbc.Driver\");\n conn = DriverManager.getConnection(\"url\", \"\", \"\");\n Statement stmt = conn.createStatement();\n ResultSet rs = stmt.executeQuery(\"....\");\n } catch (Exception e) {\n\n }finally {\n //不关闭连接\n }\n```\n\n\n④、 ThreadLocal 的引用未被清理，线程退出后仍然持有对象引用；在线程执行完后，要调用 ThreadLocal 的 remove 方法进行清理。\n\n\n```java\nThreadLocal threadLocal = new ThreadLocal<>();\nthreadLocal.set(new Object()); // 未清理\n```"
+ },
+ {
+ "id": 177,
+ "question": "有没有处理过内存泄漏问题？",
+ "answer": "有。\n\n当时在做项目的时候，由于 ThreadLocal 没有及时清理导致出现了内存泄漏问题。\n\n我用可视化的监控工具 VisualVM，配合 JDK 自带的 jstack 等命令行工具进行了排查。\n\n大致的过程我回想了一下，主要有 7 个步骤：\n\n第一步，使用 `jps -l` 查看运行的 Java 进程 ID。\n\n\n\n第二步，使用`top -p [pid]` 查看进程使用 CPU 和内存占用情况。\n\n\n\n第三步，使用 `top -Hp [pid]` 查看进程下的所有线程占用 CPU 和内存情况。\n\n\n\n第四步，抓取线程栈：`jstack -F 29452 > 29452.txt`，可以多抓几次做个对比。\n\n> 29452 为 pid，顺带作为文件名。\n\n\n\n看看有没有线程死锁、死循环或长时间等待这些问题。\n\n\n\n第五步，可以使用`jstat -gcutil [pid] 5000 10` 每隔 5 秒输出 GC 信息，输出 10 次，查看 **YGC** 和 **Full GC** 次数。\n\n\n\n通常会出现 YGC 不增加或增加缓慢，而 Full GC 增加很快。\n\n或使用 `jstat -gccause [pid] 5000` 输出 GC 摘要信息。\n\n\n\n或使用 `jmap -heap [pid]` 查看堆的摘要信息，关注老年代内存使用是否达到阀值，若达到阀值就会执行 Full GC。\n\n\n\n如果发现 `Full GC` 次数太多，就很大概率存在内存泄漏了。\n\n第六步，生成 `dump` 文件，然后借助可视化工具分析哪个对象非常多，基本就能定位到问题根源了。\n\n执行命令 `jmap -dump:format=b,file=heap.hprof 10025` 会输出进程 10025 的堆快照信息，保存到文件 heap.hprof 中。\n\n\n\n第七步，使用图形化工具分析，如 JDK 自带的 **VisualVM**，从菜单 > 文件 > 装入 dump 文件。\n\n\n\n然后在结果观察内存占用最多的对象，找到内存泄漏的源头。"
+ },
+ {
+ "id": 178,
+ "question": "有没有处理过内存溢出问题？",
+ "answer": "有。\n\n当时在做的时候，由于上传的文件过大，没有正确处理，导致一下子撑爆了内存，程序直接崩溃了。\n\n我记得是通过导出堆转储文件进行分析发现的。\n\n第一步，使用 jmap 命令手动生成 Heap Dump 文件：\n\n\n```shell\njmap -dump:format=b,file=heap.hprof \n```\n\n\n然后使用 MAT、JProfiler 等工具进行分析，查看内存中的对象占用情况。\n\n一般来说：\n\n如果生产环境的内存还有很多空余，可以适当增大堆内存大小来解决，例如 `-Xmx4g` 参数。\n\n或者检查代码中是否存在内存泄漏，如未关闭的资源、长生命周期的对象等。\n\n之后，在本地进行压力测试，模拟高负载情况下的内存表现，确保修改有效，且没有引入新的问题。"
+ },
+ {
+ "id": 179,
+ "question": "什么情况下会发生栈溢出？（补充）",
+ "answer": "> 2024 年 10 月 16 日增补\n\n栈溢出发生在程序调用栈的深度超过 JVM 允许的最大深度时。\n\n栈溢出的本质是因为线程的栈空间不足，导致无法再为新的栈帧分配内存。\n\n\n\n当一个方法被调用时，JVM 会在栈中分配一个栈帧，用于存储该方法的执行信息。如果方法调用嵌套太深，栈帧不断压入栈中，最终会导致栈空间耗尽，抛出 StackOverflowError。\n\n最常见的栈溢出场景就是递归调用，尤其是没有正确的终止条件下，会导致递归无限进行。\n\n\n```java\nclass StackOverflowExample {\n public static void recursiveMethod() {\n // 没有终止条件的递归调用\n recursiveMethod();\n }\n\n public static void main(String[] args) {\n recursiveMethod(); // 导致栈溢出\n }\n}\n```\n\n\n另外，如果方法中定义了特别大的局部变量，栈帧会变得很大，导致栈空间更容易耗尽。\n\n\n```java\npublic class LargeLocalVariables {\n public static void method() {\n int[] largeArray = new int[1000000]; // 大量局部变量\n method(); // 递归调用\n }\n\n public static void main(String[] args) {\n method(); // 导致栈溢出\n }\n}\n```"
+ }
+ ]
+ },
+ {
+ "id": 28,
+ "categoryName": "垃圾收集",
+ "questions": [
+ {
+ "id": 180,
+ "question": "讲讲 JVM 的垃圾回收机制（补充）",
+ "answer": "> 本题是增补的内容，by 2024 年 03 月 09 日；参照：\n\n垃圾回收就是对内存堆中已经死亡的或者长时间没有使用的对象进行清除或回收。\n\nJVM 在做 GC 之前，会先搞清楚什么是垃圾，什么不是垃圾，通常会通过可达性分析算法来判断对象是否存活。\n\n\n\n在确定了哪些垃圾可以被回收后，垃圾收集器（如 CMS、G1、ZGC）要做的事情就是进行垃圾回收，可以采用标记清除算法、复制算法、标记整理算法、分代收集算法等。\n\n项目使用的 JDK 8，采用的是 CMS 垃圾收集器。\n\n\n```text\njava -XX:+UseConcMarkSweepGC \\\n -XX:+UseParNewGC \\\n -XX:CMSInitiatingOccupancyFraction=75 \\\n -XX:+UseCMSInitiatingOccupancyOnly \\\n -jar your-application.jar\n```\n\n\n#### [垃圾回收的过程是什么？](#垃圾回收的过程是什么)\n\nJava 的垃圾回收过程主要分为标记存活对象、清除无用对象、以及内存压缩/整理三个阶段。不同的垃圾回收器在执行这些步骤时会采用不同的策略和算法。"
+ },
+ {
+ "id": 181,
+ "question": "如何判断对象仍然存活？",
+ "answer": "Java 通过可达性分析算法来判断一个对象是否还存活。\n\n通过一组名为 “GC Roots” 的根对象，进行递归扫描，无法从根对象到达的对象就是“垃圾”，可以被回收。\n\n\n\n这也是 G1、CMS 等主流垃圾收集器使用的主要算法。\n\n#### [什么是引用计数法？](#什么是引用计数法)\n\n每个对象有一个引用计数器，记录引用它的次数。当计数器为零时，对象可以被回收。\n\n\n\n引用计数法无法解决循环引用的问题。例如，两个对象互相引用，但不再被其他对象引用，它们的引用计数都不为零，因此不会被回收。\n\n#### [做可达性分析的时候，应该有哪些前置性的操作？](#做可达性分析的时候-应该有哪些前置性的操作)\n\n在进行垃圾回收之前，JVM 会暂停所有正在执行的应用线程。\n\n这是因为可达性分析过程必须确保在执行分析时，内存中的对象关系不会被应用线程修改。如果不暂停应用线程，可能会出现对象引用的改变，导致垃圾回收过程中判断对象是否可达的结果不一致，从而引发严重的内存错误或数据丢失。"
+ },
+ {
+ "id": 182,
+ "question": "Java 中可作为 GC Roots 的引用有哪几种？",
+ "answer": "所谓的 GC Roots，就是一组必须活跃的引用，它们是程序运行时的起点，是一切引用链的源头。在 Java 中，GC Roots 包括以下几种：\n\n* 虚拟机栈中的引用（方法的参数、局部变量等）\n* 本地方法栈中 JNI 的引用\n* 类静态变量\n* 运行时常量池中的常量（String 或 Class 类型）\n\n\n\n#### [说说虚拟机栈中的引用？](#说说虚拟机栈中的引用)\n\n来看下面这段代码：\n\n\n```java\npublic class StackReference {\n public void greet() {\n Object localVar = new Object(); // 这里的 localVar 是一个局部变量，存在于虚拟机栈中\n System.out.println(localVar.toString());\n }\n\n public static void main(String[] args) {\n new StackReference().greet();\n }\n}\n```\n\n\n在 greet 方法中，localVar 是一个局部变量，存在于虚拟机栈中，可以被认为是 GC Roots。\n\n在 greet 方法执行期间，localVar 引用的对象是活跃的，因为它是从 GC Roots 可达的。\n\n当 greet 方法执行完毕后，localVar 的作用域结束，localVar 引用的 Object 对象不再由任何 GC Roots 引用（假设没有其他引用指向这个对象），因此它将有资格作为垃圾被回收掉 😁。\n\n#### [说说本地方法栈中 JNI 的引用？](#说说本地方法栈中-jni-的引用)\n\nJava 通过 JNI 提供了一种机制，允许 Java 代码调用本地代码（通常是 C 或 C++ 编写的代码）。\n\n当调用 Java 方法时，虚拟机会创建一个栈帧并压入虚拟机栈，而当它调用本地方法时，虚拟机会通过动态链接直接调用指定的本地方法。\n\n\n\nJNI 引用是在 Java 本地接口代码中创建的引用，这些引用可以指向 Java 堆中的对象。\n\n\n```java\n// 假设的JNI方法\npublic native void nativeMethod();\n\n// 假设在C/C++中实现的本地方法\n/*\n * Class: NativeExample\n * Method: nativeMethod\n * Signature: ()V\n */\nJNIEXPORT void JNICALL Java_NativeExample_nativeMethod(JNIEnv *env, jobject thisObj) {\n jobject localRef = (*env)->NewObject(env, ...); // 在本地方法栈中创建JNI引用\n // localRef 引用的Java对象在本地方法执行期间是活跃的\n}\n```\n\n\n在本地代码中，localRef 是对 Java 对象的一个 JNI 引用，它在本地方法执行期间保持 Java 对象活跃，可以被认为是 GC Roots。\n\n一旦 JNI 方法执行完毕，除非这个引用是全局的，否则它指向的对象将会被作为垃圾回收掉（假设没有其他地方再引用这个对象）。\n\n#### [说说类静态变量？](#说说类静态变量)\n\n来看下面这段代码：\n\n\n```java\npublic class StaticFieldReference {\n private static Object staticVar = new Object(); // 类静态变量\n\n public static void main(String[] args) {\n System.out.println(staticVar.toString());\n }\n}\n```\n\n\nStaticFieldReference 类中的 staticVar 引用了一个 Object 对象，这个引用存储在元空间，可以被认为是 GC Roots。\n\n只要 StaticFieldReference 类未被卸载，staticVar 引用的对象都不会被垃圾回收。如果 StaticFieldReference 类被卸载（这通常发生在其类加载器被垃圾回收时），那么 staticVar 引用的对象也将有资格被垃圾回收（如果没有其他引用指向这个对象）。\n\n#### [说说运行时常量池中的常量？](#说说运行时常量池中的常量)\n\n来看这段代码：\n\n\n```java\nclass ConstantPoolReference {\n public static final String CONSTANT_STRING = \"Hello, World\"; // 常量，存在于运行时常量池中\n public static final Class CONSTANT_CLASS = Object.class; // 类类型常量\n\n public static void main(String[] args) {\n System.out.println(CONSTANT_STRING);\n System.out.println(CONSTANT_CLASS.getName());\n }\n}\n```\n\n\n在 ConstantPoolReference 中，CONSTANT\\_STRING 和 CONSTANT\\_CLASS 作为常量存储在运行时常量池。它们可以用来作为 GC Roots。\n\n这些常量引用的对象（字符串\"Hello, World\"和 Object.class 类对象）在常量池中，只要包含这些常量的 ConstantPoolReference 类未被卸载，这些对象就不会被垃圾回收。"
+ },
+ {
+ "id": 183,
+ "question": "finalize()方法了解吗？",
+ "answer": "垃圾回收就是古代的秋后问斩，`finalize()` 就是刀下留人，在人犯被处决之前，还要做最后一次审计，青天大老爷会看看有没有什么冤情，需不需要刀下留人。\n\n\n\n如果对象在进行可达性分析后发现没有与 GC Roots 相连接的引用链，那它将会被第一次标记，随后进行一次筛选。\n\n筛选的条件是对象是否有必要执行 `finalize()`方法。\n\n如果对象在 `finalize()` 中成功拯救自己——只要重新与引用链上的任何一个对象建立关联即可。\n\n譬如把自己 （this 关键字）赋值给某个类变量或者对象的成员变量，那在第二次标记时它就”逃过一劫“；但是如果没有抓住这个机会，那么对象就真的要被回收了。"
+ },
+ {
+ "id": 184,
+ "question": "垃圾收集算法了解吗？",
+ "answer": "垃圾收集算法主要有三种，分别是标记-清除算法、标记-复制算法和标记-整理算法。\n\n#### [说说标记-清除算法？](#说说标记-清除算法)\n\n`标记-清除`算法分为两个阶段：\n\n* **标记**：标记所有需要回收的对象\n* **清除**：回收所有被标记的对象\n\n\n\n优点是实现简单，缺点是回收过程中会产生内存碎片。\n\n#### [说说标记-复制算法？](#说说标记-复制算法)\n\n`标记-复制`算法可以解决标记-清除算法的内存碎片问题，因为它将内存空间划分为两块，每次只使用其中一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后清理掉这一块。\n\n\n\n缺点是浪费了一半的内存空间。\n\n#### [说说标记-整理算法？](#说说标记-整理算法)\n\n`标记-整理`算法是标记-清除复制算法的升级版，它不再划分内存空间，而是将存活的对象向内存的一端移动，然后清理边界以外的内存。\n\n\n\n缺点是移动对象的成本比较高。\n\n#### [说说分代收集算法？](#说说分代收集算法)\n\n`分代收集`算法是目前主流的垃圾收集算法，它根据对象存活周期的不同将内存划分为几块，一般分为新生代和老年代。\n\n\n\n新生代用复制算法，因为大部分对象生命周期短。老年代用标记-整理算法，因为对象存活率较高。\n\n#### [为什么要用分代收集呢？](#为什么要用分代收集呢)\n\n分代收集算法的核心思想是根据对象的生命周期优化垃圾回收。\n\n新生代的对象生命周期短，使用复制算法可以快速回收。老年代的对象生命周期长，使用标记-整理算法可以减少移动对象的成本。\n\n#### [标记复制的标记过程和复制过程会不会停顿？](#标记复制的标记过程和复制过程会不会停顿)\n\n在标记-复制算法 中，标记阶段和复制阶段都会触发STW。\n\n* 标记阶段停顿是为了保证对象的引用关系不被修改。\n* 复制阶段停顿是防止对象在复制过程中被修改。"
+ },
+ {
+ "id": 185,
+ "question": "Minor GC、Major GC、Mixed GC、Full GC 都是什么意思？",
+ "answer": "Minor GC 也称为 Young GC，是指发生在年轻代的垃圾收集。年轻代包含 Eden 区以及两个 Survivor 区。\n\n\n\nMajor GC 也称为 Old GC，主要指的是发生在老年代的垃圾收集。是 CMS 的特有行为。\n\nMixed GC 是 G1 垃圾收集器特有的一种 GC 类型，它在一次 GC 中同时清理年轻代和部分老年代。\n\nFull GC 是最彻底的垃圾收集，涉及整个 Java 堆和方法区。它是最耗时的 GC，通常在 JVM 压力很大时发生。\n\n#### [FULL gc怎么去清理的？](#full-gc怎么去清理的)\n\nFull GC 会从 GC Root 出发，标记所有可达对象。新生代使用复制算法，清空 Eden 区。老年代使用标记-整理算法，回收对象并消除碎片。\n\n停顿时间较长，会影响系统响应性能。"
+ },
+ {
+ "id": 186,
+ "question": "Young GC 什么时候触发？",
+ "answer": "如果 Eden 区没有足够的空间时，就会触发 Young GC 来清理新生代。"
+ },
+ {
+ "id": 187,
+ "question": "什么时候会触发 Full GC？",
+ "answer": "在进行 Young GC 的时候，如果发现`老年代可用的连续内存空间` < `新生代历次 Young GC 后升入老年代的对象总和的平均大小`，说明本次 Young GC 后升入老年代的对象大小，可能超过了老年代当前可用的内存空间，就会触发 Full GC。\n\n执行 Young GC 后老年代没有足够的内存空间存放转入的对象，会立即触发一次 Full GC。\n\n`System.gc()`、`jmap -dump` 等命令会触发 full gc。\n\n#### [空间分配担保是什么？](#空间分配担保是什么)\n\n空间分配担保是指在进行 Minor GC 前，JVM 会确保老年代有足够的空间存放从新生代晋升的对象。如果老年代空间不足，可能会触发 Full GC。"
+ },
+ {
+ "id": 188,
+ "question": "知道哪些垃圾收集器？",
+ "answer": "JVM 的垃圾收集器主要分为两大类：分代收集器和分区收集器，分代收集器的代表是 CMS，分区收集器的代表是 G1 和 ZGC。\n\n\n\nCMS 是第一个关注 GC 停顿时间的垃圾收集器，JDK 1.5 时引入，JDK9 被标记弃用，JDK14 被移除。\n\nG1 在 JDK 1.7 时引入，在 JDK 9 时取代 CMS 成为了默认的垃圾收集器。\n\nZGC 是 JDK11 推出的一款低延迟垃圾收集器，适用于大内存低延迟服务的内存管理和回收，在 128G 的大堆下，最大停顿时间才 1.68 ms，性能远胜于 G1 和 CMS。\n\n#### [说说 Serial 收集器？](#说说-serial-收集器)\n\nSerial 收集器是最基础、历史最悠久的收集器。\n\n如同它的名字（串行），它是一个单线程工作的收集器，使用一个处理器或一条收集线程去完成垃圾收集工作。并且进行垃圾收集时，必须暂停其他所有工作线程，直到垃圾收集结束——这就是所谓的“Stop The World”。\n\nSerial/Serial Old 收集器的运行过程如图：\n\n\n\n#### [说说 ParNew 收集器？](#说说-parnew-收集器)\n\nParNew 收集器实质上是 Serial 收集器的多线程并行版本，使用多条线程进行垃圾收集。\n\nParNew/Serial Old 收集器运行示意图如下：\n\n\n\n#### [说说 Parallel Scavenge 收集器？](#说说-parallel-scavenge-收集器)\n\nParallel Scavenge 收集器是一款新生代收集器，基于标记-复制算法实现，也能够并行收集。和 ParNew 有些类似，但 Parallel Scavenge 主要关注的是垃圾收集的吞吐量——所谓吞吐量，就是 CPU 用于运行用户代码的时间和总消耗时间的比值，比值越大，说明垃圾收集的占比越小。\n\n\n\n根据对象存活周期的不同会将内存划分为几块，一般是把 Java 堆分为新生代和老年代，这样就可以根据各个年代的特点采用最适当的收集算法。\n\n#### [说说 Serial Old 收集器？](#说说-serial-old-收集器)\n\nSerial Old 是 Serial 收集器的老年代版本，它同样是一个单线程收集器，使用标记-整理算法。\n\n#### [说说 Parallel Old 收集器？](#说说-parallel-old-收集器)\n\nParallel Old 是 Parallel Scavenge 收集器的老年代版本，基于标记-整理算法实现，使用多条 GC 线程在 STW 期间同时进行垃圾回收。\n\n\n\n#### [说说 CMS 收集器？](#说说-cms-收集器)\n\nCMS 在 JDK 1.5 时引入，JDK 9 时被标记弃用，JDK 14 时被移除。\n\nCMS 是一种低延迟的垃圾收集器，采用标记-清除算法，分为初始标记、并发标记、重新标记和并发清除四个阶段，优点是垃圾回收线程和应用线程同时运行，停顿时间短，适合延迟敏感的应用，但容易产生内存碎片，可能触发 Full GC。\n\n\n\n#### [说说 G1 收集器？](#说说-g1-收集器)\n\nG1 在 JDK 1.7 时引入，在 JDK 9 时取代 CMS 成为默认的垃圾收集器。\n\nG1 是一种面向大内存、高吞吐场景的垃圾收集器，它将堆划分为多个小的 Region，通过标记-整理算法，避免了内存碎片问题。优点是停顿时间可控，适合大堆场景，但调优较复杂。\n\n\n\n#### [说说 ZGC 收集器？](#说说-zgc-收集器)\n\nZGC 是 JDK 11 时引入的一款低延迟的垃圾收集器，最大特点是将垃圾收集的停顿时间控制在 10ms 以内，即使在 TB 级别的堆内存下也能保持较低的停顿时间。\n\n它通过并发标记和重定位来避免大部分 Stop-The-World 停顿，主要依赖指针染色来管理对象状态。\n\n\n\n* **标记对象的可达性**：通过在指针上增加标记位，不需要额外的标记位即可判断对象的存活状态。\n* **重定位状态**：在对象被移动时，可以通过指针染色来更新对象的引用，而不需要等待全局同步。\n\n适用于需要超低延迟的场景，比如金融交易系统、电商平台。\n\n#### [垃圾回收器的作用是什么？](#垃圾回收器的作用是什么)\n\n垃圾回收器的核心作用是自动管理 Java 应用程序的运行时内存。它负责识别哪些内存是不再被应用程序使用的，并释放这些内存以便重新使用。\n\n这一过程减少了程序员手动管理内存的负担，降低了内存泄漏和溢出错误的风险。"
+ },
+ {
+ "id": 189,
+ "question": "能详细说一下 CMS 的垃圾收集过程吗？",
+ "answer": "\n\nCMS 使用**标记-清除**算法进行垃圾收集，分 4 大步：\n\n* **初始标记**：标记所有从 GC Roots 直接可达的对象，这个阶段需要 STW，但速度很快。\n* **并发标记**：从初始标记的对象出发，遍历所有对象，标记所有可达的对象。这个阶段是并发进行的。\n* **重新标记**：完成剩余的标记工作，包括处理并发阶段遗留下来的少量变动，这个阶段通常需要短暂的 STW 停顿。\n* **并发清除**：清除未被标记的对象，回收它们占用的内存空间。\n\n#### [你提到了remark，那它remark具体是怎么执行的？三色标记法？](#你提到了remark-那它remark具体是怎么执行的-三色标记法)\n\n是的，remark 阶段通常会结合三色标记法来执行，确保在并发标记期间所有存活对象都被正确标记。目的是修正并发标记阶段中可能遗漏的对象引用变化。\n\n在 remark 阶段，垃圾收集器会停止应用线程，以确保在这个阶段不会有引用关系的进一步变化。这种暂停通常很短暂。remark 阶段主要包括以下操作：\n\n1. 处理写屏障记录的引用变化：在并发标记阶段，应用程序可能会更新对象的引用（比如一个黑色对象新增了对一个白色对象的引用），这些变化通过写屏障记录下来。在 remark 阶段，GC 会处理这些记录，确保所有可达对象都正确地标记为灰色或黑色。\n2. 扫描灰色对象：再次遍历灰色对象，处理它们的所有引用，确保引用的对象正确标记为灰色或黑色。\n3. 清理：确保所有引用关系正确处理后，灰色对象标记为黑色，白色对象保持不变。这一步完成后，所有存活对象都应当是黑色的。\n\n#### [什么是三色标记法？](#什么是三色标记法)\n\n\n\n三色标记法用于标记对象的存活状态，它将对象分为三类：\n\n1. 白色（White）：尚未访问的对象。垃圾回收结束后，仍然为白色的对象会被认为是不可达的对象，可以回收。\n2. 灰色（Gray）：已经访问到但未标记完其引用的对象。灰色对象是需要进一步处理的。\n3. 黑色（Black）：已经访问到并且其所有引用对象都已经标记过。黑色对象是完全处理过的，不需要再处理。\n\n三色标记法的工作流程：\n\n①、初始标记（Initial Marking）：从 GC Roots 开始，标记所有直接可达的对象为灰色。\n\n②、并发标记（Concurrent Marking）：在此阶段，标记所有灰色对象引用的对象为灰色，然后将灰色对象自身标记为黑色。这个过程是并发的，和应用线程同时进行。\n\n此阶段的一个问题是，应用线程可能在并发标记期间修改对象的引用关系，导致一些对象的标记状态不准确。\n\n③、重新标记（Remarking）：重新标记阶段的目标是处理并发标记阶段遗漏的引用变化。为了确保所有存活对象都被正确标记，remark 需要在 STW 暂停期间执行。\n\n④、使用写屏障（Write Barrier）来捕捉并发标记阶段应用线程对对象引用的更新。通过遍历这些更新的引用来修正标记状态，确保遗漏的对象不会被错误地回收。"
+ },
+ {
+ "id": 190,
+ "question": "G1 垃圾收集器了解吗？",
+ "answer": "G1 在 JDK 1.7 时引入，在 JDK 9 时取代 CMS 成为默认的垃圾收集器。\n\n\n\nG1 把 Java 堆划分为多个大小相等的独立区域Region，每个区域都可以扮演新生代或老年代的角色。\n\n同时，G1 还有一个专门为大对象设计的 Region，叫 Humongous 区。\n\n> 大对象的判定规则是，如果一个大对象超过了一个 Region 大小的 50%，比如每个 Region 是 2M，只要一个对象超过了 1M，就会被放入 Humongous 中。\n\n这种区域化管理使得 G1 可以更灵活地进行垃圾收集，只回收部分区域而不是整个新生代或老年代。\n\nG1 收集器的运行过程大致可划分为这几个步骤：\n\n①、**并发标记**，G1 通过并发标记的方式找出堆中的垃圾对象。并发标记阶段与应用线程同时执行，不会导致应用线程暂停。\n\n②、**混合收集**，在并发标记完成后，G1 会计算出哪些区域的回收价值最高（也就是包含最多垃圾的区域），然后优先回收这些区域。这种回收方式包括了部分新生代区域和老年代区域。\n\n选择回收成本低而收益高的区域进行回收，可以提高回收效率和减少停顿时间。\n\n③、**可预测的停顿**，G1 在垃圾回收期间仍然需要「Stop the World」。不过，G1 在停顿时间上添加了预测机制，用户可以 JVM 启动时指定期望停顿时间，G1 会尽可能地在这个时间内完成垃圾回收。\n\n"
+ },
+ {
+ "id": 191,
+ "question": "有了 CMS，为什么还要引入 G1？",
+ "answer": "| 特性 | CMS | G1 |\n| --- | --- | --- |\n| 设计目标 | 低停顿时间 | 可预测的停顿时间 |\n| 并发性 | 是 | 是 |\n| 内存碎片 | 是，容易产生碎片 | 否，通过区域划分和压缩减少碎片 |\n| 收集代数 | 年轻代和老年代 | 整个堆，但区分年轻代和老年代 |\n| 并发阶段 | 并发标记、并发清理 | 并发标记、并发清理、并发回收 |\n| 停顿时间预测 | 较难预测 | 可配置停顿时间目标 |\n| 容易出现的问题 | 内存碎片、Concurrent Mode Failure | 较少出现长时间停顿 |\n\nCMS 适用于对延迟敏感的应用场景，主要目标是减少停顿时间，但容易产生内存碎片。\n\nG1 则提供了更好的停顿时间预测和内存压缩能力，适用于大内存和多核处理器环境。"
+ },
+ {
+ "id": 192,
+ "question": "你们线上用的什么垃圾收集器？",
+ "answer": "我们生产环境中采用了设计比较优秀的 G1 垃圾收集器，因为它不仅能满足低停顿的要求，而且解决了 CMS 的浮动垃圾问题、内存碎片问题。\n\nG1 非常适合大内存、多核处理器的环境。\n\n> 以上是比较符合面试官预期的回答，但实际上，大多数情况下我们可能还是使用的 JDK 8 默认垃圾收集器。\n\n可以通过以下命令查看当前 JVM 的垃圾收集器：\n\n\n```java\njava -XX:+PrintCommandLineFlags -version\n```\n\n\n`UseParallelGC` = `Parallel Scavenge + Parallel Old`，表示新生代用`Parallel Scavenge`收集器，老年代使用`Parallel Old` 收集器。\n\n因此你也可以这样回答：\n\n我们系统的业务相对复杂，但并发量并不是特别高，所以我们选择了适用于多核处理器、能够并行处理垃圾回收任务，且能提供高吞吐量的`Parallel GC`。\n\n但这个说法不讨喜，你也可以回答：\n\n我们系统采用的是 CMS 收集器，能够最大限度减少应用暂停时间。\n\n#### [工作中项目使用的什么垃圾回收算法？](#工作中项目使用的什么垃圾回收算法)\n\n我们生产环境中采用了设计比较优秀的 G1 垃圾收集器，G1 采用的是分区式标记-整理算法，将堆划分为多个区域，按需回收，适用于大内存和多核环境，能够同时考虑吞吐量和暂停时间。\n\n或者：\n\n我们系统采用的是 CMS 收集器，CMS 采用的是标记-清除算法，能够并发标记和清除垃圾，减少暂停时间，适用于对延迟敏感的应用。\n\n再或者：\n\n我们系统采用的是 Parallel 收集器，Parallel 采用的是年轻代使用复制算法，老年代使用标记-整理算法，适用于高吞吐量要求的应用。"
+ },
+ {
+ "id": 193,
+ "question": "垃圾收集器应该如何选择？",
+ "answer": "如果应用程序只需要一个很小的内存空间（大约 100 MB），或者对停顿时间没有特殊的要求，可以选择 Serial 收集器。\n\n如果优先考虑应用程序的峰值性能，并且没有时间要求，或者可以接受 1 秒或更长的停顿时间，可以选择 Parallel 收集器。\n\n如果响应时间比吞吐量优先级高，或者垃圾收集暂停必须保持在大约 1 秒以内，可以选择 CMS/ G1 收集器。\n\n如果响应时间是高优先级的，或者堆空间比较大，可以选择 ZGC 收集器。"
+ }
+ ]
+ },
+ {
+ "id": 29,
+ "categoryName": "JVM 调优",
+ "questions": [
+ {
+ "id": 194,
+ "question": "用过哪些性能监控的命令行工具？",
+ "answer": "操作系统层面，我用过 top、vmstat、iostat、netstat 等命令，可以监控系统整体的资源使用情况，比如说内存、CPU、IO 使用情况、网络使用情况。\n\nJDK 自带的命令行工具层面，我用过 jps、jstat、jinfo、jmap、jhat、jstack、jcmd 等，可以查看 JVM 运行时信息、内存使用情况、堆栈信息等。\n\n#### [你一般都怎么用jmap？](#你一般都怎么用jmap)\n\n①、我一般会使用 `jmap -heap ` 查看堆内存摘要，包括新生代、老年代、元空间等。\n\n\n\n②、或者使用 `jmap -histo ` 查看对象分布。\n\n\n\n③、还有生成堆转储文件：`jmap -dump:format=b,file= `。\n\n"
+ },
+ {
+ "id": 195,
+ "question": "了解哪些可视化的性能监控工具？",
+ "answer": "我自己用过的可视化工具主要有：\n\n①、JConsole：JDK 自带的监控工具，可以用来监视 Java 应用程序的运行状态，包括内存使用、线程状态、类加载、GC 等。\n\n\n\n②、VisualVM：一个基于 NetBeans 的可视化工具，在很长一段时间内，VisualVM 都是 Oracle 官方主推的故障处理工具。集成了多个 JDK 命令行工具的功能，非常友好。\n\n\n\n③、Java Mission Control：JMC 最初是 JRockit VM 中的诊断工具，但在 Oracle JDK7 Update 40 以后，就绑定到了 HotSpot VM 中。不过后来又被 Oracle 开源出来作为了一个单独的产品。\n\n\n\n#### [用过哪些第三方的工具？](#用过哪些第三方的工具)\n\n①、**MAT**：一个 Java 堆内存分析工具，主要用于分析和查找 Java 堆中的内存泄漏和内存消耗问题；可以从 Java 堆转储文件中分析内存使用情况，并提供丰富的报告，如内存泄漏疑点、最大对象和 GC 根信息；支持通过图形界面查询对象，以及检查对象间的引用关系。\n\n②、**GChisto**：GC 日志分析工具，可以帮助我们优化垃圾收集行为和调整 GC 性能。\n\n③、**JProfiler**：一个全功能的商业化 Java 性能分析工具，提供 CPU、 内存和线程的实时分析。\n\n④、**arthas**：阿里巴巴开源的 Java 诊断工具，主要用于线上的应用诊断；支持在不停机的情况下进行诊断；可以提供包括 JVM 信息查看、监控、Trace 命令、反编译等功能。\n\n⑤、**async-profiler**：一个低开销的性能分析工具，支持生成火焰图，适用于复杂性能问题的分析。"
+ },
+ {
+ "id": 196,
+ "question": "JVM 的常见参数配置知道哪些？",
+ "answer": "#### [配置堆内存大小的参数有哪些？](#配置堆内存大小的参数有哪些)\n\n* `-Xms`：初始堆大小\n* `-Xmx`：最大堆大小\n* `-XX:NewSize=n`：设置年轻代大小\n* `-XX:NewRatio=n`：设置年轻代和年老代的比值。如：n 为 3 表示年轻代和年老代比值为 1：3，年轻代占总和的 1/4\n* `-XX:SurvivorRatio=n`：年轻代中 Eden 区与两个 Survivor 区的比值。如 n=3 表示 Eden 占 3 Survivor 占 2，一个 Survivor 区占整个年轻代的 1/5\n\n#### [配置 GC 收集器的参数有哪些？](#配置-gc-收集器的参数有哪些)\n\n* `-XX:+UseSerialGC`：设置串行收集器\n* `-XX:+UseParallelGC`：设置并行收集器\n* `-XX:+UseParalledlOldGC`：设置并行老年代收集器\n* `-XX:+UseConcMarkSweepGC`：设置并发收集器\n\n#### [配置并行收集的参数有哪些？](#配置并行收集的参数有哪些)\n\n* `-XX:MaxGCPauseMillis=n`：设置最大垃圾回收停顿时间\n* `-XX:GCTimeRatio=n`：设置垃圾回收时间占程序运行时间的比例\n* `-XX:+CMSIncrementalMode`：设置增量模式，适合单 CPU 环境\n* `-XX:ParallelGCThreads=n`：设置并行收集器的线程数\n\n#### [打印 GC 回收的过程日志信息的参数有哪些？](#打印-gc-回收的过程日志信息的参数有哪些)\n\n* `-XX:+PrintGC`：输出 GC 日志\n* `-XX:+PrintGCDetails`：输出 GC 详细日志\n* `-XX:+PrintGCTimeStamps`：输出 GC 的时间戳（以基准时间的形式）\n* `-Xloggc:filename`：日志文件的输出路径"
+ },
+ {
+ "id": 197,
+ "question": "做过 JVM 调优吗？",
+ "answer": "做过。\n\nJVM 调优是一个复杂的过程，调优的对象包括堆内存、垃圾收集器和 JVM 运行时参数等。\n\n\n\n如果堆内存设置过小，可能会导致频繁的垃圾回收。所以在中，启动 JVM 的时候配置了 `-Xms` 和 `-Xmx` 参数，让堆内存最大可用内存为 2G（我用的丐版服务器）。\n\n在项目运行期间，我会使用 JVisualVM 定期观察和分析 GC 日志，如果发现频繁的 Full GC，我会特意关注一下老年代的使用情况。\n\n接着，通过分析 Heap dump 寻找内存泄漏的源头，看看是否有未关闭的资源，长生命周期的大对象等。\n\n之后进行代码优化，比如说减少大对象的创建、优化数据结构的使用方式、减少不必要的对象持有等。"
+ },
+ {
+ "id": 198,
+ "question": "CPU 占用过高怎么排查？",
+ "answer": "\n\n首先，使用 top 命令查看 CPU 占用情况，找到占用 CPU 较高的进程 ID。\n\n\n```shell\ntop\n```\n\n\n接着，使用 jstack 命令查看对应进程的线程堆栈信息。\n\n\n```shell\njstack -l > thread-dump.txt\n```\n\n> 上面 👆🏻 这个命令会将所有线程的堆栈信息输出到 thread-dump.txt 文件中。\n\n然后再使用 top 命令查看进程中线程的占用情况，找到占用 CPU 较高的线程 ID。\n\n\n```shell\ntop -H -p \n```\n\n> 注意，top 命令显示的线程 ID 是十进制的，而 jstack 输出的是十六进制的，所以需要将线程 ID 转换为十六进制。\n\n\n```shell\nprintf \"%x\\n\" PID\n```\n\n\n接着在 jstack 的输出中搜索这个十六进制的线程 ID，找到对应的堆栈信息。\n\n\n```shell\n\"Thread-5\" #21 prio=5 os_prio=0 tid=0x00007f812c018800 nid=0x1a85 runnable [0x00007f811c000000]\n java.lang.Thread.State: RUNNABLE\n at com.example.MyClass.myMethod(MyClass.java:123)\n at ...\n```\n\n\n最后，根据堆栈信息定位到具体的业务方法，查看是否有死循环、频繁的垃圾回收、资源竞争导致的上下文频繁切换等问题。"
+ },
+ {
+ "id": 199,
+ "question": "内存飙高问题怎么排查？",
+ "answer": "内存飚高一般是因为创建了大量的 Java 对象导致的，如果持续飙高则说明垃圾回收跟不上对象创建的速度，或者内存泄漏导致对象无法回收。\n\n排查的方法主要分为以下几步：\n\n第一，先观察垃圾回收的情况，可以通过 `jstat -gc PID 1000` 查看 GC 次数和时间。\n\n或者使用 `jmap -histo PID | head -20` 查看堆内存占用空间最大的前 20 个对象类型。\n\n第二步，通过 jmap 命令 dump 出堆内存信息。\n\n\n\n第三步，使用可视化工具分析 dump 文件，比如说 VisualVM，找到占用内存高的对象，再找到创建该对象的业务代码位置，从代码和业务场景中定位具体问题。\n\n"
+ },
+ {
+ "id": 200,
+ "question": "频繁 minor gc 怎么办？",
+ "answer": "频繁的 Minor GC 通常意味着新生代中的对象频繁地被垃圾回收，可能是因为新生代空间设置的过小，或者是因为程序中存在大量的短生命周期对象（如临时变量）。\n\n可以使用 GC 日志进行分析，查看 GC 的频率和耗时，找到频繁 GC 的原因。\n\n\n```shell\n-XX:+PrintGCDetails -Xloggc:gc.log\n```\n\n\n或者使用监控工具查看堆内存的使用情况，特别是新生代（Eden 和 Survivor 区）的使用情况。\n\n如果是因为新生代空间不足，可以通过 `-Xmn` 增加新生代的大小，减缓新生代的填满速度。\n\n\n```shell\njava -Xmn256m your-app.jar\n```\n\n\n如果对象需要长期存活，但频繁从 Survivor 区晋升到老年代，可以通过 `-XX:SurvivorRatio` 参数调整 Eden 和 Survivor 的比例。默认比例是 8:1，表示 8 个空间用于 Eden，1 个空间用于 Survivor 区。\n\n\n```shell\n-XX:SurvivorRatio=6\n```\n\n\n调整为 6 的话，会减少 Eden 区的大小，增加 Survivor 区的大小，以确保对象在 Survivor 区中存活的时间足够长，避免过早晋升到老年代。"
+ },
+ {
+ "id": 201,
+ "question": "频繁 Full GC 怎么办？",
+ "answer": "频繁的 Full GC 通常意味着老年代中的对象频繁地被垃圾回收，可能是因为老年代空间设置的过小，或者是因为程序中存在大量的长生命周期对象。\n\n#### [该怎么排查 Full GC 频繁问题？](#该怎么排查-full-gc-频繁问题)\n\n我厂会通过专门的性能监控系统，查看 GC 的频率和堆内存的使用情况，然后根据监控数据分析 GC 的原因。\n\n如果是小厂，可以这么回复。\n\n我一般会使用 JDK 的自带工具，包括 jmap、jstat 等。\n\n\n```shell\n# 查看堆内存各区域的使用率以及GC情况\njstat -gcutil -h20 pid 1000\n# 查看堆内存中的存活对象，并按空间排序\njmap -histo pid | head -n20\n# dump堆内存文件\njmap -dump:format=b,file=heap pid\n```\n\n\n或者使用一些可视化的工具，比如 VisualVM、JConsole 等，查看堆内存的使用情况。\n\n假如是因为大对象直接分配到老年代导致的 Full GC 频繁，可以通过 `-XX:PretenureSizeThreshold` 参数设置大对象直接进入老年代的阈值。\n\n或者将大对象拆分成小对象，减少大对象的创建。比如说分页。\n\n假如是因为内存泄漏导致的频繁 Full GC，可以通过分析堆内存 dump 文件找到内存泄漏的对象，再找到内存泄漏的代码位置。\n\n假如是因为长生命周期的对象进入到了老年代，要及时释放资源，比如说 ThreadLocal、数据库连接、IO 资源等。\n\n假如是因为 GC 参数配置不合理导致的频繁 Full GC，可以通过调整 GC 参数来优化 GC 行为。或者直接更换更适合的 GC 收集器，如 G1、ZGC 等。"
+ }
+ ]
+ },
+ {
+ "id": 30,
+ "categoryName": "类加载机制",
+ "questions": [
+ {
+ "id": 202,
+ "question": "了解类的加载机制吗？（补充）",
+ "answer": "> 2024 年 03 月 29 日增补\n\n了解。\n\nJVM 的操作对象是 Class 文件，JVM 把 Class 文件中描述类的数据结构加载到内存中，并对数据进行校验、解析和初始化，最终转化成可以被 JVM 直接使用的类型，这个过程被称为类加载机制。\n\n其中最重要的三个概念就是：类加载器、类加载过程和双亲委派模型。\n\n* **类加载器**：负责加载类文件，将类文件加载到内存中，生成 Class 对象。\n* **类加载过程**：包括加载、验证、准备、解析和初始化等步骤。\n* **双亲委派模型**：当一个类加载器接收到类加载请求时，它会把请求委派给父——类加载器去完成，依次递归，直到最顶层的类加载器，如果父——类加载器无法完成加载请求，子类加载器才会尝试自己去加载。"
+ },
+ {
+ "id": 203,
+ "question": "类加载器有哪些？",
+ "answer": "主要有四种：\n\n①、**启动类加载器**，负责加载 JVM 的核心类库，如 rt.jar 和其他核心库位于`JAVA_HOME/jre/lib`目录下的类。\n\n②、**扩展类加载器**，负责加载`JAVA_HOME/jre/lib/ext`目录下，或者由系统属性`java.ext.dirs`指定位置的类库，由`sun.misc.Launcher$ExtClassLoader` 实现。\n\n③、**应用程序类加载器**，负责加载 classpath 的类库，由`sun.misc.Launcher$AppClassLoader`实现。\n\n我们编写的任何类都是由应用程序类加载器加载的，除非显式使用自定义类加载器。\n\n④、**用户自定义类加载器**，通常用于加载网络上的类、执行热部署（动态加载和替换应用程序的组件），或者为了安全考虑，从不同的源加载类。\n\n通过继承`java.lang.ClassLoader`类来实现。"
+ },
+ {
+ "id": 204,
+ "question": "能说一下类的生命周期吗？",
+ "answer": "一个类从被加载到虚拟机内存中开始，到从内存中卸载，整个生命周期需要经过七个阶段：加载 、验证、准备、解析、初始化、使用和卸载。\n\n"
+ },
+ {
+ "id": 205,
+ "question": "类装载的过程知道吗？",
+ "answer": "知道。\n\n类装载过程包括三个阶段：载入、链接和初始化。\n\n①、载入：将类的二进制字节码加载到内存中。\n\n②、链接可以细分为三个小的阶段：\n\n* 验证：检查类文件格式是否符合 JVM 规范\n* 准备：为类的静态变量分配内存并设置默认值。\n* 解析：将符号引用替换为直接引用。\n\n③、初始化：执行静态代码块和静态变量初始化。\n\n在准备阶段，静态变量已经被赋过默认初始值了，在初始化阶段，静态变量将被赋值为代码期望赋的值。比如说 `static int a = 1;`，在准备阶段，`a` 的值为 0，在初始化阶段，`a` 的值为 1。\n\n换句话说，初始化阶段是在执行类的构造方法，也就是 中看到的 `()`。\n\n#### [载入过程 JVM 会做什么？](#载入过程-jvm-会做什么)\n\n\n\n* 1）通过一个类的全限定名来获取定义此类的二进制字节流。\n* 2）将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。\n* 3）在内存中生成一个代表这个类的 `java.lang.Class` 对象，作为这个类的访问入口。"
+ },
+ {
+ "id": 206,
+ "question": "什么是双亲委派模型？",
+ "answer": "双亲委派模型要求类加载器在加载类时，先委托父加载器尝试加载，只有父加载器无法加载时，子加载器才会加载。\n\n\n\n这个过程会一直向上递归，也就是说，从子加载器到父加载器，再到更上层的加载器，一直到最顶层的启动类加载器。\n\n启动类加载器会尝试加载这个类。如果它能够加载这个类，就直接返回；如果它不能加载这个类，就会将加载任务返回给委托它的子加载器。\n\n子加载器尝试加载这个类。如果子加载器也无法加载这个类，它就会继续向下传递这个加载任务，依此类推。\n\n直到某个加载器能够加载这个类，或者所有加载器都无法加载这个类，最终抛出 ClassNotFoundException。"
+ },
+ {
+ "id": 207,
+ "question": "为什么要用双亲委派模型？",
+ "answer": "**①、避免类的重复加载**：父加载器加载的类，子加载器无需重复加载。\n\n**②、保证核心类库的安全性**：如 `java.lang.*` 只能由 Bootstrap ClassLoader 加载，防止被篡改。"
+ },
+ {
+ "id": 208,
+ "question": "如何破坏双亲委派机制？",
+ "answer": "重写 ClassLoader 的 `loadClass()` 方法。\n\n如果不想打破双亲委派模型，就重写 ClassLoader 类中的 `findClass()` 方法，那些无法被父类加载器加载的类最终会通过这个方法被加载。"
+ },
+ {
+ "id": 209,
+ "question": "有哪些破坏双亲委派模型的典型例子？",
+ "answer": "我了解的有两种：\n\n* 第一种：SPI 机制加载 JDBC 驱动。\n* 第二种：热部署框架。\n\n\n\n#### [说说SPI 机制？](#说说spi-机制)\n\nSPI 是 Java 的一种扩展机制，用于加载和注册第三方类库，常见于 JDBC、JNDI 等框架。\n\n双亲委派模型会优先让父类加载器加载类，而 SPI 需要动态加载子类加载器中的实现。\n\n根据双亲委派模型，`java.sql.Driver` 类应该由父加载器加载，但父类加载器无法加载由子类加载器定义的驱动类，如 MySQL 的 `com.mysql.cj.jdbc.Driver`。\n\n那么只能使用 SPI 机制通过 `META-INF/services` 文件指定服务提供者的实现类。\n\n\n```java\nClassLoader cl = Thread.currentThread().getContextClassLoader();\nEnumeration drivers = ServiceLoader.load(Driver.class, cl).iterator();\n```\n\n\nDriverManager 使用了线程上下文类加载器来加载 SPI 的实现类，从而允许子类加载器加载具体的 JDBC 驱动。\n\n#### [说说热部署？](#说说热部署)\n\n热部署是指在不重启服务器的情况下更新应用程序代码，需要替换旧版本的类，但旧版本的类可能由父加载器加载。\n\n如 Spring Boot 的 DevTools 通常会自定义类加载器，优先加载新的类版本。"
+ },
+ {
+ "id": 210,
+ "question": "Tomcat 的类加载机制了解吗？",
+ "answer": "了解。\n\nTomcat 基于双亲委派模型进行了一些扩展，主要的类加载器有：\n\n* Bootstrap ClassLoader：加载 Java 的核心类库；\n* Catalina ClassLoader：加载 Tomcat 的核心类库；\n* Shared ClassLoader：加载共享类库，允许多个 Web 应用共享某些类库；\n* WebApp ClassLoader：加载 Web 应用程序的类库，支持多应用隔离和优先加载应用自定义的类库（破坏了双亲委派模型）。\n\n"
+ },
+ {
+ "id": 211,
+ "question": "你觉得应该怎么实现一个热部署功能？",
+ "answer": "热部署是指在不重启服务器的情况下，动态加载、更新或卸载应用程序的组件，比如类、配置文件等。\n\n需要在类加载器的基础上，实现类的重新加载。\n\n我的思路是：\n\n第一步，使用文件监控机制，如 Java NIO 的 WatchService 来监控类文件或配置文件的变化。当监控到文件变更时，触发热部署流程。\n\n\n```java\nclass FileWatcher {\n\n public static void watchDirectoryPath(Path path) {\n // 检查路径是否是有效目录\n if (!isDirectory(path)) {\n System.err.println(\"Provided path is not a directory: \" + path);\n return;\n }\n\n System.out.println(\"Starting to watch path: \" + path);\n\n // 获取文件系统的 WatchService\n try (WatchService watchService = path.getFileSystem().newWatchService()) {\n // 注册目录监听服务，监听创建、修改和删除事件\n path.register(watchService, ENTRY_CREATE, ENTRY_MODIFY, ENTRY_DELETE);\n\n while (true) {\n WatchKey key;\n try {\n // 阻塞直到有事件发生\n key = watchService.take();\n } catch (InterruptedException e) {\n System.out.println(\"WatchService interrupted, stopping directory watch.\");\n Thread.currentThread().interrupt();\n break;\n }\n\n // 处理事件\n for (WatchEvent event : key.pollEvents()) {\n processEvent(event);\n }\n\n // 重置 key，如果失败则退出\n if (!key.reset()) {\n System.out.println(\"WatchKey no longer valid. Exiting watch loop.\");\n break;\n }\n }\n } catch (IOException e) {\n System.err.println(\"An error occurred while setting up the WatchService: \" + e.getMessage());\n e.printStackTrace();\n }\n }\n\n private static boolean isDirectory(Path path) {\n return Files.isDirectory(path, LinkOption.NOFOLLOW_LINKS);\n }\n\n private static void processEvent(WatchEvent event) {\n WatchEvent.Kind kind = event.kind();\n\n // 处理事件类型\n if (kind == OVERFLOW) {\n System.out.println(\"Event overflow occurred. Some events might have been lost.\");\n return;\n }\n\n @SuppressWarnings(\"unchecked\")\n Path fileName = ((WatchEvent) event).context();\n System.out.println(\"Event: \" + kind.name() + \", File affected: \" + fileName);\n }\n\n public static void main(String[] args) {\n // 设置监控路径为当前目录\n Path pathToWatch = Paths.get(\".\");\n watchDirectoryPath(pathToWatch);\n }\n}\n```\n\n\n第二步，创建一个自定义类加载器，继承`java.lang.ClassLoader`，并重写`findClass()`方法，用来加载新的类文件。\n\n\n```java\nclass HotSwapClassLoader extends ClassLoader {\n public HotSwapClassLoader() {\n super(ClassLoader.getSystemClassLoader());\n }\n\n @Override\n protected Class findClass(String name) throws ClassNotFoundException {\n // 加载指定路径下的类文件字节码\n byte[] classBytes = loadClassData(name);\n if (classBytes == null) {\n throw new ClassNotFoundException(name);\n }\n // 调用defineClass将字节码转换为Class对象\n return defineClass(name, classBytes, 0, classBytes.length);\n }\n\n private byte[] loadClassData(String name) {\n // 实现从文件系统或其他来源加载类文件的字节码\n // ...\n return null;\n }\n}\n```\n\n\n友情提示：Intellij IDEA 提供了热部署功能，当我们修改了代码后，IDEA 会自动保存并编译，如果是 Web 项目，还可以在 Chrome 浏览器中装一个 LiveReload 插件，一旦编译完成，页面就会自动刷新看到最新的效果。对于测试或者调试来说，非常方便。"
+ },
+ {
+ "id": 212,
+ "question": "说说解释执行和编译执行的区别（补充）",
+ "answer": "> 2024 年 03 月 08 日增补\n\n先说解释和编译的区别：\n\n* 解释：将源代码逐行转换为机器码。\n* 编译：将源代码一次性转换为机器码。\n\n一个是逐行，一个是一次性，再来说说解释执行和编译执行的区别：\n\n* 解释执行：程序运行时，将源代码逐行转换为机器码，然后执行。\n* 编译执行：程序运行前，将源代码一次性转换为机器码，然后执行。\n\nJava 一般被称为“解释型语言”，因为 Java 代码在执行前，需要先将源代码编译成字节码，然后在运行时，再由 JVM 的解释器“逐行”将字节码转换为机器码，然后执行。\n\n这也是 Java 被诟病“慢”的主要原因。\n\n但 JIT 的出现打破了这种刻板印象，JVM 会将热点代码（即运行频率高的代码）编译后放入 CodeCache，当下次执行再遇到这段代码时，会从 CodeCache 中直接读取机器码，然后执行。\n\n因此，Java 的执行效率得到了大幅提升。\n\n"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 5,
+ "topicName": "Spring",
+ "categories": [
+ {
+ "id": 31,
+ "categoryName": "基础",
+ "questions": [
+ {
+ "id": 213,
+ "question": "Spring 是什么？特性？有哪些模块？",
+ "answer": "\n\n一句话概括：**Spring 是一个轻量级、非入侵式的控制反转 (IoC) 和面向切面 (AOP) 的框架。**\n\n2003 年，一个音乐家 Rod Johnson 决定发展一个轻量级的 Java 开发框架，`Spring`作为 Java 战场的龙骑兵渐渐崛起，并淘汰了`EJB`这个传统的重装骑兵。\n\n\n\n到了现在，企业级开发的标配基本就是 **Spring5** + **Spring Boot 2** + **JDK 8**\n\n#### [Spring 有哪些特性呢？](#spring-有哪些特性呢)\n\n\n\n1. **IoC** 和 **DI** 的支持\n\nSpring 的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring 工厂用于生成 Bean，并且管理 Bean 的生命周期，实现**高内聚低耦合**的设计理念。\n\n2. AOP 编程的支持\n\nSpring 提供了**面向切面编程**，可以方便的实现对程序进行权限拦截、运行监控等切面功能。\n\n3. 声明式事务的支持\n\n支持通过配置就来完成对事务的管理，而不需要通过硬编码的方式，以前重复的一些事务提交、回滚的 JDBC 代码，都可以不用自己写了。\n\n4. 快捷测试的支持\n\nSpring 对 Junit 提供支持，可以通过**注解**快捷地测试 Spring 程序。\n\n5. 快速集成功能\n\n方便集成各种优秀框架，Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz 等）的直接支持。\n\n6. 复杂 API 模板封装\n\nSpring 对 JavaEE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等）都提供了模板化的封装，这些封装 API 的提供使得应用难度大大降低。\n\n#### [简单说一下什么是AOP 和 IoC？](#简单说一下什么是aop-和-ioc)\n\n**AOP**：面向切面编程，是一种编程范式，它的主要作用是将那些与核心业务逻辑无关，但是对多个对象产生影响的公共行为封装起来，如日志记录、性能统计、事务等。\n\n**IoC**：控制反转，是一种设计思想，它的主要作用是将对象的创建和对象之间的调用过程交给 Spring 容器来管理。\n\n#### [Spring源码看过吗？](#spring源码看过吗)\n\n看过一些，主要就是针对 Spring 循环依赖、Bean 声明周期、AOP、事务、IOC 这五部分。\n\n\n\nPS：关于这份小册的 PDF 版本，目前只有的用户可以获取，后续会考虑开放给大家。\n\n"
+ },
+ {
+ "id": 214,
+ "question": "Spring 有哪些模块呢？",
+ "answer": "Spring 框架是分模块存在，除了最核心的`Spring Core Container`是必要模块之外，其他模块都是`可选`，大约有 20 多个模块。\n\n\n\n最主要的七大模块：\n\n1. **Spring Core**：Spring 核心，它是框架最基础的部分，提供 IoC 和依赖注入 DI 特性。\n2. **Spring Context**：Spring 上下文容器，它是 BeanFactory 功能加强的一个子接口。\n3. **Spring Web**：它提供 Web 应用开发的支持。\n4. **Spring MVC**：它针对 Web 应用中 MVC 思想的实现。\n5. **Spring DAO**：提供对 JDBC 抽象层，简化了 JDBC 编码，同时，编码更具有健壮性。\n6. **Spring ORM**：它支持用于流行的 ORM 框架的整合，比如：Spring + Hibernate、Spring + iBatis、Spring + JDO 的整合等。\n7. **Spring AOP**：即面向切面编程，它提供了与 AOP 联盟兼容的编程实现。"
+ },
+ {
+ "id": 215,
+ "question": "Spring 有哪些常用注解呢？",
+ "answer": "Spring 提供了大量的注解来简化 Java 应用的开发和配置，主要用于 Web 开发、往容器注入 Bean、AOP、事务控制等。\n\n\n\n#### [Web 开发方面有哪些注解呢？](#web-开发方面有哪些注解呢)\n\n①、`@Controller`：用于标注控制层组件。\n\n②、`@RestController`：是`@Controller` 和 `@ResponseBody` 的结合体，返回 JSON 数据时使用。\n\n③、`@RequestMapping`：用于映射请求 URL 到具体的方法上，还可以细分为：\n\n* `@GetMapping`：只能用于处理 GET 请求\n* `@PostMapping`：只能用于处理 POST 请求\n* `@DeleteMapping`：只能用于处理 DELETE 请求\n\n④、`@ResponseBody`：直接将返回的数据放入 HTTP 响应正文中，一般用于返回 JSON 数据。\n\n⑤、`@RequestBody`：表示一个方法参数应该绑定到 Web 请求体。\n\n⑥、`@PathVariable`：用于接收路径参数，比如 `@RequestMapping(“/hello/{name}”)`，这里的 name 就是路径参数。\n\n⑦、`@RequestParam`：用于接收请求参数。比如 `@RequestParam(name = \"key\") String key`，这里的 key 就是请求参数。\n\n#### [容器类注解有哪些呢？](#容器类注解有哪些呢)\n\n* `@Component`：标识一个类为 Spring 组件，使其能够被 Spring 容器自动扫描和管理。\n* `@Service`：标识一个业务逻辑组件（服务层）。比如 `@Service(\"userService\")`，这里的 userService 就是 Bean 的名称。\n* `@Repository`：标识一个数据访问组件（持久层）。\n* `@Autowired`：按类型自动注入依赖。\n* `@Configuration`：用于定义配置类，可替换 XML 配置文件。\n* `@Value`：用于将 Spring Boot 中 application.properties 配置的属性值赋值给变量。\n\n#### [AOP 方面有哪些注解呢？](#aop-方面有哪些注解呢)\n\n`@Aspect` 用于声明一个切面，可以配合其他注解一起使用，比如：\n\n* `@After`：在方法执行之后执行。\n* `@Before`：在方法执行之前执行。\n* `@Around`：方法前后均执行。\n* `@PointCut`：定义切点，指定需要拦截的方法。\n\n#### [事务注解有哪些？](#事务注解有哪些)\n\n主要就是 `@Transactional`，用于声明一个方法需要事务支持。"
+ },
+ {
+ "id": 216,
+ "question": "Spring 中应用了哪些设计模式呢？",
+ "answer": "Spring 框架中用了蛮多设计模式的：\n\n\n\n①、比如说工厂模式用于 BeanFactory 和 ApplicationContext，实现 Bean 的创建和管理。\n\n\n```java\nApplicationContext context = new ClassPathXmlApplicationContext(\"applicationContext.xml\");\nMyBean myBean = context.getBean(MyBean.class);\n```\n\n\n②、比如说单例模式，这样可以保证 Bean 的唯一性，减少系统开销。\n\n\n```java\nApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);\nMyService myService1 = context.getBean(MyService.class);\nMyService myService2 = context.getBean(MyService.class);\n\n// This will print \"true\" because both references point to the same instance\nSystem.out.println(myService1 == myService2);\n```\n\n\n③、比如说 AOP 使用了代理模式来实现横切关注点（如事务管理、日志记录、权限控制等）。\n\n\n```java\n@Transactional\npublic void myTransactionalMethod() {\n // 方法实现\n}\n```\n\n\n#### [Spring如何实现单例模式？](#spring如何实现单例模式)\n\nSpring 通过 IOC 容器实现单例模式，具体步骤是：\n\n单例 Bean 在容器初始化时创建并使用 DefaultSingletonBeanRegistry 提供的 singletonObjects 进行缓存。\n\n\n```java\n// 单例缓存\nprivate final Map singletonObjects = new ConcurrentHashMap<>();\n\npublic Object getSingleton(String beanName) {\n return this.singletonObjects.get(beanName);\n}\n\nprotected void addSingleton(String beanName, Object singletonObject) {\n this.singletonObjects.put(beanName, singletonObject);\n}\n```\n\n\n在请求 Bean 时，Spring 会先从缓存中获取。"
+ },
+ {
+ "id": 217,
+ "question": "Spring 容器、Web 容器之间的区别？（补充）",
+ "answer": "> 2024 年 7 月 11 日增补\n\nSpring 容器是 Spring 框架的核心部分，负责管理应用程序中的对象生命周期和依赖注入。\n\nWeb 容器（也称 Servlet 容器），是用于运行 Java Web 应用程序的服务器环境，支持 Servlet、JSP 等 Web 组件。常见的 Web 容器包括 Apache Tomcat、Jetty等。\n\nSpring MVC 是 Spring 框架的一部分，专门用于处理 Web 请求，基于 MVC（Model-View-Controller）设计模式。"
+ }
+ ]
+ },
+ {
+ "id": 32,
+ "categoryName": "IoC",
+ "questions": [
+ {
+ "id": 218,
+ "question": "说一说什么是 IoC、DI？",
+ "answer": "所谓的**IoC**，就是由容器来控制对象的生命周期和对象之间的关系。控制对象生命周期的不再是引用它的对象，而是容器，这就叫**控制反转**（Inversion of Control）。\n\n\n\n以前是我们想要什么就自己创建什么，现在是我们需要什么容器就帮我们送来什么。\n\n\n\n没有 IoC 之前：\n\n有了 IoC 之后：\n\n> 我需要一个女朋友，于是我就去找婚介所，告诉婚介所，我需要一个长的像赵露思的，会打 Dota2 的，于是婚介所在它的人才库里开始找，找不到它就直接说没有，找到它就直接介绍给我。\n\n婚介所就相当于一个 IoC 容器，我就是一个对象，我需要的女朋友就是另一个对象，我不用关心女朋友是怎么来的，我只需要告诉婚介所我需要什么样的女朋友，婚介所就帮我去找。\n\nSpring 倡导的开发方式就是这样，所有类的创建和销毁都通过 Spring 容器来，不再是开发者去 new，去 `= null`，这样就实现了对象的解耦。\n\n于是，对于某个对象来说，以前是它控制它依赖的对象，现在是所有对象都被 Spring 控制。\n\n\n\n#### [说说什么是 DI？](#说说什么是-di)\n\nIOC 是一种思想，DI 是实现 IOC 的具体方式，比如说利用注入机制（如构造器注入、Setter 注入）将依赖传递给目标对象。\n\n\n\n2004 年，Martin Fowler 在他的文章《控制反转容器&依赖注入模式》首次提出了 **DI（依赖注入，Dependency Injection）** 这个名词。\n\n打个比方，你现在想吃韭菜馅的饺子，这时候就有人用针管往你吃的饺子里注入韭菜鸡蛋馅。就好像 A 类需要 B 类，以前是 A 类自己 new 一个 B 类，现在是有人把 B 类注入到 A 类里。\n\n#### [为什么要使用 IoC 呢？](#为什么要使用-ioc-呢)\n\n在平时的 Java 开发中，如果我们要实现某一个功能，可能至少需要两个以上的对象来协助完成，在没有 Spring 之前，每个对象在需要它的合作对象时，需要自己 new 一个，比如说 A 要使用 B，A 就对 B 产生了依赖，也就是 A 和 B 之间存在了一种耦合关系。\n\n有了 Spring 之后，就不一样了，创建 B 的工作交给了 Spring 来完成，Spring 创建好了 B 对象后就放到容器中，A 告诉 Spring 我需要 B，Spring 就从容器中取出 B 交给 A 来使用。\n\n至于 B 是怎么来的，A 就不再关心了，Spring 容器想通过 newnew 创建 B 还是 new 创建 B，无所谓。\n\n这就是 IoC 的好处，它降低了对象之间的耦合度，使得程序更加灵活，更加易于维护。"
+ },
+ {
+ "id": 219,
+ "question": "能简单说一下 Spring IoC 的实现机制吗？",
+ "answer": "PS:这道题老三在面试中被问到过，问法是“**你有自己实现过简单的 Spring 吗？**”\n\nSpring 的 IoC 本质就是一个大工厂，我们想想一个工厂是怎么运行的呢？\n\n\n\n* **生产产品**：一个工厂最核心的功能就是生产产品。在 Spring 里，不用 Bean 自己来实例化，而是交给 Spring，应该怎么实现呢？——答案毫无疑问，**反射**。\n\n 那么这个厂子的生产管理是怎么做的？你应该也知道——**工厂模式**。\n* **库存产品**：工厂一般都是有库房的，用来库存产品，毕竟生产的产品不能立马就拉走。Spring 我们都知道是一个容器，这个容器里存的就是对象，不能每次来取对象，都得现场来反射创建对象，得把创建出的对象存起来。\n* **订单处理**：还有最重要的一点，工厂根据什么来提供产品呢？订单。这些订单可能五花八门，有线上签签的、有到工厂签的、还有工厂销售上门签的……最后经过处理，指导工厂的出货。\n\n 在 Spring 里，也有这样的订单，它就是我们 bean 的定义和依赖关系，可以是 xml 形式，也可以是我们最熟悉的注解形式。\n\n我们简单地实现一个 mini 版的 Spring IoC：\n\n\n\n**Bean 定义：**\n\nBean 通过一个配置文件定义，把它解析成一个类型。\n\n* beans.properties\n\n 偷懒，这里直接用了最方便解析的 properties，这里直接用一个``类型的配置来代表 Bean 的定义，其中 key 是 beanName，value 是 class\n\n \n```java\nuserDao:cn.fighter3.bean.UserDao\n```\n\n* BeanDefinition.java\n\n bean 定义类，配置文件中 bean 定义对应的实体\n\n \n```java\npublic class BeanDefinition {\n\n private String beanName;\n\n private Class beanClass;\n //省略getter、setter\n }\n```\n\n* ResourceLoader.java\n\n 资源加载器，用来完成配置文件中配置的加载\n\n \n```java\npublic class ResourceLoader {\n\n public static Map getResource() {\n Map beanDefinitionMap = new HashMap<>(16);\n Properties properties = new Properties();\n try {\n InputStream inputStream = ResourceLoader.class.getResourceAsStream(\"/beans.properties\");\n properties.load(inputStream);\n Iterator it = properties.stringPropertyNames().iterator();\n while (it.hasNext()) {\n String key = it.next();\n String className = properties.getProperty(key);\n BeanDefinition beanDefinition = new BeanDefinition();\n beanDefinition.setBeanName(key);\n Class clazz = Class.forName(className);\n beanDefinition.setBeanClass(clazz);\n beanDefinitionMap.put(key, beanDefinition);\n }\n inputStream.close();\n } catch (IOException | ClassNotFoundException e) {\n e.printStackTrace();\n }\n return beanDefinitionMap;\n }\n\n}\n```\n\n* BeanRegister.java\n\n 对象注册器，这里用于单例 bean 的缓存，我们大幅简化，默认所有 bean 都是单例的。可以看到所谓单例注册，也很简单，不过是往 HashMap 里存对象。\n\n \n```java\npublic class BeanRegister {\n\n //单例Bean缓存\n private Map singletonMap = new HashMap<>(32);\n\n /**\n * 获取单例Bean\n *\n * @param beanName bean名称\n * @return\n */\n public Object getSingletonBean(String beanName) {\n return singletonMap.get(beanName);\n }\n\n /**\n * 注册单例bean\n *\n * @param beanName\n * @param bean\n */\n public void registerSingletonBean(String beanName, Object bean) {\n if (singletonMap.containsKey(beanName)) {\n return;\n }\n singletonMap.put(beanName, bean);\n }\n\n}\n```\n\n* **BeanFactory.java**\n\n\n\n* 对象工厂，我们最**核心**的一个类，在它初始化的时候，创建了 bean 注册器，完成了资源的加载。\n* 获取 bean 的时候，先从单例缓存中取，如果没有取到，就创建并注册一个 bean\n\n \n```java\npublic class BeanFactory {\n\n private Map beanDefinitionMap = new HashMap<>();\n\n private BeanRegister beanRegister;\n\n public BeanFactory() {\n //创建bean注册器\n beanRegister = new BeanRegister();\n //加载资源\n this.beanDefinitionMap = new ResourceLoader().getResource();\n }\n\n /**\n * 获取bean\n *\n * @param beanName bean名称\n * @return\n */\n public Object getBean(String beanName) {\n //从bean缓存中取\n Object bean = beanRegister.getSingletonBean(beanName);\n if (bean != null) {\n return bean;\n }\n //根据bean定义，创建bean\n return createBean(beanDefinitionMap.get(beanName));\n }\n\n /**\n * 创建Bean\n *\n * @param beanDefinition bean定义\n * @return\n */\n private Object createBean(BeanDefinition beanDefinition) {\n try {\n Object bean = beanDefinition.getBeanClass().newInstance();\n //缓存bean\n beanRegister.registerSingletonBean(beanDefinition.getBeanName(), bean);\n return bean;\n } catch (InstantiationException | IllegalAccessException e) {\n e.printStackTrace();\n }\n return null;\n }\n}\n```\n\n* 测试\n\n + UserDao.java\n\n 我们的 Bean 类，很简单\n\n \n```java\npublic class UserDao {\n\n public void queryUserInfo(){\n System.out.println(\"A good man.\");\n }\n}\n```\n\n + 单元测试\n\n \n```java\npublic class ApiTest {\n @Test\n public void test_BeanFactory() {\n //1.创建bean工厂(同时完成了加载资源、创建注册单例bean注册器的操作)\n BeanFactory beanFactory = new BeanFactory();\n\n //2.第一次获取bean（通过反射创建bean，缓存bean）\n UserDao userDao1 = (UserDao) beanFactory.getBean(\"userDao\");\n userDao1.queryUserInfo();\n\n //3.第二次获取bean（从缓存中获取bean）\n UserDao userDao2 = (UserDao) beanFactory.getBean(\"userDao\");\n userDao2.queryUserInfo();\n }\n}\n```\n\n + 运行结果\n\n \n```java\nA good man.\nA good man.\n```\n\n\n至此，我们一个乞丐+破船版的 Spring 就完成了，代码也比较完整，有条件的可以跑一下。\n\nPS:因为时间+篇幅的限制，这个 demo 比较简陋，没有面向接口、没有解耦、边界检查、异常处理……健壮性、扩展性都有很大的不足，感兴趣可以学习参考[15]。"
+ },
+ {
+ "id": 220,
+ "question": "说说 BeanFactory 和 ApplicantContext?",
+ "answer": "可以这么比喻，BeanFactory 是 Spring 的“心脏”，而 ApplicantContext 是 Spring 的完整“身躯”。\n\n* BeanFactory 主要负责配置、创建和管理 bean，为 Spring 提供了基本的依赖注入（DI）支持。\n* ApplicationContext 是 BeanFactory 的子接口，在 BeanFactory 的基础上添加了企业级的功能支持。\n\n\n\n#### [详细说说 BeanFactory](#详细说说-beanfactory)\n\nBeanFactory 位于整个 Spring IoC 容器的顶端，ApplicationContext 算是 BeanFactory 的子接口。\n\n\n\n它最主要的方法就是 `getBean()`，这个方法负责从容器中返回特定名称或者类型的 Bean 实例。\n\n来看一个 XMLBeanFactory（已过时） 获取 bean 的例子：\n\n\n```java\nclass HelloWorldApp{\n public static void main(String[] args) {\n BeanFactory factory = new XmlBeanFactory (new ClassPathResource(\"beans.xml\"));\n HelloWorld obj = (HelloWorld) factory.getBean(\"itwanger\");\n obj.getMessage();\n }\n}\n```\n\n\n#### [请详细说说 ApplicationContext](#请详细说说-applicationcontext)\n\nApplicationContext 继承了 HierachicalBeanFactory 和 ListableBeanFactory 接口，算是 BeanFactory 的自动挡版本，是 Spring 应用的默认方式。\n\n\n\nApplicationContext 会在启动时预先创建和配置所有的单例 bean，并支持如 JDBC、ORM 框架的集成，内置面向切面编程（AOP）的支持，可以配置声明式事务管理等。\n\n这是 ApplicationContext 的使用例子：\n\n\n```java\nclass MainApp {\n public static void main(String[] args) {\n // 使用 AppConfig 配置类初始化 ApplicationContext\n ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);\n\n // 从 ApplicationContext 获取 messageService 的 bean\n MessageService service = context.getBean(MessageService.class);\n\n // 使用 bean\n service.printMessage();\n }\n}\n```\n\n\n通过 AnnotationConfigApplicationContext 类，我们可以使用 Java 配置类来初始化 ApplicationContext，这样就可以使用 Java 代码来配置 Spring 容器。\n\n\n```java\n@Configuration\n@ComponentScan(basePackages = \"com.github.paicoding.forum.test.javabetter.spring1\") // 替换为你的包名\npublic class AppConfig {\n}\n```"
+ },
+ {
+ "id": 221,
+ "question": "你知道 Spring 容器启动阶段会干什么吗？",
+ "answer": "Spring 的 IoC 容器工作的过程，其实可以划分为两个阶段：**容器启动阶段**和**Bean 实例化阶段**。\n\n其中容器启动阶段主要做的工作是加载和解析配置文件，保存到对应的 Bean 定义中。\n\n\n\n容器启动开始，首先会通过某种途径加载 Configuration MetaData，在大部分情况下，容器需要依赖某些工具类（BeanDefinitionReader）对加载的 Configuration MetaData 进行解析和分析，并将分析后的信息组为相应的 BeanDefinition。\n\n\n\n最后把这些保存了 Bean 定义必要信息的 BeanDefinition，注册到相应的 BeanDefinitionRegistry，这样容器启动就完成了。\n\n#### [说说 Spring 的 Bean 实例化方式](#说说-spring-的-bean-实例化方式)\n\nSpring 提供了 4 种不同的方式来实例化 Bean，以满足不同场景下的需求。\n\n#### [说说构造方法的方式](#说说构造方法的方式)\n\n在类上使用@Component（或@Service、@Repository 等特定于场景的注解）标注类，然后通过构造方法注入依赖。\n\n\n```java\n@Component\npublic class ExampleBean {\n private DependencyBean dependency;\n\n @Autowired\n public ExampleBean(DependencyBean dependency) {\n this.dependency = dependency;\n }\n}\n```\n\n\n#### [说说静态工厂的方式](#说说静态工厂的方式)\n\n在这种方式中，Bean 是由一个静态方法创建的，而不是直接通过构造方法。\n\n\n```java\npublic class ClientService {\n private static ClientService clientService = new ClientService();\n\n private ClientService() {}\n\n public static ClientService createInstance() {\n return clientService;\n }\n}\n```\n\n\n#### [说说实例工厂方法实例化的方式](#说说实例工厂方法实例化的方式)\n\n与静态工厂方法相比，实例工厂方法依赖于某个类的实例来创建 Bean。这通常用在需要通过工厂对象的非静态方法来创建 Bean 的场景。\n\n\n```java\npublic class ServiceLocator {\n public ClientService createClientServiceInstance() {\n return new ClientService();\n }\n}\n```\n\n\n#### [说说 FactoryBean 接口实例化方式](#说说-factorybean-接口实例化方式)\n\nFactoryBean 是一个特殊的 Bean 类型，可以在 Spring 容器中返回其他对象的实例。通过实现 FactoryBean 接口，可以自定义实例化逻辑，这对于构建复杂的初始化逻辑非常有用。\n\n\n```java\npublic class ToolFactoryBean implements FactoryBean {\n private int factoryId;\n private int toolId;\n\n @Override\n public Tool getObject() throws Exception {\n return new Tool(toolId);\n }\n\n @Override\n public Class getObjectType() {\n return Tool.class;\n }\n\n @Override\n public boolean isSingleton() {\n return true;\n }\n\n // setter and getter methods for factoryId and toolId\n}\n```"
+ },
+ {
+ "id": 222,
+ "question": "你是怎么理解 Bean 的？",
+ "answer": "Bean 是指由 Spring 容器管理的对象，它的生命周期由容器控制，包括创建、初始化、使用和销毁。以通过三种方式声明：**注解方式**、**XML 配置**、**Java 配置**。\n\n\n\n①、使用 `@Component`、`@Service`、`@Repository`、`@Controller` 等注解定义，主流。\n\n②、基于 XML 配置，Spring Boot 项目已经不怎么用了。\n\n③、使用 Java 配置类创建 Bean：\n\n\n```java\n@Configuration\npublic class AppConfig {\n @Bean\n public UserService userService() {\n return new UserService();\n }\n}\n```\n\n\n#### [@Component 和 @Bean 的区别](#component-和-bean-的区别)\n\n`@Component` 是 Spring 提供的一个类级别注解，由 Spring 自动扫描并注册到 Spring 容器中。\n\n`@Bean` 是一个方法级别的注解，用于显式地声明一个 Bean，当我们需要第三方库或者无法使用 `@Component` 注解类时，可以使用 `@Bean` 来将其实例注册到容器中。"
+ },
+ {
+ "id": 223,
+ "question": "能说一下 Bean 的生命周期吗？",
+ "answer": "Bean 的生命周期大致分为五个阶段：\n\n\n\n* **实例化**：Spring 首先使用构造方法或者工厂方法创建一个 Bean 的实例。在这个阶段，Bean 只是一个空的 Java 对象，还未设置任何属性。\n* **属性赋值**：Spring 将配置文件中的属性值或依赖的 Bean 注入到该 Bean 中。这个过程称为依赖注入，确保 Bean 所需的所有依赖都被注入。\n* **初始化**：Spring 调用 afterPropertiesSet 方法，或通过配置文件指定的 init-method 方法，完成初始化。\n* **使用中**：Bean 准备好可以使用了。\n* **销毁**：在容器关闭时，Spring 会调用 destroy 方法，完成 Bean 的清理工作。\n\n#### [可以从源码角度讲一下吗？](#可以从源码角度讲一下吗)\n\n\n\n* **实例化**：Spring 容器根据 Bean 的定义创建 Bean 的实例，相当于执行构造方法，也就是 new 一个对象。\n* **属性赋值**：相当于执行 setter 方法为字段赋值。\n* **初始化**：初始化阶段允许执行自定义的逻辑，比如设置某些必要的属性值、开启资源、执行预加载操作等，以确保 Bean 在使用之前是完全配置好的。\n* **销毁**：相当于执行 `= null`，释放资源。\n\n可以在源码 `AbstractAutowireCapableBeanFactory` 中的 `doCreateBean` 方法中，看到 Bean 的前三个生命周期：\n\n\n```java\nprotected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {\n BeanWrapper instanceWrapper = null;\n if (mbd.isSingleton()) {\n instanceWrapper = (BeanWrapper)this.factoryBeanInstanceCache.remove(beanName);\n }\n\n if (instanceWrapper == null) {\n // 实例化阶段\n instanceWrapper = this.createBeanInstance(beanName, mbd, args);\n }\n\n ...\n\n Object exposedObject = bean;\n\n try {\n // 属性赋值阶段\n this.populateBean(beanName, mbd, instanceWrapper);\n // 初始化阶段\n exposedObject = this.initializeBean(beanName, exposedObject, mbd);\n } catch (Throwable var18) {\n ...\n }\n\n ...\n}\n```\n\n\n源码位置，见下图：\n\n\n\n至于销毁，是在容器关闭的时候调用的，详见 `ConfigurableApplicationContext` 的 `close` 方法。\n\n\n\n#### [请在一个已有的 Spring Boot 项目中通过单元测试的形式来展示 Spring Bean 的生命周期？](#请在一个已有的-spring-boot-项目中通过单元测试的形式来展示-spring-bean-的生命周期)\n\n第一步，创建一个 LifecycleDemoBean 类：\n\n\n```java\npublic class LifecycleDemoBean implements InitializingBean, DisposableBean {\n\n // 使用@Value注解注入属性值，这里演示了如何从配置文件中读取值\n // 如果配置文件中没有定义lifecycle.demo.bean.name，则使用默认值\"default name\"\n @Value(\"${lifecycle.demo.bean.name:default name}\")\n private String name;\n\n // 构造方法：在Bean实例化时调用\n public LifecycleDemoBean() {\n System.out.println(\"LifecycleDemoBean: 实例化\");\n }\n\n // 属性赋值：Spring通过反射调用setter方法为Bean的属性注入值\n public void setName(String name) {\n System.out.println(\"LifecycleDemoBean: 属性赋值\");\n this.name = name;\n }\n\n // 使用@PostConstruct注解的方法：在Bean的属性赋值完成后调用，用于执行初始化逻辑\n @PostConstruct\n public void postConstruct() {\n System.out.println(\"LifecycleDemoBean: @PostConstruct（初始化）\");\n }\n\n // 实现InitializingBean接口：afterPropertiesSet方法在@PostConstruct注解的方法之后调用\n // 用于执行更多的初始化逻辑\n @Override\n public void afterPropertiesSet() throws Exception {\n System.out.println(\"LifecycleDemoBean: afterPropertiesSet（InitializingBean）\");\n }\n\n // 自定义初始化方法：在XML配置或Java配置中指定，执行特定的初始化逻辑\n public void customInit() {\n System.out.println(\"LifecycleDemoBean: customInit（自定义初始化方法）\");\n }\n\n // 使用@PreDestroy注解的方法：在容器销毁Bean之前调用，用于执行清理工作\n @PreDestroy\n public void preDestroy() {\n System.out.println(\"LifecycleDemoBean: @PreDestroy（销毁前）\");\n }\n\n // 实现DisposableBean接口：destroy方法在@PreDestroy注解的方法之后调用\n // 用于执行清理资源等销毁逻辑\n @Override\n public void destroy() throws Exception {\n System.out.println(\"LifecycleDemoBean: destroy（DisposableBean）\");\n }\n\n // 自定义销毁方法：在XML配置或Java配置中指定，执行特定的清理逻辑\n public void customDestroy() {\n System.out.println(\"LifecycleDemoBean: customDestroy（自定义销毁方法）\");\n }\n}\n```\n\n\n**①、实例化**\n\n实例化是创建 Bean 实例的过程，即在内存中为 Bean 对象分配空间。这一步是通过调用 Bean 的构造方法完成的。\n\n\n```java\npublic LifecycleDemoBean() {\n System.out.println(\"LifecycleDemoBean: 实例化\");\n}\n```\n\n\n在这里，当 Spring 创建 LifecycleDemoBean 的实例时，会调用其无参数的构造方法，这个过程就是实例化。\n\n**②、属性赋值**\n\n在实例化之后，Spring 将根据 Bean 定义中的配置信息，通过反射机制为 Bean 的属性赋值。\n\n\n```java\n@Value(\"${lifecycle.demo.bean.name:default name}\")\nprivate String name;\n\npublic void setName(String name) {\n System.out.println(\"LifecycleDemoBean: 属性赋值\");\n this.name = name;\n}\n```\n\n\n`@Value`注解和 setter 方法体现了属性赋值的过程。`@Value`注解让 Spring 注入配置值（或默认值），setter 方法则是属性赋值的具体操作。\n\n**③、初始化**\n\n初始化阶段允许执行自定义的初始化逻辑，比如检查必要的属性是否已经设置、开启资源等。Spring 提供了多种方式来配置初始化逻辑。\n\n1、使用 `@PostConstruct` 注解的方法\n\n\n```java\n@PostConstruct\npublic void postConstruct() {\n System.out.println(\"LifecycleDemoBean: @PostConstruct（初始化）\");\n}\n```\n\n\n`@PostConstruct`注解的方法在 Bean 的所有属性都被赋值后，且用户自定义的初始化方法之前调用。\n\n2、实现 `InitializingBean` 接口的 `afterPropertiesSet` 方法\n\n\n```java\n@Override\npublic void afterPropertiesSet() throws Exception {\n System.out.println(\"LifecycleDemoBean: afterPropertiesSet（InitializingBean）\");\n}\n```\n\n\nafterPropertiesSet 方法提供了另一种初始化 Bean 的方式，也是在所有属性赋值后调用。\n\n3、自定义初始化方法\n\n\n```java\npublic void customInit() {\n System.out.println(\"LifecycleDemoBean: customInit（自定义初始化方法）\");\n}\n```\n\n\n需要在配置类中指定初始化方法：\n\n\n```java\n@Bean(initMethod = \"customInit\")\npublic LifecycleDemoBean lifecycleDemoBean() {\n return new LifecycleDemoBean();\n}\n```\n\n\n**④、销毁**\n\n销毁阶段允许执行自定义的销毁逻辑，比如释放资源。类似于初始化阶段，Spring 也提供了多种方式来配置销毁逻辑。\n\n1、使用 `@PreDestroy` 注解的方法\n\n\n```java\n@PreDestroy\npublic void preDestroy() {\n System.out.println(\"LifecycleDemoBean: @PreDestroy（销毁前）\");\n}\n```\n\n\n`@PreDestroy`注解的方法在 Bean 被销毁前调用。\n\n2、实现 `DisposableBean` 接口的 `destroy` 方法\n\n\n```java\n@Override\npublic void destroy() throws Exception {\n System.out.println(\"LifecycleDemoBean: destroy（DisposableBean）\");\n}\n```\n\n\ndestroy 方法提供了另一种销毁 Bean 的方式，也是在 Bean 被销毁前调用。\n\n3、自定义销毁方法\n\n\n```java\npublic void customDestroy() {\n System.out.println(\"LifecycleDemoBean: customDestroy（自定义销毁方法）\");\n}\n```\n\n\n需要在配置类中指定销毁方法：\n\n\n```java\n@Bean(destroyMethod = \"customDestroy\")\npublic LifecycleDemoBean lifecycleDemoBean() {\n return new LifecycleDemoBean();\n}\n```\n\n\n第二步，注册 Bean 并指定自定义初始化方法和销毁方法：\n\n\n```java\n@Configuration\npublic class LifecycleDemoConfig {\n\n @Bean(initMethod = \"customInit\", destroyMethod = \"customDestroy\")\n public LifecycleDemoBean lifecycleDemoBean() {\n return new LifecycleDemoBean();\n }\n}\n```\n\n\n第三步，编写单元测试：\n\n\n```java\n@SpringBootTest\npublic class LifecycleDemoTest {\n\n @Autowired\n private ApplicationContext context;\n\n @Test\n public void testBeanLifecycle() {\n System.out.println(\"获取LifecycleDemoBean实例...\");\n LifecycleDemoBean bean = context.getBean(LifecycleDemoBean.class);\n }\n}\n```\n\n\n运行单元测试，查看控制台输出：\n\n\n```java\nLifecycleDemoBean: 实例化\nLifecycleDemoBean: @PostConstruct（初始化）\nLifecycleDemoBean: afterPropertiesSet（InitializingBean）\nLifecycleDemoBean: customInit（自定义初始化方法）\n获取LifecycleDemoBean实例...\nLifecycleDemoBean: @PreDestroy（销毁前）\nLifecycleDemoBean: destroy（DisposableBean）\nLifecycleDemoBean: customDestroy（自定义销毁方法）\n```\n\n\n#### [Aware 类型的接口有什么作用？](#aware-类型的接口有什么作用)\n\n通过实现 Aware 接口，Bean 可以获取 Spring 容器的相关信息，如 BeanFactory、ApplicationContext 等。\n\n常见 Aware 接口有：\n\n| 接口 | 作用 |\n| --- | --- |\n| BeanNameAware | 获取当前 Bean 的名称。 |\n| BeanFactoryAware | 获取当前 Bean 所在的 BeanFactory 实例，可以直接操作容器。 |\n| ApplicationContextAware | 获取当前 Bean 所在的 ApplicationContext 实例。 |\n| EnvironmentAware | 获取 Environment 对象，用于获取配置文件中的属性或环境变量。 |\n| ServletContextAware | 在 Web 环境下获取 ServletContext 实例，访问 Web 应用上下文。 |\n| ResourceLoaderAware | 获取 ResourceLoader 对象，用于加载资源文件（如类路径文件或 URL）。 |\n\n#### [如果配置了 init-method 和 destroy-method，Spring 会在什么时候调用其配置的方法？](#如果配置了-init-method-和-destroy-method-spring-会在什么时候调用其配置的方法)\n\ninit-method 在 Bean 初始化阶段调用，依赖注入完成后且 postProcessBeforeInitialization 调用之后执行。\n\ndestroy-method 在 Bean 销毁阶段调用，容器关闭时调用。\n\n"
+ },
+ {
+ "id": 224,
+ "question": "为什么 IDEA 不推荐使用 @Autowired 注解注入 Bean？",
+ "answer": "当使用 `@Autowired` 注解注入 Bean 时，IDEA 会提示“Field injection is not recommended”。\n\n\n\n这是因为字段注入的方式：\n\n* 不能像构造方法那样使用 final 注入不可变对象\n* 隐藏了依赖关系，调用者可以看到构造方法注入或者 setter 注入，但无法看到私有字段的注入\n\n在 Spring 4.3 及更高版本中，如果一个类只有一个构造方法，Spring 会自动使用该构造方法进行依赖注入，无需使用 `@Autowired` 注解。\n\n#### [@Autowired 和 @Resource 注解的区别？](#autowired-和-resource-注解的区别)\n\n* `@Autowired` 是 Spring 提供的注解，按类型（byType）注入。\n* `@Resource` 是 Java EE 提供的注解，按名称（byName）注入。\n\n虽然 IDEA 不推荐使用 `@Autowired`，但对 `@Resource` 注解却没有任何提示。\n\n这是因为 `@Resource` 属于 Java EE 标准的注解，如果使用其他 IOC 容器而不是 Spring 也是可以兼容的。\n\n#### [提到了byType，如果两个类型一致的发生了冲突，应该怎么处理](#提到了bytype-如果两个类型一致的发生了冲突-应该怎么处理)\n\n当容器中存在多个相同类型的 bean，编译器会提示 `Could not autowire. There is more than one bean of 'UserRepository2' type.`\n\n\n```java\n@Component\npublic class UserRepository21 implements UserRepository2 {}\n\n@Component\npublic class UserRepository22 implements UserRepository2 {}\n\n@Component\npublic class UserService2 {\n @Autowired\n private UserRepository2 userRepository; // 冲突\n}\n```\n\n\n这时候，就可以配合 `@Qualifier` 注解来指定具体的 bean 名称：\n\n\n```java\n@Component(\"userRepository21\")\npublic class UserRepository21 implements UserRepository2 {\n}\n@Component(\"userRepository22\")\npublic class UserRepository22 implements UserRepository2 {\n}\n@Autowired\n@Qualifier(\"userRepository22\")\nprivate UserRepository2 userRepository22;\n```\n\n\n或者使用 `@Resource` 注解按名称进行注入，指定 name 属性。\n\n\n```java\n@Resource(name = \"userRepository21\")\nprivate UserRepository2 userRepository21;\n```"
+ },
+ {
+ "id": 225,
+ "question": "Spring 有哪些自动装配的方式？",
+ "answer": "> **什么是自动装配？**\n\nSpring IoC 容器知道所有 Bean 的配置信息，此外，通过 Java 反射机制还可以获知实现类的结构信息，如构造方法的结构、属性等信息。掌握所有 Bean 的这些信息后，Spring IoC 容器就可以按照某种规则对容器中的 Bean 进行自动装配，而无须通过显式的方式进行依赖配置。\n\nSpring 提供的这种方式，可以按照某些规则进行 Bean 的自动装配，``元素提供了一个指定自动装配类型的属性：`autowire=\"<自动装配类型>\"`\n\n> **Spring 提供了哪几种自动装配类型？**\n\nSpring 提供了 4 种自动装配类型：\n\n\n\n* **byName**：根据名称进行自动匹配，假设 Boss 有一个名为 car 的属性，如果容器中刚好有一个名为 car 的 bean，Spring 就会自动将其装配给 Boss 的 car 属性\n* **byType**：根据类型进行自动匹配，假设 Boss 有一个 Car 类型的属性，如果容器中刚好有一个 Car 类型的 Bean，Spring 就会自动将其装配给 Boss 这个属性\n* **constructor**：与 byType 类似， 只不过它是针对构造函数注入而言的。如果 Boss 有一个构造函数，构造函数包含一个 Car 类型的入参，如果容器中有一个 Car 类型的 Bean，则 Spring 将自动把这个 Bean 作为 Boss 构造函数的入参；如果容器中没有找到和构造函数入参匹配类型的 Bean，则 Spring 将抛出异常。\n* **autodetect**：根据 Bean 的自省机制决定采用 byType 还是 constructor 进行自动装配，如果 Bean 提供了默认的构造函数，则采用 byType，否则采用 constructor。"
+ },
+ {
+ "id": 226,
+ "question": "Bean 的作用域有哪些?",
+ "answer": "在 Spring 中，Bean 默认是单例的，即在整个 Spring 容器中，每个 Bean 只有一个实例。\n\n可以通过在配置中指定 scope 属性，将 Bean 改为多例（Prototype）模式，这样每次获取的都是新的实例。\n\n\n```java\n@Bean\n@Scope(\"prototype\") // 每次获取都是新的实例\npublic MyBean myBean() {\n return new MyBean();\n}\n```\n\n\n除了单例和多例，Spring 还支持其他作用域，如请求作用域（Request）、会话作用域（Session）等，适合 Web 应用中特定的使用场景。\n\n\n\n* **request**：每一次 HTTP 请求都会产生一个新的 Bean，该 Bean 仅在当前 HTTP Request 内有效。\n* **session**：同一个 Session 共享一个 Bean，不同的 Session 使用不同的 Bean。\n* **globalSession**：同一个全局 Session 共享一个 Bean，只用于基于 Protlet 的 Web 应用，Spring5 中已经移除。"
+ },
+ {
+ "id": 227,
+ "question": "Spring 中的单例 Bean 会存在线程安全问题吗？",
+ "answer": "Spring Bean 的默认作用域是单例（Singleton），这意味着 Spring 容器中只会存在一个 Bean 实例，并且该实例会被多个线程共享。\n\n如果单例 Bean 是无状态的，也就是没有成员变量，那么这个单例 Bean 是线程安全的。比如 Spring MVC 中的 Controller、Service、Dao 等，基本上都是无状态的。\n\n但如果 Bean 的内部状态是可变的，且没有进行适当的同步处理，就可能出现线程安全问题。\n\n\n\n#### [单例 Bean 线程安全问题怎么解决呢？](#单例-bean-线程安全问题怎么解决呢)\n\n第一，使用局部变量。局部变量是线程安全的，因为每个线程都有自己的局部变量副本。尽量使用局部变量而不是共享的成员变量。\n\n\n```java\npublic class MyService {\n public void process() {\n int localVar = 0;\n // 使用局部变量进行操作\n }\n}\n```\n\n\n第二，尽量使用无状态的 Bean，即不在 Bean 中保存任何可变的状态信息。\n\n\n```java\npublic class MyStatelessService {\n public void process() {\n // 无状态处理\n }\n}\n```\n\n\n第三，同步访问。如果 Bean 中确实需要保存可变状态，可以通过 或者 来保证线程安全。\n\n\n```java\npublic class MyService {\n private int sharedVar;\n\n public synchronized void increment() {\n sharedVar++;\n }\n}\n```\n\n\n或者将 Bean 中的成员变量保存到 ThreadLocal 中， 可以保证多线程环境下变量的隔离。\n\n\n```java\npublic class MyService {\n private ThreadLocal localVar = ThreadLocal.withInitial(() -> 0);\n\n public void process() {\n localVar.set(localVar.get() + 1);\n }\n}\n```\n\n\n再或者使用线程安全的工具类，比如说 、、 等。\n\n\n```java\npublic class MyService {\n private ConcurrentHashMap map = new ConcurrentHashMap<>();\n\n public void putValue(String key, String value) {\n map.put(key, value);\n }\n}\n```\n\n\n第四，将 Bean 定义为原型作用域（Prototype）。原型作用域的 Bean 每次请求都会创建一个新的实例，因此不存在线程安全问题。\n\n\n```java\n@Component\n@Scope(\"prototype\")\npublic class MyService {\n // 实例变量\n}\n```"
+ },
+ {
+ "id": 228,
+ "question": "说说循环依赖?",
+ "answer": "A 依赖 B，B 依赖 A，或者 C 依赖 C，就成了循环依赖。\n\n\n> 循环依赖只发生在 Singleton 作用域的 Bean 之间，因为如果是 Prototype 作用域的 Bean，Spring 会直接抛出异常。\n\n原因很简单，AB 循环依赖，A 实例化的时候，发现依赖 B，创建 B 实例，创建 B 的时候发现需要 A，创建 A1 实例……无限套娃。。。。\n\n我们来看一个实例，先是 PrototypeBeanA：\n\n\n```java\n@Component\n@Scope(\"prototype\")\npublic class PrototypeBeanA {\n private final PrototypeBeanB prototypeBeanB;\n\n @Autowired\n public PrototypeBeanA(PrototypeBeanB prototypeBeanB) {\n this.prototypeBeanB = prototypeBeanB;\n }\n}\n```\n\n\n然后是 PrototypeBeanB：\n\n\n```java\n@Component\n@Scope(\"prototype\")\npublic class PrototypeBeanB {\n private final PrototypeBeanA prototypeBeanA;\n\n @Autowired\n public PrototypeBeanB(PrototypeBeanA prototypeBeanA) {\n this.prototypeBeanA = prototypeBeanA;\n }\n}\n```\n\n\n再然后是测试：\n\n\n```java\n@SpringBootApplication\npublic class DemoApplication {\n\n public static void main(String[] args) {\n SpringApplication.run(DemoApplication.class, args);\n }\n\n @Bean\n CommandLineRunner commandLineRunner(ApplicationContext ctx) {\n return args -> {\n // 尝试获取PrototypeBeanA的实例\n PrototypeBeanA beanA = ctx.getBean(PrototypeBeanA.class);\n };\n }\n}\n```\n\n\n运行结果：\n\n\n\n在这个示例中，当 Spring 应用启动并尝试获取 PrototypeBeanA 或 PrototypeBeanB 的实例时，将会遇到问题。因为它们互相依赖，而 Spring 无法解决 Prototype 作用域 bean 的循环依赖问题。\n\n#### [Spring 可以解决哪些情况的循环依赖？](#spring-可以解决哪些情况的循环依赖)\n\n看看这几种情形（AB 循环依赖）：\n\n\n\n也就是说：\n\n* AB 均采用构造器注入，不支持\n* AB 均采用 setter 注入，支持\n* AB 均采用属性自动注入，支持\n* A 中注入的 B 为 setter 注入，B 中注入的 A 为构造器注入，支持\n* B 中注入的 A 为 setter 注入，A 中注入的 B 为构造器注入，不支持\n\n第四种可以，第五种不可以的原因是 Spring 在创建 Bean 时默认会根据自然排序进行创建，所以 A 会先于 B 进行创建。\n\n简单总结下，当循环依赖的实例都采用 setter 方法注入时，Spring 支持，都采用构造器注入的时候，不支持；构造器注入和 setter 注入同时存在的时候，看天（😂）。"
+ },
+ {
+ "id": 229,
+ "question": "Spring 怎么解决循环依赖呢？",
+ "answer": "Spring 通过三级缓存机制来解决循环依赖：\n\n1. 一级缓存：存放完全初始化好的单例 Bean。\n2. 二级缓存：存放正在创建但未完全初始化的 Bean 实例。\n3. 三级缓存：存放 Bean 工厂对象，用于提前暴露 Bean。\n\n\n\n#### [三级缓存解决循环依赖的过程是什么样的？](#三级缓存解决循环依赖的过程是什么样的)\n\n1. 实例化 Bean 时，将其早期引用放入三级缓存。\n2. 其他依赖该 Bean 的对象，可以从缓存中获取其引用。\n3. 初始化完成后，将 Bean 移入一级缓存。\n\n假如 A、B 两个类发生循环依赖：\n\n\n\nA 实例的初始化过程：\n\n①、创建 A 实例，实例化的时候把 A 的对象⼯⼚放⼊三级缓存，表示 A 开始实例化了，虽然这个对象还不完整，但是先曝光出来让大家知道。\n\n\n\n②、A 注⼊属性时，发现依赖 B，此时 B 还没有被创建出来，所以去实例化 B。\n\n③、同样，B 注⼊属性时发现依赖 A，它就从缓存里找 A 对象。依次从⼀级到三级缓存查询 A。\n\n发现可以从三级缓存中通过对象⼯⼚拿到 A，虽然 A 不太完善，但是存在，就把 A 放⼊⼆级缓存，同时删除三级缓存中的 A，此时，B 已经实例化并且初始化完成了，把 B 放入⼀级缓存。\n\n\n\n④、接着 A 继续属性赋值，顺利从⼀级缓存拿到实例化且初始化完成的 B 对象，A 对象创建也完成，删除⼆级缓存中的 A，同时把 A 放⼊⼀级缓存\n\n⑤、最后，⼀级缓存中保存着实例化、初始化都完成的 A、B 对象。\n\n"
+ },
+ {
+ "id": 230,
+ "question": "为什么要三级缓存？⼆级不⾏吗？",
+ "answer": "不行，主要是为了 **⽣成代理对象**。如果是没有代理的情况下，使用二级缓存解决循环依赖也是 OK 的。但是如果存在代理，三级没有问题，二级就不行了。\n\n因为三级缓存中放的是⽣成具体对象的匿名内部类，获取 Object 的时候，它可以⽣成代理对象，也可以返回普通对象。使⽤三级缓存主要是为了保证不管什么时候使⽤的都是⼀个对象。\n\n假设只有⼆级缓存的情况，往⼆级缓存中放的显示⼀个普通的 Bean 对象，Bean 初始化过程中，通过 BeanPostProcessor 去⽣成代理对象之后，覆盖掉⼆级缓存中的普通 Bean 对象，那么可能就导致取到的 Bean 对象不一致了。\n\n\n\n#### [如果缺少第二级缓存会有什么问题？](#如果缺少第二级缓存会有什么问题)\n\n如果没有二级缓存，Spring 无法在未完成初始化的情况下暴露 Bean。会导致代理 Bean 的循环依赖问题，因为某些代理逻辑无法在三级缓存中提前暴露。最终可能抛出 BeanCurrentlyInCreationException。"
+ },
+ {
+ "id": 231,
+ "question": "@Autowired 的实现原理？",
+ "answer": "实现@Autowired 的关键是：**AutowiredAnnotationBeanPostProcessor**\n\n在 Bean 的初始化阶段，会通过 Bean 后置处理器来进行一些前置和后置的处理。\n\n实现@Autowired 的功能，也是通过后置处理器来完成的。这个后置处理器就是 AutowiredAnnotationBeanPostProcessor。\n\n* Spring 在创建 bean 的过程中，最终会调用到 doCreateBean()方法，在 doCreateBean()方法中会调用 populateBean()方法，来为 bean 进行属性填充，完成自动装配等工作。\n* 在 populateBean()方法中一共调用了两次后置处理器，第一次是为了判断是否需要属性填充，如果不需要进行属性填充，那么就会直接进行 return，如果需要进行属性填充，那么方法就会继续向下执行，后面会进行第二次后置处理器的调用，这个时候，就会调用到 AutowiredAnnotationBeanPostProcessor 的 postProcessPropertyValues()方法，在该方法中就会进行@Autowired 注解的解析，然后实现自动装配。\n\n\n```java\n/**\n* 属性赋值\n**/\nprotected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {\n //…………\n if (hasInstAwareBpps) {\n if (pvs == null) {\n pvs = mbd.getPropertyValues();\n }\n\n PropertyValues pvsToUse;\n for(Iterator var9 = this.getBeanPostProcessorCache().instantiationAware.iterator(); var9.hasNext(); pvs = pvsToUse) {\n InstantiationAwareBeanPostProcessor bp = (InstantiationAwareBeanPostProcessor)var9.next();\n pvsToUse = bp.postProcessProperties((PropertyValues)pvs, bw.getWrappedInstance(), beanName);\n if (pvsToUse == null) {\n if (filteredPds == null) {\n filteredPds = this.filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);\n }\n //执行后处理器，填充属性，完成自动装配\n //调用InstantiationAwareBeanPostProcessor的postProcessPropertyValues()方法\n pvsToUse = bp.postProcessPropertyValues((PropertyValues)pvs, filteredPds, bw.getWrappedInstance(), beanName);\n if (pvsToUse == null) {\n return;\n }\n }\n }\n }\n //…………\n }\n```\n\n\n* postProcessorPropertyValues()方法的源码如下，在该方法中，会先调用 findAutowiringMetadata()方法解析出 bean 中带有@Autowired 注解、@Inject 和@Value 注解的属性和方法。然后调用 metadata.inject()方法，进行属性填充。\n\n\n```java\n public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {\n //@Autowired注解、@Inject和@Value注解的属性和方法\n InjectionMetadata metadata = this.findAutowiringMetadata(beanName, bean.getClass(), pvs);\n\n try {\n //属性填充\n metadata.inject(bean, beanName, pvs);\n return pvs;\n } catch (BeanCreationException var6) {\n throw var6;\n } catch (Throwable var7) {\n throw new BeanCreationException(beanName, \"Injection of autowired dependencies failed\", var7);\n }\n }\n```"
+ }
+ ]
+ },
+ {
+ "id": 33,
+ "categoryName": "AOP",
+ "questions": [
+ {
+ "id": 232,
+ "question": "说说什么是 AOP？",
+ "answer": "AOP，也就是面向切面编程，简单点说，AOP 就是把一些业务逻辑中的相同代码抽取到一个独立的模块中，让业务逻辑更加清爽。\n\n\n\n举个例子，假如我们现在需要在业务代码开始前进行参数校验，在结束后打印日志，该怎么办呢？\n\n我们可以把`日志记录`和`数据校验`这两个功能抽取出来，形成一个切面，然后在业务代码中引入这个切面，这样就可以实现业务逻辑和通用逻辑的分离。\n\n\n\n业务代码不再关心这些通用逻辑，只需要关心自己的业务实现，这样就实现了业务逻辑和通用逻辑的分离。\n\n#### [AOP 有哪些核心概念？](#aop-有哪些核心概念)\n\n* **切面**（Aspect）：类是对物体特征的抽象，切面就是对横切关注点的抽象\n* **连接点**（Join Point）：被拦截到的点，因为 Spring 只支持方法类型的连接点，所以在 Spring 中，连接点指的是被拦截到的方法，实际上连接点还可以是字段或者构造方法\n* **切点**（Pointcut）：对连接点进行拦截的定位\n* **通知**（Advice）：指拦截到连接点之后要执行的代码，也可以称作**增强**\n* **目标对象** （Target）：代理的目标对象\n* **引介**（introduction）：一种特殊的增强，可以动态地为类添加一些属性和方法\n* **织入**（Weabing）：织入是将增强添加到目标类的具体连接点上的过程。\n\n#### [织入有哪几种方式？](#织入有哪几种方式)\n\n①、编译期织入：切面在目标类编译时被织入。\n\n②、类加载期织入：切面在目标类加载到 JVM 时被织入。需要特殊的类加载器，它可以在目标类被引入应用之前增强该目标类的字节码。\n\n③、运行期织入：切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP 容器会为目标对象动态地创建一个代理对象。\n\nSpring AOP 采用运行期织入，而 AspectJ 可以在编译期织入和类加载时织入。\n\n#### [AspectJ 是什么？](#aspectj-是什么)\n\nAspectJ 是一个 AOP 框架，它可以做很多 Spring AOP 干不了的事情，比如说支持编译时、编译后和类加载时织入切面。并且提供更复杂的切点表达式和通知类型。\n\n\n\n下面是一个简单的 AspectJ 示例：\n\n\n```java\n// 定义一个切面\n@Aspect\npublic class LoggingAspect {\n\n // 定义一个切点，匹配 com.example 包下的所有方法\n @Pointcut(\"execution(* com.example..*(..))\")\n private void selectAll() {}\n\n // 定义一个前置通知，在匹配的方法执行之前执行\n @Before(\"selectAll()\")\n public void beforeAdvice() {\n System.out.println(\"A method is about to be executed.\");\n }\n}\n```\n\n\n#### [AOP 有哪些环绕方式？](#aop-有哪些环绕方式)\n\nAOP 一般有 **5 种**环绕方式：\n\n* 前置通知 (@Before)\n* 返回通知 (@AfterReturning)\n* 异常通知 (@AfterThrowing)\n* 后置通知 (@After)\n* 环绕通知 (@Around)\n\n\n\n多个切面的情况下，可以通过 `@Order` 指定先后顺序，数字越小，优先级越高。代码示例如下：\n\n\n```java\n@Aspect\n@Component\npublic class WebLogAspect {\n\n private final static Logger logger = LoggerFactory.getLogger(WebLogAspect.class);\n\n @Pointcut(\"@annotation(cn.fighter3.spring.aop_demo.WebLog)\")\n public void webLog() {}\n\n @Before(\"webLog()\")\n public void doBefore(JoinPoint joinPoint) throws Throwable {\n // 开始打印请求日志\n ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();\n HttpServletRequest request = attributes.getRequest();\n // 打印请求相关参数\n logger.info(\"========================================== Start ==========================================\");\n // 打印请求 url\n logger.info(\"URL : {}\", request.getRequestURL().toString());\n // 打印 Http method\n logger.info(\"HTTP Method : {}\", request.getMethod());\n // 打印调用 controller 的全路径以及执行方法\n logger.info(\"Class Method : {}.{}\", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());\n // 打印请求的 IP\n logger.info(\"IP : {}\", request.getRemoteAddr());\n // 打印请求入参\n logger.info(\"Request Args : {}\",new ObjectMapper().writeValueAsString(joinPoint.getArgs()));\n }\n\n @After(\"webLog()\")\n public void doAfter() throws Throwable {\n // 结束后打个分隔线，方便查看\n logger.info(\"=========================================== End ===========================================\");\n }\n\n @Around(\"webLog()\")\n public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {\n //开始时间\n long startTime = System.currentTimeMillis();\n Object result = proceedingJoinPoint.proceed();\n // 打印出参\n logger.info(\"Response Args : {}\", new ObjectMapper().writeValueAsString(result));\n // 执行耗时\n logger.info(\"Time-Consuming : {} ms\", System.currentTimeMillis() - startTime);\n return result;\n }\n}\n```\n\n\n#### [Spring AOP 发生在什么时候？](#spring-aop-发生在什么时候)\n\nSpring AOP 基于运行时代理机制，这意味着 Spring AOP 是在运行时通过动态代理生成的，而不是在编译时或类加载时生成的。\n\n在 Spring 容器初始化 Bean 的过程中，Spring AOP 会检查 Bean 是否需要应用切面。如果需要，Spring 会为该 Bean 创建一个代理对象，并在代理对象中织入切面逻辑。这一过程发生在 Spring 容器的后处理器（BeanPostProcessor）阶段。\n\n\n\n#### [简单总结一下 AOP](#简单总结一下-aop)\n\nAOP，也就是面向切面编程，是一种编程范式，旨在提高代码的模块化。比如说可以将日志记录、事务管理等分离出来，来提高代码的可重用性。\n\nAOP 的核心概念包括切面（Aspect）、连接点（Join Point）、通知（Advice）、切点（Pointcut）和织入（Weaving）等。\n\n① 像日志打印、事务管理等都可以抽离为切面，可以声明在类的方法上。像 `@Transactional` 注解，就是一个典型的 AOP 应用，它就是通过 AOP 来实现事务管理的。我们只需要在方法上添加 `@Transactional` 注解，Spring 就会在方法执行前后添加事务管理的逻辑。\n\n② Spring AOP 是基于代理的，它默认使用 JDK 动态代理和 CGLIB 代理来实现 AOP。\n\n③ Spring AOP 的织入方式是运行时织入，而 AspectJ 支持编译时织入、类加载时织入。\n\n#### [AOP和 OOP 的关系？](#aop和-oop-的关系)\n\nAOP 和 OOP 是互补的编程思想：\n\n1. OOP 通过类和对象封装数据和行为，专注于核心业务逻辑。\n2. AOP 提供了解决横切关注点（如日志、权限、事务等）的机制，将这些逻辑集中管理。"
+ },
+ {
+ "id": 233,
+ "question": "AOP的使用场景有哪些？",
+ "answer": "AOP 的使用场景有很多，比如说日志记录、事务管理、权限控制、性能监控等。\n\n我们在中主要利用 AOP 来打印接口的入参和出参日志、执行时间，方便后期 bug 溯源和性能调优。\n\n\n\n第一步，自定义注解作为切点\n\n\n```java\n@Target({ElementType.METHOD, ElementType.TYPE})\n@Retention(RetentionPolicy.RUNTIME)\n@Documented\npublic @interface MdcDot {\n String bizCode() default \"\";\n}\n```\n\n\n第二步，配置 AOP 切面：\n\n* `@Aspect`：标识切面\n* `@Pointcut`：设置切点，这里以自定义注解为切点\n* `@Around`：环绕切点，打印方法签名和执行时间\n\n第三步，在使用的地方加上自定义注解\n\n第四步，当接口被调用时，就可以看到对应的执行日志。\n\n\n```text\n2023-06-16 11:06:13,008 [http-nio-8080-exec-3] INFO |00000000.1686884772947.468581113|101|c.g.p.forum.core.mdc.MdcAspect.handle(MdcAspect.java:47) - 方法执行耗时: com.github.paicoding.forum.web.front.article.rest.ArticleRestController#recommend = 47\n```"
+ },
+ {
+ "id": 234,
+ "question": "说说 JDK 动态代理和 CGLIB 代理？",
+ "answer": "AOP 是通过[动态代理](https://mp.weixin.qq.com/s/aZtfwik0weJN5JzYc-JxYg)实现的，代理方式有两种：JDK 动态代理和 CGLIB 代理。\n\n①、JDK 动态代理是基于接口的代理，只能代理实现了接口的类。\n\n使用 JDK 动态代理时，Spring AOP 会创建一个代理对象，该代理对象实现了目标对象所实现的接口，并在方法调用前后插入横切逻辑。\n\n优点：只需依赖 JDK 自带的 `java.lang.reflect.Proxy` 类，不需要额外的库；缺点：只能代理接口，不能代理类本身。\n\n示例代码：\n\n\n```java\npublic interface Service {\n void perform();\n}\n\npublic class ServiceImpl implements Service {\n public void perform() {\n System.out.println(\"Performing service...\");\n }\n}\n\npublic class ServiceInvocationHandler implements InvocationHandler {\n private Object target;\n\n public ServiceInvocationHandler(Object target) {\n this.target = target;\n }\n\n @Override\n public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {\n System.out.println(\"Before method\");\n Object result = method.invoke(target, args);\n System.out.println(\"After method\");\n return result;\n }\n}\n\npublic class Main {\n public static void main(String[] args) {\n Service service = new ServiceImpl();\n Service proxy = (Service) Proxy.newProxyInstance(\n service.getClass().getClassLoader(),\n service.getClass().getInterfaces(),\n new ServiceInvocationHandler(service)\n );\n proxy.perform();\n }\n}\n```\n\n\n②、CGLIB 动态代理是基于继承的代理，可以代理没有实现接口的类。\n\n使用 CGLIB 动态代理时，Spring AOP 会生成目标类的子类，并在方法调用前后插入横切逻辑。\n\n\n\n优点：可以代理没有实现接口的类，灵活性更高；缺点：需要依赖 CGLIB 库，创建代理对象的开销相对较大。\n\n示例代码：\n\n\n```java\npublic class Service {\n public void perform() {\n System.out.println(\"Performing service...\");\n }\n}\n\npublic class ServiceInterceptor implements MethodInterceptor {\n @Override\n public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {\n System.out.println(\"Before method\");\n Object result = proxy.invokeSuper(obj, args);\n System.out.println(\"After method\");\n return result;\n }\n}\n\npublic class Main {\n public static void main(String[] args) {\n Enhancer enhancer = new Enhancer();\n enhancer.setSuperclass(Service.class);\n enhancer.setCallback(new ServiceInterceptor());\n\n Service proxy = (Service) enhancer.create();\n proxy.perform();\n }\n}\n```\n\n\n#### [选择 CGLIB 还是 JDK 动态代理？](#选择-cglib-还是-jdk-动态代理)\n\n* 如果目标对象没有实现任何接口，则只能使用 CGLIB 代理。如果目标对象实现了接口，通常首选 JDK 动态代理。\n* 虽然 CGLIB 在代理类的生成过程中可能消耗更多资源，但在运行时具有较高的性能。对于性能敏感且代理对象创建频率不高的场景，可以考虑使用 CGLIB。\n* JDK 动态代理是 Java 原生支持的，不需要额外引入库。而 CGLIB 需要将 CGLIB 库作为依赖加入项目中。\n\n#### [你会用 JDK 动态代理和 CGLIB 吗？](#你会用-jdk-动态代理和-cglib-吗)\n\n假设我们有这样一个小场景，客服中转，解决用户问题：\n\n\n\n①、JDK 动态代理实现：\n\n\n\n第一步，创建接口\n\n\n```java\npublic interface ISolver {\n void solve();\n}\n```\n\n\n第二步，实现对应接口\n\n\n```java\npublic class Solver implements ISolver {\n @Override\n public void solve() {\n System.out.println(\"疯狂掉头发解决问题……\");\n }\n}\n```\n\n\n第三步，动态代理工厂:ProxyFactory，直接用反射方式生成一个目标对象的代理，这里用了一个匿名内部类方式重写 InvocationHandler 方法。\n\n\n```java\npublic class ProxyFactory {\n\n // 维护一个目标对象\n private Object target;\n\n public ProxyFactory(Object target) {\n this.target = target;\n }\n\n // 为目标对象生成代理对象\n public Object getProxyInstance() {\n return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),\n new InvocationHandler() {\n @Override\n public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {\n System.out.println(\"请问有什么可以帮到您？\");\n\n // 调用目标对象方法\n Object returnValue = method.invoke(target, args);\n\n System.out.println(\"问题已经解决啦！\");\n return null;\n }\n });\n }\n}\n```\n\n\n第五步，客户端：Client，生成一个代理对象实例，通过代理对象调用目标对象方法\n\n\n```java\npublic class Client {\n public static void main(String[] args) {\n //目标对象:程序员\n ISolver developer = new Solver();\n //代理：客服小姐姐\n ISolver csProxy = (ISolver) new ProxyFactory(developer).getProxyInstance();\n //目标方法：解决问题\n csProxy.solve();\n }\n}\n```\n\n\n②、CGLIB 动态代理实现：\n\n\n\n第一步：定义目标类（Solver），目标类 Solver 定义了一个 solve 方法，模拟了解决问题的行为。目标类不需要实现任何接口，这与 JDK 动态代理的要求不同。\n\n\n```java\npublic class Solver {\n\n public void solve() {\n System.out.println(\"疯狂掉头发解决问题……\");\n }\n}\n```\n\n\n第二步：动态代理工厂（ProxyFactory），ProxyFactory 类实现了 MethodInterceptor 接口，这是 CGLIB 提供的一个方法拦截接口，用于定义方法的拦截逻辑。\n\n\n```java\npublic class ProxyFactory implements MethodInterceptor {\n\n //维护一个目标对象\n private Object target;\n\n public ProxyFactory(Object target) {\n this.target = target;\n }\n\n //为目标对象生成代理对象\n public Object getProxyInstance() {\n //工具类\n Enhancer en = new Enhancer();\n //设置父类\n en.setSuperclass(target.getClass());\n //设置回调函数\n en.setCallback(this);\n //创建子类对象代理\n return en.create();\n }\n\n @Override\n public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {\n System.out.println(\"请问有什么可以帮到您？\");\n // 执行目标对象的方法\n Object returnValue = method.invoke(target, args);\n System.out.println(\"问题已经解决啦！\");\n return null;\n }\n\n}\n```\n\n\n* ProxyFactory 接收一个 Object 类型的 target，即目标对象的实例。\n* 使用 CGLIB 的 Enhancer 类来生成目标类的子类（代理对象）。通过 setSuperclass 设置代理对象的父类为目标对象的类，setCallback 设置方法拦截器为当前对象（this），最后调用 create 方法生成并返回代理对象。\n* 重写 MethodInterceptor 接口的 intercept 方法以提供方法拦截逻辑。在目标方法执行前后添加自定义逻辑，然后通过 method.invoke 调用目标对象的方法。\n\n第三步：客户端使用代理，首先创建目标对象（Solver 的实例），然后使用 ProxyFactory 创建该目标对象的代理。通过代理对象调用 solve 方法时，会先执行 intercept 方法中定义的逻辑，然后执行目标方法，最后再执行 intercept 方法中的后续逻辑。\n\n\n```java\npublic class Client {\n public static void main(String[] args) {\n //目标对象:程序员\n Solver developer = new Solver();\n //代理：客服小姐姐\n Solver csProxy = (Solver) new ProxyFactory(developer).getProxyInstance();\n //目标方法：解决问题\n csProxy.solve();\n }\n}\n```"
+ },
+ {
+ "id": 235,
+ "question": "说说 Spring AOP 和 AspectJ AOP 区别?",
+ "answer": "Spring AOP 属于`运行时增强`，主要具有如下特点：\n\n1. 基于动态代理来实现，默认如果使用接口的，用 JDK 提供的动态代理实现，如果是方法则使用 CGLIB 实现\n2. Spring AOP 需要依赖 IoC 容器来管理，并且只能作用于 Spring 容器，使用纯 Java 代码实现\n3. 在性能上，由于 Spring AOP 是基于**动态代理**来实现的，在容器启动时需要生成代理实例，在方法调用上也会增加栈的深度，使得 Spring AOP 的性能不如 AspectJ 的那么好。\n4. Spring AOP 致力于解决企业级开发中最普遍的 AOP(方法织入)。\n\nAspectJ 是一个易用的功能强大的 AOP 框架，属于`编译时增强`， 可以单独使用，也可以整合到其它框架中，是 AOP 编程的完全解决方案。AspectJ 需要用到单独的编译器 ajc。\n\nAspectJ 属于**静态织入**，通过修改代码来实现，在实际运行之前就完成了织入，所以说它生成的类是没有额外运行时开销的，一般有如下几个织入的时机：\n\n1. 编译期织入（Compile-time weaving）：如类 A 使用 AspectJ 添加了一个属性，类 B 引用了它，这个场景就需要编译期的时候就进行织入，否则没法编译类 B。\n2. 编译后织入（Post-compile weaving）：也就是已经生成了 .class 文件，或已经打成 jar 包了，这种情况我们需要增强处理的话，就要用到编译后织入。\n3. 类加载后织入（Load-time weaving）：指的是在加载类的时候进行织入，要实现这个时期的织入，有几种常见的方法\n\n整体对比如下：\n\n"
+ },
+ {
+ "id": 236,
+ "question": "说说 AOP 和反射的区别？（补充）",
+ "answer": "> 2024 年 7 月 27 日增补。\n\n1. 反射：用于检查和操作类的方法和字段，动态调用方法或访问字段。反射是 Java 提供的内置机制，直接操作类对象。\n2. 动态代理：通过生成代理类来拦截方法调用，通常用于 AOP 实现。动态代理使用反射来调用被代理的方法。"
+ }
+ ]
+ },
+ {
+ "id": 34,
+ "categoryName": "事务",
+ "questions": [
+ {
+ "id": 237,
+ "question": "Spring 事务的种类？",
+ "answer": "在 Spring 中，事务管理可以分为两大类：声明式事务管理和编程式事务管理。\n\n\n\n#### [介绍一下编程式事务管理？](#介绍一下编程式事务管理)\n\n编程式事务可以使用 TransactionTemplate 和 PlatformTransactionManager 来实现，需要显式执行事务。允许我们在代码中直接控制事务的边界，通过编程方式明确指定事务的开始、提交和回滚。\n\n\n```java\npublic class AccountService {\n private TransactionTemplate transactionTemplate;\n\n public void setTransactionTemplate(TransactionTemplate transactionTemplate) {\n this.transactionTemplate = transactionTemplate;\n }\n\n public void transfer(final String out, final String in, final Double money) {\n transactionTemplate.execute(new TransactionCallbackWithoutResult() {\n @Override\n protected void doInTransactionWithoutResult(TransactionStatus status) {\n // 转出\n accountDao.outMoney(out, money);\n // 转入\n accountDao.inMoney(in, money);\n }\n });\n }\n}\n```\n\n\n在上面的代码中，我们使用了 TransactionTemplate 来实现编程式事务，通过 execute 方法来执行事务，这样就可以在方法内部实现事务的控制。\n\n#### [介绍一下声明式事务管理？](#介绍一下声明式事务管理)\n\n声明式事务是建立在 AOP 之上的。其本质是通过 AOP 功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前启动一个事务，在目标方法执行完之后根据执行情况提交或者回滚事务。\n\n相比较编程式事务，优点是不需要在业务逻辑代码中掺杂事务管理的代码，Spring 推荐通过 @Transactional 注解的方式来实现声明式事务管理，也是日常开发中最常用的。\n\n不足的地方是，声明式事务管理最细粒度只能作用到方法级别，无法像编程式事务那样可以作用到代码块级别。\n\n\n```java\n@Service\npublic class AccountService {\n @Autowired\n private AccountDao accountDao;\n\n @Transactional\n public void transfer(String out, String in, Double money) {\n // 转出\n accountDao.outMoney(out, money);\n // 转入\n accountDao.inMoney(in, money);\n }\n}\n```\n\n\n#### [说说两者的区别？](#说说两者的区别)\n\n* **编程式事务管理**：需要在代码中显式调用事务管理的 API 来控制事务的边界，比较灵活，但是代码侵入性较强，不够优雅。\n* **声明式事务管理**：这种方式使用 Spring 的 AOP 来声明事务，将事务管理代码从业务代码中分离出来。优点是代码简洁，易于维护。但缺点是不够灵活，只能在预定义的方法上使用事务。"
+ },
+ {
+ "id": 238,
+ "question": "说说 Spring 的事务隔离级别？",
+ "answer": "好，事务的隔离级别定义了一个事务可能受其他并发事务影响的程度。SQL 标准定义了四个隔离级别，Spring 都支持，并且提供了对应的机制来配置它们，定义在 TransactionDefinition 接口中。\n\n\n\n①、ISOLATION\\_DEFAULT：使用数据库默认的隔离级别（你们爱咋咋滴 😁），MySQL 默认的是可重复读，Oracle 默认的读已提交。\n\n②、ISOLATION\\_READ\\_UNCOMMITTED：读未提交，允许事务读取未被其他事务提交的更改。这是隔离级别最低的设置，可能会导致“脏读”问题。\n\n③、ISOLATION\\_READ\\_COMMITTED：读已提交，确保事务只能读取已经被其他事务提交的更改。这可以防止“脏读”，但仍然可能发生“不可重复读”和“幻读”问题。\n\n④、ISOLATION\\_REPEATABLE\\_READ：可重复读，确保事务可以多次从一个字段中读取相同的值，即在这个事务内，其他事务无法更改这个字段，从而避免了“不可重复读”，但仍可能发生“幻读”问题。\n\n⑤、ISOLATION\\_SERIALIZABLE：串行化，这是最高的隔离级别，它完全隔离了事务，确保事务序列化执行，以此来避免“脏读”、“不可重复读”和“幻读”问题，但性能影响也最大。"
+ },
+ {
+ "id": 239,
+ "question": "Spring 的事务传播机制？",
+ "answer": "事务的传播机制定义了方法在被另一个事务方法调用时的事务行为，这些行为定义了事务的边界和事务上下文如何在方法调用链中传播。\n\n\n\nSpring 的默认传播行为是 PROPAGATION\\_REQUIRED，即如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。\n\n事务传播机制是使用 实现的，所以，如果调用的方法是在新线程中，事务传播会失效。\n\n\n```java\n@Transactional\npublic void parentMethod() {\n new Thread(() -> childMethod()).start();\n}\n\npublic void childMethod() {\n // 这里的操作将不会在 parentMethod 的事务范围内执行\n}\n```\n\n\nSpring 默认的事务传播行为是 PROPAFATION\\_REQUIRED，即如果多个 `ServiceX#methodX()` 都工作在事务环境下，且程序中存在这样的调用链 `Service1#method1()->Service2#method2()->Service3#method3()`，那么这 3 个服务类的 3 个方法都通过 Spring 的事务传播机制工作在同一个事务中。\n\n#### [protected 和 private 加事务会生效吗](#protected-和-private-加事务会生效吗)\n\n在 Spring 中，**只有通过 Spring 容器的 AOP 代理调用的公开方法（public method）上的`@Transactional`注解才会生效**。\n\n如果在 protected、private 方法上使用`@Transactional`，这些事务注解将不会生效，原因：Spring 默认使用基于 JDK 的动态代理（当接口存在时）或基于 CGLIB 的代理（当只有类时）来实现事务。这两种代理机制都只能代理公开的方法。"
+ },
+ {
+ "id": 240,
+ "question": "声明式事务实现原理了解吗？",
+ "answer": "Spring 的声明式事务管理是通过 AOP（面向切面编程）和代理机制实现的。\n\n第一步，**在 Bean 初始化阶段创建代理对象**：\n\nSpring 容器在初始化单例 Bean 的时候，会遍历所有的 BeanPostProcessor 实现类，并执行其 postProcessAfterInitialization 方法。\n\n在执行 postProcessAfterInitialization 方法时会遍历容器中所有的切面，查找与当前 Bean 匹配的切面，这里会获取事务的属性切面，也就是 `@Transactional` 注解及其属性值。\n\n然后根据得到的切面创建一个代理对象，默认使用 JDK 动态代理创建代理，如果目标类是接口，则使用 JDK 动态代理，否则使用 Cglib。\n\n第二步，**在执行目标方法时进行事务增强操作**：\n\n当通过代理对象调用 Bean 方法的时候，会触发对应的 AOP 增强拦截器，声明式事务是一种环绕增强，对应接口为`MethodInterceptor`，事务增强对该接口的实现为`TransactionInterceptor`，类图如下：\n\n\n\n事务拦截器`TransactionInterceptor`在`invoke`方法中，通过调用父类`TransactionAspectSupport`的`invokeWithinTransaction`方法进行事务处理，包括开启事务、事务提交、异常回滚等。"
+ },
+ {
+ "id": 241,
+ "question": "声明式事务在哪些情况下会失效？",
+ "answer": "\n\n#### [1、@Transactional 应用在非 public 修饰的方法上](#_1、-transactional-应用在非-public-修饰的方法上)\n\n如果 Transactional 注解应用在非 public 修饰的方法上，Transactional 将会失效。\n\n是因为在 Spring AOP 代理时，TransactionInterceptor （事务拦截器）在目标方法执行前后进行拦截，DynamicAdvisedInterceptor（CglibAopProxy 的内部类）的 intercept 方法或 JdkDynamicAopProxy 的 invoke 方法会间接调用 AbstractFallbackTransactionAttributeSource 的 **computeTransactionAttribute**方法，获取 Transactional 注解的事务配置信息。\n\n\n```java\nprotected TransactionAttribute computeTransactionAttribute(Method method,\n Class targetClass) {\n // Don't allow no-public methods as required.\n if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {\n return null;\n }\n}\n```\n\n\n此方法会检查目标方法的修饰符是否为 public，不是 public 则不会获取 @Transactional 的属性配置信息。\n\n#### [2、@Transactional 注解属性 propagation 设置错误](#_2、-transactional-注解属性-propagation-设置错误)\n\n* TransactionDefinition.PROPAGATION\\_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务方式执行；错误使用场景：在业务逻辑必须运行在事务环境下以确保数据一致性的情况下使用 SUPPORTS。\n* TransactionDefinition.PROPAGATION\\_NOT\\_SUPPORTED：总是以非事务方式执行，如果当前存在事务，则挂起该事务。错误使用场景：在需要事务支持的操作中使用 NOT\\_SUPPORTED。\n* TransactionDefinition.PROPAGATION\\_NEVER：总是以非事务方式执行，如果当前存在事务，则抛出异常。错误使用场景：在应该在事务环境下执行的操作中使用 NEVER。\n\n#### [3、@Transactional 注解属性 rollbackFor 设置错误](#_3、-transactional-注解属性-rollbackfor-设置错误)\n\nrollbackFor 用来指定能够触发事务回滚的异常类型。Spring 默认抛出未检查 unchecked 异常（继承自 RuntimeException 的异常）或者 Error 才回滚事务，其他异常不会触发回滚事务。\n\n\n```java\n// 希望自定义的异常可以进行回滚\n@Transactional(propagation= Propagation.REQUIRED,rollbackFor= MyException.class)\n```\n\n\n若在目标方法中抛出的异常是 rollbackFor 指定的异常的子类，事务同样会回滚。\n\n#### [4、同一个类中方法调用，导致@Transactional 失效](#_4、同一个类中方法调用-导致-transactional-失效)\n\n开发中避免不了会对同一个类里面的方法调用，比如有一个类 Test，它的一个方法 A，A 调用本类的方法 B（不论方法 B 是用 public 还是 private 修饰），但方法 A 没有声明注解事务，而 B 方法有。\n\n则外部调用方法 A 之后，方法 B 的事务是不会起作用的。这也是经常犯错误的一个地方。\n\n那为啥会出现这种情况呢？其实还是由 Spring AOP 代理造成的，因为只有事务方法被当前类以外的代码调用时，才会由 Spring 生成的代理对象来管理。\n\n\n```java\n //@Transactional\n@GetMapping(\"/test\")\nprivate Integer A() throws Exception {\n CityInfoDict cityInfoDict = new CityInfoDict();\n cityInfoDict.setCityName(\"2\");\n /**\n * B 插入字段为 3的数据\n */\n this.insertB();\n /**\n * A 插入字段为 2的数据\n */\n int insert = cityInfoDictMapper.insert(cityInfoDict);\n return insert;\n}\n\n@Transactional()\npublic Integer insertB() throws Exception {\n CityInfoDict cityInfoDict = new CityInfoDict();\n cityInfoDict.setCityName(\"3\");\n cityInfoDict.setParentCityId(3);\n\n return cityInfoDictMapper.insert(cityInfoDict);\n}\n```\n\n\n这种情况是最常见的一种@Transactional 注解失效场景。\n\n\n```java\n@Transactional\nprivate Integer A() throws Exception {\n int insert = 0;\n try {\n CityInfoDict cityInfoDict = new CityInfoDict();\n cityInfoDict.setCityName(\"2\");\n cityInfoDict.setParentCityId(2);\n /**\n * A 插入字段为 2的数据\n */\n insert = cityInfoDictMapper.insert(cityInfoDict);\n /**\n * B 插入字段为 3的数据\n */\n b.insertB();\n } catch (Exception e) {\n e.printStackTrace();\n }\n}\n```\n\n\n如果 B 方法内部抛了异常，而 A 方法此时 try catch 了 B 方法的异常，那这个事务就不能正常回滚了，会抛出异常：\n\n\n```java\norg.springframework.transaction.UnexpectedRollbackException: Transaction rolled back because it has been marked as rollback-only\n```"
+ }
+ ]
+ },
+ {
+ "id": 35,
+ "categoryName": "MVC",
+ "questions": [
+ {
+ "id": 242,
+ "question": "Spring MVC 的核心组件？",
+ "answer": "1. **DispatcherServlet**：前置控制器，是整个流程控制的**核心**，控制其他组件的执行，进行统一调度，降低组件之间的耦合性，相当于总指挥。\n2. **Handler**：处理器，完成具体的业务逻辑，相当于 Servlet 或 Action。\n3. **HandlerMapping**：DispatcherServlet 接收到请求之后，通过 HandlerMapping 将不同的请求映射到不同的 Handler。\n4. **HandlerInterceptor**：处理器拦截器，是一个接口，如果需要完成一些拦截处理，可以实现该接口。\n5. **HandlerExecutionChain**：处理器执行链，包括两部分内容：Handler 和 HandlerInterceptor（系统会有一个默认的 HandlerInterceptor，如果需要额外设置拦截，可以添加拦截器）。\n6. **HandlerAdapter**：处理器适配器，Handler 执行业务方法之前，需要进行一系列的操作，包括表单数据的验证、数据类型的转换、将表单数据封装到 JavaBean 等，这些操作都是由 HandlerApater 来完成，开发者只需将注意力集中业务逻辑的处理上，DispatcherServlet 通过 HandlerAdapter 执行不同的 Handler。\n7. **ModelAndView**：装载了模型数据和视图信息，作为 Handler 的处理结果，返回给 DispatcherServlet。\n8. **ViewResolver**：视图解析器，DispatcheServlet 通过它将逻辑视图解析为物理视图，最终将渲染结果响应给客户端。"
+ },
+ {
+ "id": 243,
+ "question": "Spring MVC 的工作流程？",
+ "answer": "首先，客户端发送请求，DispatcherServlet 拦截并通过 HandlerMapping 找到对应的控制器。\n\nDispatcherServlet 使用 HandlerAdapter 调用控制器方法，执行具体的业务逻辑，返回一个 ModelAndView 对象。\n\n然后 DispatcherServlet 通过 ViewResolver 解析视图。\n\n最后，DispatcherServlet 渲染视图并将响应返回给客户端。\n\n\n\n①、**发起请求**：客户端通过 HTTP 协议向服务器发起请求。\n\n②、**前端控制器**：这个请求会先到前端控制器 DispatcherServlet，它是整个流程的入口点，负责接收请求并将其分发给相应的处理器。\n\n③、**处理器映射**：DispatcherServlet 调用 HandlerMapping 来确定哪个 Controller 应该处理这个请求。通常会根据请求的 URL 来确定。\n\n④、**处理器适配器**：一旦找到目标 Controller，DispatcherServlet 会使用 HandlerAdapter 来调用 Controller 的处理方法。\n\n⑤、**执行处理器**：Controller 处理请求，处理完后返回一个 ModelAndView 对象，其中包含模型数据和逻辑视图名。\n\n⑥、**视图解析器**：DispatcherServlet 接收到 ModelAndView 后，会使用 ViewResolver 来解析视图名称，找到具体的视图页面。\n\n⑦、**渲染视图**：视图使用模型数据渲染页面，生成最终的页面内容。\n\n⑧、**响应结果**：DispatcherServlet 将视图结果返回给客户端。\n\n**Spring MVC** 虽然整体流程复杂，但是实际开发中很简单，大部分的组件不需要我们开发人员创建和管理，真正需要处理的只有 **Controller** 、**View** 、**Model**。\n\n在前后端分离的情况下，步骤 ⑥、⑦、⑧ 会略有不同，后端通常只需要处理数据，并将 JSON 格式的数据返回给前端就可以了，而不是返回完整的视图页面。\n\n#### [这个 Handler 是什么东西啊？为什么还需要 HandlerAdapter](#这个-handler-是什么东西啊-为什么还需要-handleradapter)\n\nHandler 一般就是指 Controller，Controller 是 Spring MVC 的核心组件，负责处理请求，返回响应。\n\nSpring MVC 允许使用多种类型的处理器。不仅仅是标准的`@Controller`注解的类，还可以是实现了特定接口的其他类（如 HttpRequestHandler 或 SimpleControllerHandlerAdapter 等）。这些处理器可能有不同的方法签名和交互方式。\n\nHandlerAdapter 的主要职责就是调用 Handler 的方法来处理请求，并且适配不同类型的处理器。HandlerAdapter 确保 DispatcherServlet 可以以统一的方式调用不同类型的处理器，无需关心具体的执行细节。"
+ },
+ {
+ "id": 244,
+ "question": "SpringMVC Restful 风格的接口的流程是什么样的呢？",
+ "answer": "PS:这是一道全新的八股，毕竟 ModelAndView 这种方式应该没人用了吧？现在都是前后端分离接口，八股也该更新换代了。\n\n我们都知道 Restful 接口，响应格式是 json，这就用到了一个常用注解：**@ResponseBody**\n\n\n```java\n @GetMapping(\"/user\")\n @ResponseBody\n public User user(){\n return new User(1,\"张三\");\n }\n```\n\n\n加入了这个注解后，整体的流程上和使用 ModelAndView 大体上相同，但是细节上有一些不同：\n\n\n\n1. 客户端向服务端发送一次请求，这个请求会先到前端控制器 DispatcherServlet\n2. DispatcherServlet 接收到请求后会调用 HandlerMapping 处理器映射器。由此得知，该请求该由哪个 Controller 来处理\n3. DispatcherServlet 调用 HandlerAdapter 处理器适配器，告诉处理器适配器应该要去执行哪个 Controller\n4. Controller 被封装成了 ServletInvocableHandlerMethod，HandlerAdapter 处理器适配器去执行 invokeAndHandle 方法，完成对 Controller 的请求处理\n5. HandlerAdapter 执行完对 Controller 的请求，会调用 HandlerMethodReturnValueHandler 去处理返回值，主要的过程：\n\n 5.1. 调用 RequestResponseBodyMethodProcessor，创建 ServletServerHttpResponse（Spring 对原生 ServerHttpResponse 的封装）实例\n\n 5.2.使用 HttpMessageConverter 的 write 方法，将返回值写入 ServletServerHttpResponse 的 OutputStream 输出流中\n\n 5.3.在写入的过程中，会使用 JsonGenerator（默认使用 Jackson 框架）对返回值进行 Json 序列化\n6. 执行完请求后，返回的 ModealAndView 为 null，ServletServerHttpResponse 里也已经写入了响应，所以不用关心 View 的处理"
+ }
+ ]
+ },
+ {
+ "id": 36,
+ "categoryName": "Spring Boot",
+ "questions": [
+ {
+ "id": 245,
+ "question": "介绍一下 SpringBoot，有哪些优点？",
+ "answer": "Spring Boot 提供了一套默认配置，它通过约定大于配置的理念，来帮助我们快速搭建 Spring 项目骨架。\n\n\n\n以前的 Spring 开发需要配置大量的 xml 文件，并且需要引入大量的第三方 jar 包，还需要手动放到 classpath 下。现在只需要引入一个 Starter，或者一个注解，就可以轻松搞定。\n\nSpring Boot 的优点非常多，比如说：\n\n1. Spring Boot 内嵌了 Tomcat、Jetty、Undertow 等容器，直接运行 jar 包就可以启动项目。\n2. Spring Boot 内置了 Starter 和自动装配，避免繁琐的手动配置。例如，如果项目中添加了 spring-boot-starter-web，Spring Boot 会自动配置 Tomcat 和 Spring MVC。\n3. Spring Boot 内置了 Actuator 和 DevTools，便于调试和监控。\n\n#### [Spring Boot常用注解有哪些？](#spring-boot常用注解有哪些)\n\n1. **@SpringBootApplication**：Spring Boot 应用的入口，用在启动类上。\n2. 还有一些 Spring 框架本身的注解，比如 **@Component**、**@RestController**、**@Service**、**@ConfigurationProperties**、**@Transactional** 等。"
+ },
+ {
+ "id": 246,
+ "question": "SpringBoot 自动配置原理了解吗？",
+ "answer": "在 Spring 中，自动装配是指容器利用反射技术，根据 Bean 的类型、名称等自动注入所需的依赖。\n\n\n\n在 Spring Boot 中，开启自动装配的注解是`@EnableAutoConfiguration`。\n\n\n\nSpring Boot 为了进一步简化，直接通过 `@SpringBootApplication` 注解一步搞定，该注解包含了 `@EnableAutoConfiguration` 注解。\n\nmain 类启动的时候，Spring Boot 会通过底层的`AutoConfigurationImportSelector` 类加载自动装配类。\n\n\n```java\n@AutoConfigurationPackage //将main同级的包下的所有组件注册到容器中\n@Import({AutoConfigurationImportSelector.class}) //加载自动装配类 xxxAutoconfiguration\npublic @interface EnableAutoConfiguration {\n String ENABLED_OVERRIDE_PROPERTY = \"spring.boot.enableautoconfiguration\";\n\n Class[] exclude() default {};\n\n String[] excludeName() default {};\n}\n```\n\n\n`AutoConfigurationImportSelector`实现了`ImportSelector`接口，该接口的作用是收集需要导入的配置类，配合 `@Import()` 将相应的类导入到 Spring 容器中。\n\n\n\n获取注入类的方法是 `selectImports()`，它实际调用的是`getAutoConfigurationEntry()`，这个方法是获取自动装配类的关键。\n\n\n```java\nprotected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {\n // 检查自动配置是否启用。如果@ConditionalOnClass等条件注解使得自动配置不适用于当前环境，则返回一个空的配置条目。\n if (!isEnabled(annotationMetadata)) {\n return EMPTY_ENTRY;\n }\n\n // 获取启动类上的@EnableAutoConfiguration注解的属性，这可能包括对特定自动配置类的排除。\n AnnotationAttributes attributes = getAttributes(annotationMetadata);\n\n // 从spring.factories中获取所有候选的自动配置类。这是通过加载META-INF/spring.factories文件中对应的条目来实现的。\n List configurations = getCandidateConfigurations(annotationMetadata, attributes);\n\n // 移除配置列表中的重复项，确保每个自动配置类只被考虑一次。\n configurations = removeDuplicates(configurations);\n\n // 根据注解属性解析出需要排除的自动配置类。\n Set exclusions = getExclusions(annotationMetadata, attributes);\n\n // 检查排除的类是否存在于候选配置中，如果存在，则抛出异常。\n checkExcludedClasses(configurations, exclusions);\n\n // 从候选配置中移除排除的类。\n configurations.removeAll(exclusions);\n\n // 应用过滤器进一步筛选自动配置类。过滤器可能基于条件注解如@ConditionalOnBean等来排除特定的配置类。\n configurations = getConfigurationClassFilter().filter(configurations);\n\n // 触发自动配置导入事件，允许监听器对自动配置过程进行干预。\n fireAutoConfigurationImportEvents(configurations, exclusions);\n\n // 创建并返回一个包含最终确定的自动配置类和排除的配置类的AutoConfigurationEntry对象。\n return new AutoConfigurationEntry(configurations, exclusions);\n}\n```\n\n\n总结：Spring Boot 的自动装配原理依赖于 Spring 框架的依赖注入和条件注册，通过这种方式，Spring Boot 能够智能地配置 bean，并且只有当这些 bean 实际需要时才会被创建和配置。"
+ },
+ {
+ "id": 247,
+ "question": "如何自定义一个 SpringBoot Srarter?",
+ "answer": "创建一个自定义的 Spring Boot Starter，需要这几步：\n\n第一步，创建一个新的 Maven 项目，例如命名为 my-spring-boot-starter。在 pom.xml 文件中添加必要的依赖和配置：\n\n\n```xml\n\n 2.3.1.RELEASE \n \n\n\n \n org.springframework.boot \n spring-boot-autoconfigure \n ${spring.boot.version} \n \n \n org.springframework.boot \n spring-boot-starter \n ${spring.boot.version} \n \n \n```\n\n\n第二步，在 `src/main/java` 下创建一个自动配置类，比如 MyServiceAutoConfiguration.java：（通常是 autoconfigure 包下）。\n\n\n```java\n@Configuration\n@EnableConfigurationProperties(MyStarterProperties.class)\npublic class MyServiceAutoConfiguration {\n\n @Bean\n @ConditionalOnMissingBean\n public MyService myService(MyStarterProperties properties) {\n return new MyService(properties.getMessage());\n }\n}\n```\n\n\n第三步，创建一个配置属性类 MyStarterProperties.java：\n\n\n```java\n@ConfigurationProperties(prefix = \"mystarter\")\npublic class MyStarterProperties {\n private String message = \"练习伴侣不错啊!\";\n\n public String getMessage() {\n return message;\n }\n\n public void setMessage(String message) {\n this.message = message;\n }\n}\n```\n\n\n第四步，创建一个简单的服务类 MyService.java：\n\n\n```java\npublic class MyService {\n private final String message;\n\n public MyService(String message) {\n this.message = message;\n }\n\n public String getMessage() {\n return message;\n }\n}\n```\n\n\n第五步，配置 spring.factories，在 `src/main/resources/META-INF` 目录下创建 spring.factories 文件，并添加：\n\n\n```text\norg.springframework.boot.autoconfigure.EnableAutoConfiguration=\\\ncom.itwanger.mystarter.autoconfigure.MyServiceAutoConfiguration\n```\n\n\n第六步，使用 Maven 打包这个项目：\n\n\n```shell\nmvn clean install\n```\n\n\n第七步，在其他的 Spring Boot 项目中，通过 Maven 来添加这个自定义的 Starter 依赖，并通过 application.properties 配置欢迎消息：\n\n\n```xml\nmystarter.message=javabetter.cn\n```\n\n\n然后就可以在 Spring Boot 项目中注入 MyStarterProperties 来使用它。\n\n\n\n启动项目，然后在浏览器中输入 `localhost:8081/hello`，就可以看到欢迎消息了。\n\n\n\n#### [Spring Boot Starter 的原理了解吗？](#spring-boot-starter-的原理了解吗)\n\nSpring Boot Starter 主要通过起步依赖和自动配置机制来简化项目的构建和配置过程。\n\n起步依赖是 Spring Boot 提供的一组预定义依赖项，它们将一组相关的库和模块打包在一起。比如 `spring-boot-starter-web` 就包含了 Spring MVC、Tomcat 和 Jackson 等依赖。\n\n自动配置机制是 Spring Boot 的核心特性，通过自动扫描类路径下的类、资源文件和配置文件，自动创建和配置应用程序所需的 Bean 和组件。\n\n比如有了 `spring-boot-starter-web`，我们开发者就不需要再手动配置 Tomcat、Spring MVC 等，Spring Boot 会自动帮我们完成这些工作。"
+ },
+ {
+ "id": 248,
+ "question": "Spring Boot 启动原理了解吗？",
+ "answer": "Spring Boot 的启动由 SpringApplication 类负责：\n\n* 第一步，创建 SpringApplication 实例，负责应用的启动和初始化；\n* 第二步，从 application.yml 中加载配置文件和环境变量；\n* 第三步，创建上下文环境 ApplicationContext，并加载 Bean，完成依赖注入；\n* 第四步，启动内嵌的 Web 容器。\n* 第五步，发布启动完成事件 ApplicationReadyEvent，并调用 ApplicationRunner 的 run 方法完成启动后的逻辑。\n\n关键的代码逻辑如下：\n\n\n```java\npublic ConfigurableApplicationContext run(String... args) {\n // 1. 创建启动时的监听器并触发启动事件\n SpringApplicationRunListeners listeners = getRunListeners(args);\n listeners.starting();\n\n // 2. 准备运行环境\n ConfigurableEnvironment environment = prepareEnvironment(listeners);\n configureIgnoreBeanInfo(environment);\n\n // 3. 创建上下文\n ConfigurableApplicationContext context = createApplicationContext();\n\n try {\n // 4. 准备上下文\n prepareContext(context, environment, listeners, args);\n\n // 5. 刷新上下文，完成 Bean 初始化和装配\n refreshContext(context);\n\n // 6. 调用运行器\n afterRefresh(context, args);\n\n // 7. 触发启动完成事件\n listeners.started(context);\n } catch (Exception ex) {\n handleRunFailure(context, ex, listeners);\n }\n\n return context;\n}\n```\n\n\n以为例。在启动类 QuickForumApplication 中，main 方法会调用 `SpringApplication.run()` 启动项目。\n\n该方法负责 Spring 应用的上下文环境（ApplicationContext）准备，包括：\n\n* 扫描配置文件，添加依赖项\n* 初始化和加载 Bean 定义\n* 启动内嵌的 Web 容器等\n* 发布启动完成事件\n\n#### [了解@SpringBootApplication 注解吗？](#了解-springbootapplication-注解吗)\n\n`@SpringBootApplication`是 Spring Boot 的核心注解，经常用于主类上，作为项目启动入口的标识。它是一个组合注解：\n\n* `@SpringBootConfiguration`：继承自 `@Configuration`，标注该类是一个配置类，相当于一个 Spring 配置文件。\n* `@EnableAutoConfiguration`：告诉 Spring Boot 根据 pom.xml 中添加的依赖自动配置项目。例如，如果 spring-boot-starter-web 依赖被添加到项目中，Spring Boot 会自动配置 Tomcat 和 Spring MVC。\n* `@ComponentScan`：扫描当前包及其子包下被`@Component`、`@Service`、`@Controller`、`@Repository` 注解标记的类，并注册为 Spring Bean。\n\n\n```java\n@SpringBootApplication\npublic class Application {\n public static void main(String[] args) {\n SpringApplication.run(Application.class, args);\n }\n}\n```\n\n\n#### [为什么 Spring Boot 在启动的时候能够找到 main 方法上的@SpringBootApplication 注解？](#为什么-spring-boot-在启动的时候能够找到-main-方法上的-springbootapplication-注解)\n\nSpring Boot 在启动时能够找到主类上的`@SpringBootApplication`注解，是因为它利用了 Java 的反射机制和类加载机制，结合 Spring 框架内部的一系列处理流程。\n\n当运行一个 Spring Boot 程序时，通常会调用主类中的`main`方法，这个方法会执行`SpringApplication.run()`，比如：\n\n\n```java\n@SpringBootApplication\npublic class MyApplication {\n public static void main(String[] args) {\n SpringApplication.run(MyApplication.class, args);\n }\n}\n```\n\n\n`SpringApplication.run(Class primarySource, String... args)`方法接收两个参数：第一个是主应用类（即包含`main`方法的类），第二个是命令行参数。`primarySource`参数提供了一个起点，Spring Boot 通过它来加载应用上下文。\n\nSpring Boot 利用 Java 反射机制来读取传递给`run`方法的类（`MyApplication.class`）。它会检查这个类上的注解，包括`@SpringBootApplication`。\n\n#### [Spring Boot 默认的包扫描路径是什么？](#spring-boot-默认的包扫描路径是什么)\n\nSpring Boot 的默认包扫描路径是以启动类 `@SpringBootApplication` 注解所在的包为根目录的，即默认情况下，Spring Boot 会扫描启动类所在包及其子包下的所有组件。\n\n比如说在中，启动类`QuickForumApplication`所在的包是`com.github.paicoding.forum.web`，那么 Spring Boot 默认会扫描`com.github.paicoding.forum.web`包及其子包下的所有组件。\n\n\n\n`@SpringBootApplication` 是一个组合注解，它里面的`@ComponentScan`注解可以指定要扫描的包路径，默认扫描启动类所在包及其子包下的所有组件。\n\n\n```java\n@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),\n\t\t@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })\npublic @interface SpringBootApplication {\n}\n```\n\n\n比如说带有 `@Component`、`@Service`、`@Controller`、`@Repository` 等注解的类都会被 Spring Boot 扫描到，并注册到 Spring 容器中。\n\n如果需要自定义包扫描路径，可以在`@SpringBootApplication`注解上添加`@ComponentScan`注解，指定要扫描的包路径。\n\n\n```java\n@SpringBootApplication\n@ComponentScan(basePackages = {\"com.github.paicoding.forum\"})\npublic class QuickForumApplication {\n public static void main(String[] args) {\n SpringApplication.run(QuickForumApplication.class, args);\n }\n}\n```\n\n\n这种方式会覆盖默认的包扫描路径，只扫描`com.github.paicoding.forum`包及其子包下的所有组件。"
+ },
+ {
+ "id": 249,
+ "question": "SpringBoot 和 SpringMVC 的区别？（补充）",
+ "answer": "> 2024 年 04 月 04 日增补\n\nSpring MVC 是基于 Spring 框架的一个模块，提供了一种 Model-View-Controller（模型-视图-控制器）的开发模式。\n\nSpring Boot 旨在简化 Spring 应用的配置和部署过程，提供了大量的自动配置选项，以及运行时环境的内嵌 Web 服务器，这样就可以更快速地开发一个 SpringMVC 的 Web 项目。"
+ },
+ {
+ "id": 250,
+ "question": "Spring Boot 和 Spring 有什么区别？（补充）",
+ "answer": "> 2024 年 07 月 09 日新增\n\nSpring Boot 是 Spring Framework 的一个扩展，提供了一套快速配置和开发的机制，可以帮助我们快速搭建 Spring 项目的骨架，提高生产效率。\n\n| 特性 | Spring Framework | Spring Boot |\n| --- | --- | --- |\n| **目的** | 提供企业级的开发工具和库 | 简化 Spring 应用的开发、配置和部署 |\n| **配置方式** | 主要通过 XML 和注解等手动配置 | 提供开箱即用的自动配置 |\n| **启动和运行** | 需要打成 war 包到 Tomcat 等容器下运行 | 已嵌入 Tomcat 等容器，打包成 JAR 文件直接运行 |\n| **依赖管理** | 手动添加和管理依赖 | 使用 `spring-boot-starter` 简化依赖管理 |"
+ }
+ ]
+ },
+ {
+ "id": 37,
+ "categoryName": "Spring Cloud",
+ "questions": [
+ {
+ "id": 251,
+ "question": "对 SpringCloud 了解多少？",
+ "answer": "Spring Cloud 是一个基于 Spring Boot，提供构建分布式系统和微服务架构的工具集。用于解决分布式系统中的一些常见问题，如配置管理、服务发现、负载均衡等等。\n\n\n\n#### [什么是微服务？](#什么是微服务)\n\n1. 2014 年 **Martin Fowler** 提出的一种新的架构形式。微服务架构是一种**架构模式**，提倡将单一应用程序划分成一组小的服务，服务之间相互协调，互相配合，为用户提供最终价值。每个服务运行在其独立的进程中，服务与服务之间采用轻量级的通信机制(如 HTTP 或 Dubbo)互相协作，每个服务都围绕着具体的业务进行构建，并且能够被独立的部署到生产环境中，另外，应尽量避免统一的，集中式的服务管理机制，对具体的一个服务而言，应根据业务上下文，选择合适的语言、工具(如 Maven)对其进行构建。\n2. 微服务化的核心就是将传统的一站式应用，根据业务拆分成一个一个的服务，彻底地去耦合，每一个微服务提供单个业务功能的服务，一个服务做一件事情，从技术角度看就是一种小而独立的处理过程，类似进程的概念，能够自行单独启动或销毁，拥有自己独立的数据库。\n\n#### [微服务架构主要要解决哪些问题？](#微服务架构主要要解决哪些问题)\n\n1. 服务很多，客户端怎么访问，如何提供对外网关?\n2. 这么多服务，服务之间如何通信? HTTP 还是 RPC?\n3. 这么多服务，如何治理? 服务的注册和发现。\n4. 服务挂了怎么办？熔断机制。\n\n#### [有哪些主流微服务框架？](#有哪些主流微服务框架)\n\n1. Spring Cloud Netflix\n2. Spring Cloud Alibaba\n3. SpringBoot + Dubbo + ZooKeeper\n\n#### [SpringCloud 有哪些核心组件？](#springcloud-有哪些核心组件)\n\n"
+ }
+ ]
+ },
+ {
+ "id": 38,
+ "categoryName": "补充",
+ "questions": [
+ {
+ "id": 252,
+ "question": "SpringTask 了解吗？",
+ "answer": "SpringTask 是 Spring 框架提供的一个轻量级的任务调度框架，它允许我们开发者通过简单的注解来配置和管理定时任务。\n\n①、`@Scheduled`：最常用的注解，用于标记方法为计划任务的执行点。中，就使用该注解来定时刷新 sitemap.xml：\n\n\n```java\n@Scheduled(cron = \"0 15 5 * * ?\")\npublic void autoRefreshCache() {\n log.info(\"开始刷新sitemap.xml的url地址，避免出现数据不一致问题!\");\n refreshSitemap();\n log.info(\"刷新完成！\");\n}\n```\n\n\n`@Scheduled` 注解支持多种调度选项，如 fixedRate、fixedDelay 和 cron 表达式。\n\n②、`@EnableScheduling`：用于开启定时任务的支持。\n\n#### [用SpringTask资源占用太高，有什么其他的方式解决？（补充）](#用springtask资源占用太高-有什么其他的方式解决-补充)\n\n> 2024年05月27日新增\n\n**第一，使用消息队列**，如 RabbitMQ、Kafka、RocketMQ 等，将任务放到消息队列中，然后由消费者异步处理这些任务。\n\n①、在订单创建时，将订单超时检查任务放入消息队列，并设置延迟时间（即订单超时时间）。\n\n\n```java\n@Service\npublic class OrderService {\n @Autowired\n private RabbitTemplate rabbitTemplate;\n\n public void createOrder(Order order) {\n // 创建订单逻辑\n // ...\n \n // 发送延迟消息\n rabbitTemplate.convertAndSend(\"orderExchange\", \"orderTimeoutQueue\", order, message -> {\n message.getMessageProperties().setExpiration(\"600000\"); // 设置延迟时间（10分钟）\n return message;\n });\n }\n}\n```\n\n\n②、使用消费者从队列中消费消息，当消费到超时任务时，执行订单超时处理逻辑。\n\n\n```java\n@Service\npublic class OrderTimeoutConsumer {\n\n @RabbitListener(queues = \"orderTimeoutQueue\")\n public void handleOrderTimeout(Order order) {\n // 处理订单超时逻辑\n // ...\n }\n}\n```\n\n\n**第二，使用数据库调度器（如 Quartz）**。\n\n①、创建一个 Quartz 任务类，处理订单超时逻辑。\n\n\n```java\npublic class OrderTimeoutJob implements Job {\n @Override\n public void execute(JobExecutionContext context) throws JobExecutionException {\n // 获取订单信息\n Order order = (Order) context.getJobDetail().getJobDataMap().get(\"order\");\n\n // 处理订单超时逻辑\n // ...\n }\n}\n```\n\n\n②、在订单创建时，调度一个 Quartz 任务，设置任务的触发时间为订单超时时间。\n\n\n```java\n@Service\npublic class OrderService {\n @Autowired\n private Scheduler scheduler;\n\n public void createOrder(Order order) {\n // 创建订单逻辑\n // ...\n\n // 调度 Quartz 任务\n JobDetail jobDetail = JobBuilder.newJob(OrderTimeoutJob.class)\n .usingJobData(\"order\", order)\n .build();\n\n Trigger trigger = TriggerBuilder.newTrigger()\n .startAt(new Date(System.currentTimeMillis() + 600000)) // 设置触发时间（10分钟后）\n .build();\n\n try {\n scheduler.scheduleJob(jobDetail, trigger);\n } catch (SchedulerException e) {\n e.printStackTrace();\n }\n }\n}\n```"
+ },
+ {
+ "id": 253,
+ "question": "Spring Cache 了解吗？",
+ "answer": "Spring Cache 是 Spring 框架提供的一个缓存抽象，它通过统一的接口来支持多种缓存实现（如 Redis、Caffeine 等）。\n\n它通过注解（如 `@Cacheable`、`@CachePut`、`@CacheEvict`）来实现缓存管理，极大简化了代码实现。\n\n* @Cacheable：缓存方法的返回值。\n* @CachePut：用于更新缓存，每次调用方法都会将结果重新写入缓存。\n* @CacheEvict：用于删除缓存。\n\n使用示例：\n\n\n\n#### [Spring Cache 和 Redis 有什么区别？](#spring-cache-和-redis-有什么区别)\n\n1. **Spring Cache** 是 Spring 框架提供的一个缓存抽象，它通过注解来实现缓存管理，支持多种缓存实现（如 Redis、Caffeine 等）。\n2. **Redis** 是一个分布式的缓存中间件，支持多种数据类型（如 String、Hash、List、Set、ZSet），还支持持久化、集群、主从复制等。\n\nSpring Cache 适合用于单机、轻量级和短时缓存场景，能够通过注解轻松控制缓存管理。\n\nRedis 是一种分布式缓存解决方案，支持多种数据结构和高并发访问，适合分布式系统和高并发场景，可以提供数据持久化和多种淘汰策略。\n\n在实际开发中，Spring Cache 和 Redis 可以结合使用，Spring Cache 提供管理缓存的注解，而 Redis 则作为分布式缓存的实现，提供共享缓存支持。\n\n#### [有了 Redis 为什么还需要 Spring Cache？](#有了-redis-为什么还需要-spring-cache)\n\n虽然 Redis 非常强大，但 Spring Cache 提供了一层缓存抽象，简化了缓存的管理。我们可以直接在方法上通过注解来实现缓存逻辑，减少了手动操作 Redis 的代码量。\n\nSpring Cache 还能灵活切换底层缓存实现。此外，Spring Cache 支持事务性缓存和条件缓存，便于在复杂场景中确保数据一致性。\n\n#### [说说Spring Cache 的底层原理？](#说说spring-cache-的底层原理)\n\nSpring Cache 是基于 AOP 和缓存抽象层实现的。它通过 AOP 拦截被 @Cacheable、@CachePut 和 @CacheEvict 注解的方法，在方法调用前后自动执行缓存逻辑。\n\n\n\n其提供的 CacheManager 和 Cache 等接口，不依赖具体的缓存实现，因此可以灵活地集成 Redis、Caffeine 等多种缓存。\n\n* ConcurrentMapCacheManager：基于 Java ConcurrentMap 的本地缓存实现。\n* RedisCacheManager：基于 Redis 的分布式缓存实现。\n* CaffeineCacheManager：基于 Caffeine 的缓存实现。\n\n---\n\n图文详解 41 道 Spring 面试高频题，这次吊打面试官，我觉得稳了（手动 dog）。整理：练习伴侣二，戳[转载链接](https://mp.weixin.qq.com/s/EQge6DmgIqYITM3mAxkatg)，作者：三分恶，戳[原文链接](https://mp.weixin.qq.com/s/Y17S85ntHm_MLTZMJdtjQQ)。\n\n*没有什么使我停留——除了目的，纵然岸旁有玫瑰、有绿荫、有宁静的港湾，我是不系之舟*。\n\n**系列内容**：\n\n\n\n---"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 6,
+ "topicName": "Redis",
+ "categories": [
+ {
+ "id": 39,
+ "categoryName": "基础",
+ "questions": [
+ {
+ "id": 254,
+ "question": "说说什么是 Redis?",
+ "answer": "是 **Re**mote **Di**ctionary **S**ervice 三个单词中加粗字母的组合，是一种基于键值对的 NoSQL 数据库。\n\n\n\n但比一般的键值对，比如 强大的多，Redis 中的 value 支持 string、hash、 list、set、zset、Bitmaps、 [HyperLogLog](https://www.cnblogs.com/54chensongxia/p/13803465.html)、GEO等多种数据结构。\n\n而且因为 Redis 的所有数据都存放在内存当中，所以它的读写性能非常出色。\n\n不仅如此，Redis 还可以将内存数据持久化到硬盘上，这样在发生类似断电或者机器故障的时候，内存中的数据并不会“丢失”。\n\n除此之外，Redis 还提供了键过期、发布订阅、事务、流水线、Lua 脚本等附加功能，是互联网技术领域中使用最广泛的缓存中间件。\n\n#### [Redis 和 MySQL 的区别？](#redis-和-mysql-的区别)\n\n* Redis：数据存储在内存中的 NoSQL 数据库，读写性能非常好，是互联网技术领域中使用最广泛的缓存中间件。\n* MySQL：数据存储在硬盘中的关系型数据库，适用于需要事务支持和复杂查询的场景。\n\n#### [项目里哪里用到了 Redis？](#项目里哪里用到了-redis)\n\n在中，很多地方都用到了 Redis，比如说用户活跃排行榜、作者白名单、常用热点数据（文章标签、文章分类）、计数统计（文章点赞收藏评论数粉丝数）等等。\n\n#### [部署过 Redis 吗？](#部署过-redis-吗)\n\n我是直接在本地部署的单机版，只需要下载 Redis 的安装包，解压后运行 `redis-server` 命令即可。\n\n也可以通过 Docker 拉取 Redis 镜像，然后运行容器。\n\n\n```shell\ndocker run -d --name redis -p 6379:6379 redis\n```"
+ },
+ {
+ "id": 255,
+ "question": "Redis 可以用来干什么？",
+ "answer": "Redis 可以用来做缓存、排行榜、分布式锁等等。\n\n①、缓存\n\n缓存是 Redis 最常见的用途，由于 Redis 的数据存储在内存中，所以读写速度非常快，远超基于磁盘存储的数据库。使用 Redis 缓存可以极大地提高应用的响应速度和吞吐量。\n\n\n\n②、排行榜/计数器\n\nRedis 的 ZSet 非常适合用来实现排行榜的功能，可以根据 score（分值）进行排序，实时展示用户的活跃度。\n\n同时 Redis 的原子递增操作可以用来实现计数器功能。\n\n③、分布式锁\n\nRedis 可以实现分布式锁，用来控制跨多个进程的资源访问。\n\n"
+ },
+ {
+ "id": 256,
+ "question": "Redis 有哪些数据类型？",
+ "answer": "Redis 有五种基本数据类型，这五种数据类型分别是：string（字符串）、hash（哈希）、list（列表）、set（集合）、sorted set（有序集合，也叫 zset）。\n\n\n\n#### [简单介绍下 string？](#简单介绍下-string)\n\n字符串是最基础的数据类型，key 是一个字符串，不用多说，value 可以是：\n\n* 字符串（简单的字符串、复杂的字符串（例如 JSON、XML））\n* 数字 （整数、浮点数）\n* 甚至是二进制（图片、音频、视频），但最大不能超过 512MB。\n\n字符串主要有以下几个典型的使用场景：\n\n* 缓存功能\n* 计数\n* 共享 Session\n* 限速\n\n#### [简单介绍下 hash？](#简单介绍下-hash)\n\n键值对集合，key 是字符串，value 是一个 Map 集合，比如说 `value = {name: '练习伴侣二', age: 18}`，name 和 age 属于字段 field，练习伴侣二 和 18 属于值 value。\n\n哈希主要有以下两个典型应用场景：\n\n* 缓存用户信息\n* 缓存对象\n\n#### [什么使用 hash 类型而不使用 string 类型序列化存储？](#什么使用-hash-类型而不使用-string-类型序列化存储)\n\n来感受一下，使用字符串类型存储用户信息和使用哈希类型存储用户信息的区别：\n\n\n\n可以看得出，使用 hash 比使用 string 更便于进行序列化，我们可以将一整个用户对象序列化，然后作为一个 value 存储在 Redis 中，存取更加便捷。\n\n#### [简单介绍下 list？](#简单介绍下-list)\n\nlist 是一个简单的字符串列表，按照插入顺序排序。可以添加一个元素到列表的头部（左边）或者尾部（右边）。\n\n列表主要有以下两个使用场景：\n\n* 消息队列\n* 文章列表\n\n#### [简单介绍下 set？](#简单介绍下-set)\n\nSet 是一个无序集合，元素是唯一的，不允许重复。\n\n#### [简单介绍下 zset？](#简单介绍下-zset)\n\nZset 是有序集合，比 set 多了一个排序属性 score。\n\n\n\n可以用来实现排行榜，比如中，我们就使用了 Zset 来实现用户活跃排行榜。"
+ },
+ {
+ "id": 257,
+ "question": "Redis 为什么快呢？",
+ "answer": "Redis 的速度⾮常快，单机的 Redis 就可以⽀撑每秒十几万的并发，性能是 MySQL 的⼏⼗倍。原因主要有⼏点：\n\n①、**基于内存的数据存储**，Redis 将数据存储在内存当中，使得数据的读写操作避开了磁盘 I/O。而内存的访问速度远超硬盘，这是 Redis 读写速度快的根本原因。\n\n②、**单线程模型**，Redis 使用单线程模型来处理客户端的请求，这意味着在任何时刻只有一个命令在执行。这样就避免了线程切换和锁竞争带来的消耗。\n\n③、**IO 多路复⽤**，基于 Linux 的 select/epoll 机制。该机制允许内核中同时存在多个监听套接字和已连接套接字，内核会一直监听这些套接字上的连接请求或者数据请求，一旦有请求到达，就会交给 Redis 处理，就实现了所谓的 Redis 单个线程处理多个 IO 读写的请求。\n\n\n\n④、**高效的数据结构**，Redis 提供了多种高效的数据结构，如字符串（String）、列表（List）、集合（Set）、有序集合（Sorted Set）等，这些数据结构经过了高度优化，能够支持快速的数据操作。"
+ },
+ {
+ "id": 258,
+ "question": "能说一下 I/O 多路复用吗？",
+ "answer": "IO 多路复用是一种高效管理多个 IO 事件的技术，通过单线程监控多个文件描述符（fd），实现高并发的 IO 操作。\n\n常见的 I/O 多路复用机制包括 select、poll 和 epoll 等。\n\n| 特性 | `select` | `poll` | `epoll` |\n| --- | --- | --- | --- |\n| 文件描述符限制 | 受 `FD_SETSIZE` 限制 | 无限制 | 无限制 |\n| 时间复杂度 | O(n) | O(n) | O(1) |\n| 数据复制 | 需要 | 需要 | 不需要 |\n| 工作方式 | 线性扫描 | 线性扫描 | 事件通知 |\n| 内核支持 | 所有 UNIX 系统 | 所有 UNIX 系统 | Linux 2.6 及以上版本 |\n| 适用场景 | 少量连接 | 中等连接 | 大量并发连接 |\n\n比如说你是一名数学老师，上课时提出了一个问题：“今天谁来证明一下勾股定律？”\n\n同学小练习伴侣举手，你就让小王回答；小李举手，你就让小李回答；小张举手，你就让小张回答。\n\n这种模式就是 IO 多路复用，你只需要在讲台上等，谁举手谁回答，不需要一个一个去问。\n\n\n\nRedis 就是使用 epoll 这样的 I/O 多路复用机制，在单线程模型下实现高效的网络 I/O，从而支持高并发的请求处理。\n\n#### [举例子说一下 I/O 多路复用？](#举例子说一下-i-o-多路复用)\n\n假设你是一个老师，让 30 个学生解答一道题目，然后检查学生做的是否正确，你有下面几个选择：\n\n* 第一种选择：按顺序逐个检查，先检查 A，然后是 B，之后是 C、D。。。这中间如果有一个学生卡住，全班都会被耽误。这种模式就好比，你用循环挨个处理 socket，根本不具有并发能力。\n* 第二种选择：你创建 30 个分身，每个分身检查一个学生的答案是否正确。 这种类似于为每一个用户创建一个进程或者线程处理连接。\n* 第三种选择，你站在讲台上等，谁解答完谁举手。这时 C、D 举手，表示他们解答问题完毕，你下去依次检查 C、D 的答案，然后继续回到讲台上等。此时 E、A 又举手，然后去处理 E 和 A。\n\n第一种就是阻塞 IO 模型，第三种就是 I/O 复用模型。\n\n\n\nLinux 系统有三种方式实现 IO 多路复用：select、poll 和 epoll。\n\n例如 epoll 方式是将用户 socket 对应的 fd 注册进 epoll，然后 epoll 帮你监听哪些 socket 上有消息到达，这样就避免了大量的无用操作。此时的 socket 应该采用非阻塞模式。\n\n这样，整个过程只在进行 select、poll、epoll 这些调用的时候才会阻塞，收发客户消息是不会阻塞的，整个进程或者线程就被充分利用起来，这就是事件驱动，所谓的 reactor 模式。\n\n#### [select、poll 和 epoll 的实现原理？](#select、poll-和-epoll-的实现原理)\n\nselect 使用位图管理 fd，每次调用都需要将 fd 集合从用户态复制到内核态。最大支持 1024 个文件描述符。\n\npoll 使用动态数组管理 fd，突破了 select 的数量限制。\n\nepoll 使用红黑树和链表管理 fd，每次调用只需要将 fd 集合从用户态复制到内核态一次，不需要重复复制。"
+ },
+ {
+ "id": 259,
+ "question": "Redis 为什么早期选择单线程？",
+ "answer": "官方解释：https://redis.io/topics/faq\n\n 官方 FAQ 表示，因为 Redis 是基于内存的操作，CPU 成为 Redis 的瓶颈的情况很少见，Redis 的瓶颈最有可能是内存的大小或者网络限制。\n\n如果想要最大程度利用 CPU，可以在一台机器上启动多个 Redis 实例。\n\nPS：网上有这样的回答，吐槽官方的解释有些敷衍，其实就是历史原因，开发者嫌多线程麻烦，后来这个 CPU 的利用问题就被抛给了使用者。\n\n同时 FAQ 里还提到了， Redis 4.0 之后开始变成多线程，除了主线程外，它也有后台线程在处理一些较为缓慢的操作，例如清理脏数据、无用连接的释放、大 Key 的删除等等。"
+ },
+ {
+ "id": 260,
+ "question": "Redis 6.0 使用多线程是怎么回事?",
+ "answer": "单线程模型意味着 Redis 在大量 IO 请求时，无法充分利用多核 CPU 的优势。\n\n\n\n在 Redis 6.0 中，多线程主要用来处理网络 IO 操作，命令解析和执行仍然是单线程完成，这样既可以发挥多核 CPU 的优势，又能避免锁和上下文切换带来的性能损耗。"
+ },
+ {
+ "id": 261,
+ "question": "说说 Redis 常用命令（补充）",
+ "answer": "> 2024 年 04 月 11 日增补\n\n①、操作字符串的命令有：\n\n* `SET key value`：设置键 key 的值为 value。\n* `GET key`：获取键 key 的值。\n* `DEL key`：删除键 key。\n* `INCR key`：将键 key 存储的数值增一。\n* `DECR key`：将键 key 存储的数值减一。\n\n②、操作列表的命令有：\n\n* `LPUSH key value`：将一个值插入到列表 key 的头部。\n* `RPUSH key value`：将一个值插入到列表 key 的尾部。\n* `LPOP key`：移除并返回列表 key 的头元素。\n* `RPOP key`：移除并返回列表 key 的尾元素。\n* `LRANGE key start stop`：获取列表 key 中指定范围内的元素。\n\n③、操作集合的命令有：\n\n* `SADD key member`：向集合 key 添加一个元素。\n* `SREM key member`：从集合 key 中移除一个元素。\n* `SMEMBERS key`：返回集合 key 中的所有元素。\n\n④、操作有序集合的命令有：\n\n* `ZADD key score member`：向有序集合 key 添加一个成员，或更新其分数。\n* `ZRANGE key start stop [WITHSCORES]`：按照索引区间返回有序集合 key 中的成员，可选 WITHSCORES 参数返回分数。\n* `ZREVRANGE key start stop [WITHSCORES]`：返回有序集合 key 中，指定区间内的成员，按分数递减。\n* `ZREM key member`：移除有序集合 key 中的一个或多个成员。\n\n⑤、操作哈希的命令有：\n\n* `HSET key field value`：向键为 key 的哈希表中设置字段 field 的值为 value。\n* `HGET key field`：获取键为 key 的哈希表中字段 field 的值。\n* `HGETALL key`：获取键为 key 的哈希表中所有的字段和值。\n* `HDEL key field`：删除键为 key 的哈希表中的一个或多个字段。\n\n#### [详细说说 set 命令？](#详细说说-set-命令)\n\n在 Redis 中，设置键值对的命令是 set。set 命令有几个常用的参数：\n\n①、可以通过 EX 或 PX 为键设置过期时间（秒或毫秒）\n\n\n```shell\nredis-cli SET session_id \"xyz\" EX 3600 # 设置键 session_id，值为 \"xyz\"，过期时间为 3600 秒\n```\n\n\n②、NX 选项表示只有键不存在时才设置\n\n\n```shell\nredis-cli SET lock_key \"locked\" NX\n```\n\n\n③、XX 选项表示只有键存在时才设置\n\n\n```shell\nredis-cli SET config \"new_config\" XX\n```\n\n\n#### [sadd 命令的时间复杂度是多少？](#sadd-命令的时间复杂度是多少)\n\n向指定 Set 中添加 1 个或多个 member，如果指定 Set 不存在，会自动创建一个。**时间复杂度 O(N)** ，N 为添加的 member 个数。\n\n#### [incr命令了解吗？](#incr命令了解吗)\n\nINCR 命令是 Redis 中的一个原子操作，用于将存储在 key 中的数值加 1。\n\nRedis 的单线程模型确保了每个命令都是原子执行的，不会被其他命令打断。"
+ },
+ {
+ "id": 262,
+ "question": "单线程 Redis 的 QPS 是多少？(补充)",
+ "answer": "> 2024 年 4 月 14 日增补\n\nRedis 的 QPS（Queries Per Second，每秒查询率）受多种因素影响，包括硬件配置（如 CPU、内存、网络带宽）、数据模型、命令类型、网络延迟等。\n\n根据官方的基准测试，一个普通服务器的 Redis 实例通常可以达到每秒数万到几十万的 QPS。\n\n可以通过 `redis-benchmark` 命令进行基准测试：\n\n\n```shell\nredis-benchmark -h 127.0.0.1 -p 6379 -c 50 -n 10000\n```\n\n\n* `-h`：指定 Redis 服务器的地址，默认是 127.0.0.1。\n* `-p`：指定 Redis 服务器的端口，默认是 6379。\n* `-c`：并发连接数，即同时有多少个客户端在进行测试。\n* `-n`：请求总数，即测试过程中总共要执行多少个请求。\n\n我本机是一台 macOS，4 GHz 四核 Intel Core i7，32 GB 1867 MHz DDR3，测试结果如下：\n\n\n\n可以看得出，每秒能处理超过 10 万次请求。"
+ }
+ ]
+ },
+ {
+ "id": 40,
+ "categoryName": "持久化",
+ "questions": [
+ {
+ "id": 263,
+ "question": "Redis 持久化⽅式有哪些？有什么区别？",
+ "answer": "Redis 的持久化机制保证了 Redis 服务器在重启后数据不丢失，通过 RDB 和 AOF 文件来恢复内存中原有的数据。\n\n这两种持久化方式可以单独使用，也可以同时使用。\n\n\n\n#### [说一下 RDB？](#说一下-rdb)\n\nRDB 持久化通过创建数据集的快照来工作，在指定的时间间隔内将 Redis 在某一时刻的数据状态保存到磁盘的一个 RDB 文件中。\n\n可通过 save 和 bgsave 命令两个命令来手动触发 RDB 持久化操作：\n\n\n\n**①、save 命令**：会同步地将 Redis 的所有数据保存到磁盘上的一个 RDB 文件中。这个操作会阻塞所有客户端请求直到 RDB 文件被完全写入磁盘。\n\n当 Redis 数据集较大时，使用 SAVE 命令会导致 Redis 服务器停止响应客户端的请求。\n\n不推荐在生产环境中使用，除非数据集非常小，或者可以接受服务暂时的不可用状态。\n\n**②、bgsave 命令**：会在后台异步地创建 Redis 的数据快照，并将快照保存到磁盘上的 RDB 文件中。这个命令会立即返回，Redis 服务器可以继续处理客户端请求。\n\n在 BGSAVE 命令执行期间，Redis 会继续响应客户端的请求，对服务的可用性影响较小。快照的创建过程是由一个子进程完成的，主进程不会被阻塞。是在生产环境中执行 RDB 持久化的推荐方式。\n\n以下场景会自动触发 RDB 持久化：\n\n①、在 Redis 配置文件（通常是 redis.conf）中，可以通过`save `指令配置自动触发 RDB 持久化的条件。这个指令可以设置多次，每个设置定义了一个时间间隔（秒）和该时间内发生的变更次数阈值。\n\n\n```text\nsave 900 1\nsave 300 10\nsave 60 10000\n```\n\n\n这意味着：\n\n* 如果至少有 1 个键被修改，900 秒后自动触发一次 RDB 持久化。\n* 如果至少有 10 个键被修改，300 秒后自动触发一次 RDB 持久化。\n* 如果至少有 10000 个键被修改，60 秒后自动触发一次 RDB 持久化。\n\n满足以上任一条件，RDB 持久化就会被自动触发。\n\n②、当 Redis 服务器通过 SHUTDOWN 命令正常关闭时，如果没有禁用 RDB 持久化，Redis 会自动执行一次 RDB 持久化，以确保数据在下次启动时能够恢复。\n\n③、在 Redis 复制场景中，当一个 Redis 实例被配置为从节点并且与主节点建立连接时，它可能会根据配置接收主节点的 RDB 文件来初始化数据集。这个过程中，主节点会在后台自动触发 RDB 持久化，然后将生成的 RDB 文件发送给从节点。\n\n#### [说一下 AOF？](#说一下-aof)\n\nAOF 持久化通过记录每个写操作命令并将其追加到 AOF 文件中来工作，恢复时通过重新执行这些命令来重建数据集。\n\nAOF 的主要作用是解决了数据持久化的实时性，目前已经是 Redis 持久化的主流方式。\n\nAOF 的工作流程分为四个步骤：命令写入、文件同步、文件重写、重启加载。\n\n\n\n1）当 AOF 持久化机制被启用时，Redis 服务器会将接收到的所有写命令追加到 AOF 缓冲区的末尾。\n\n2）接着将缓冲区中的命令刷新到磁盘的 AOF 文件中，刷新策略有三种：\n\n* always：每次写命令都会同步到 AOF 文件。\n* everysec（默认）：每秒同步一次。如果系统崩溃，可能会丢失最后一秒的数据。\n* no：在这种模式下，如果发生宕机，那么丢失的数据量由操作系统内核的缓存冲洗策略决定。\n\n3）随着 AOF 文件的不断增长，Redis 会启用重写机制来生成一个更小的 AOF 文件：\n\n* 将内存中每个键值对的当前状态转换为一条最简单的 Redis 命令，写入到一个新的 AOF 文件中。即使某个键被修改了多次，在新的 AOF 文件中也只会保留最终的状态。\n* Redis 会 fork 一个子进程，子进程负责重写 AOF 文件，主进程不会被阻塞。\n\n\n```text\n主进程（fork） \n │ \n ├─→ 子进程（生成新的 AOF 文件） \n │ │ \n │ ├─→ 内存快照 \n │ ├─→ 写入临时 AOF 文件 \n │ ├─→ 通知主进程完成 \n │ \n ├─→ 主进程（追加缓冲区到新 AOF 文件） \n ├─→ 替换旧 AOF 文件 \n ├─→ 重写完成\n```\n\n\n4）当 Redis 服务器重启时，会读取 AOF 文件中的所有命令并重新执行它们，以恢复重启前的内存状态。\n\n#### [AOF 文件存储的是什么类型的数据？](#aof-文件存储的是什么类型的数据)\n\nAOF 文件存储的是 Redis 所有的写操作命令，比如 SET、HSET、INCR 等。\n\n\n\n#### [AOF重写期间命令可能会写入两次，会造成什么影响？](#aof重写期间命令可能会写入两次-会造成什么影响)\n\nAOF 重写期间，Redis 会将新的写命令同时写入旧的 AOF 文件和重写缓冲区。\n\n这样会带来额外的磁盘开销。\n\n但可以防止在 AOF 重写尚未完成时，Redis 发生崩溃，导致数据丢失。即使重写失败，旧的 AOF 文件仍然是完整的。\n\n当重写完成后，会通过原子操作将新的 AOF 文件替换旧的 AOF 文件。"
+ },
+ {
+ "id": 264,
+ "question": "RDB 和 AOF 各自有什么优缺点？",
+ "answer": "RDB 是一个非常紧凑的单文件（二进制文件 dump.rdb），代表了 Redis 在某个时间点上的数据快照。非常适合用于备份数据，比如在夜间进行备份，然后将 RDB 文件复制到远程服务器。但可能会丢失最后一次持久化后的数据。\n\nAOF 的最大优点是灵活，实时性好，可以设置不同的 fsync 策略，如每秒同步一次，每次写入命令就同步，或者完全由操作系统来决定何时同步。但 AOF 文件往往比较大，恢复速度慢，因为它记录了每个写操作。"
+ },
+ {
+ "id": 265,
+ "question": "RDB 和 AOF 如何选择？",
+ "answer": "如果需要尽可能减少数据丢失，AOF 是更好的选择。尤其是在频繁写入的环境下，设置 AOF 每秒同步可以最大限度减少数据丢失。\n\n如果性能是首要考虑，RDB 可能更适合。RDB 的快照生成通常对性能影响较小，并且数据恢复速度快。\n\n如果系统需要经常重启，并且希望系统重启后快速恢复，RDB 可能是更好的选择。虽然 AOF 也提供了良好的恢复能力，但重写 AOF 文件可能会比较慢。\n\n在许多生产环境中，同时启用 RDB 和 AOF 被认为是最佳实践：\n\n* 使用 RDB 进行快照备份。\n* 使用 AOF 保证崩溃后的最大数据完整性。"
+ },
+ {
+ "id": 266,
+ "question": "Redis 的数据恢复？",
+ "answer": "当 Redis 中的数据丢失时，可以从 RDB 或者 AOF 中恢复数据。\n\n可以将 RDB 文件或者 AOF 文件复制到 Redis 的数据目录下，然后重启 Redis 服务，Redis 会自动加载数据文件并恢复数据。\n\n\n\n**Redis** 启动时加载数据的流程：\n\n1. AOF 开启且存在 AOF 文件时，优先加载 AOF 文件。\n2. AOF 关闭或者 AOF 文件不存在时，加载 RDB 文件。"
+ },
+ {
+ "id": 267,
+ "question": "Redis 4.0 的混合持久化了解吗？",
+ "answer": "在 Redis 中，RDB 持久化是通过创建数据的快照来保存数据的，而 AOF 持久化则是通过记录每个写入命令来保存数据的。\n\n两种方式各有优缺点。RDB 持久化的优点是恢复大数据集的速度比较快，但是可能会丢失最后一次快照以后的数据。AOF 持久化的优点是数据的完整性比较高，通常只会丢失一秒的数据，但是对于大数据集，AOF 文件可能会比较大，恢复的速度比较慢。\n\n在 Redis 4.0 版本中，混合持久化模式会在 AOF 重写的时候同时生成一份 RDB 快照，然后将这份快照作为 AOF 文件的一部分，最后再附加新的写入命令。\n\n\n\n这样，当需要恢复数据时，Redis 先加载 RDB 文件来恢复到快照时刻的状态，然后应用 RDB 之后记录的 AOF 命令来恢复之后的数据更改，既快又可靠。\n\n#### [如何设置持久化模式？](#如何设置持久化模式)\n\n可以通过编辑 Redis 的配置文件 redis.conf 来进行设置，或者在运行时通过 Redis 命令行动态调整。\n\nRDB 持久化通过在配置文件中设置快照（snapshotting）规则来启用。这些规则定义了在多少秒内如果有多少个键被修改，则自动执行一次持久化操作。\n\n\n```shell\nsave 900 1 # 如果至少有1个键被修改，900秒后自动保存一次\nsave 300 10 # 如果至少有10个键被修改，300秒后自动保存一次\nsave 60 10000 # 如果至少有10000个键被修改，60秒后自动保存一次\n```\n\n\nAOF 持久化是通过在配置文件中设置 appendonly 参数为 yes 来启用的：\n\n\n```shell\nappendonly yes\n```\n\n\n此外，还可以配置 AOF 文件的写入频率，这是通过 appendfsync 设置的：\n\n\n```shell\nappendfsync always # 每次写入数据都同步，保证数据不丢失，但性能较低\nappendfsync everysec # 每秒同步一次，折衷方案\nappendfsync no # 由操作系统决定何时同步，性能最好，但数据安全性最低\n```\n\n\n为了优化 AOF 文件的大小，Redis 允许自动或手动重写 AOF 文件。可以在配置文件中设置重写的触发条件：\n\n\n```shell\nauto-aof-rewrite-percentage 100 # 增长到原大小的100%时触发重写\nauto-aof-rewrite-min-size 64mb # AOF 文件至少达到64MB时才考虑重写\n```\n\n\n手动执行 AOF 重写的命令是：\n\n\n```shell\nredis-cli bgrewriteaof\n```\n\n\n如果决定同时使用 RDB 和 AOF，可以在配置文件中同时启用两者。\n\n\n```shell\nsave 900 1\nappendonly yes\n```\n\n\n还可以在运行时动态更改：\n\n\n```shell\nredis-cli config set save \"900 1 300 10 60 10000\"\nredis-cli config set appendonly yes\nredis-cli config set appendfsync everysec\n```"
+ }
+ ]
+ },
+ {
+ "id": 41,
+ "categoryName": "高可用",
+ "questions": [
+ {
+ "id": 268,
+ "question": "主从复制了解吗？",
+ "answer": "主从复制是指将一台 Redis 服务器的数据，复制到其他的 Redis 服务器。\n\n前者称为主节点 master，后者称为从节点slave。且数据的复制是单向的，只能由主节点到从节点。\n\n\n\n在 Redis 主从架构中，主节点负责处理所有的写操作，并将这些操作异步复制到从节点。从节点主要用于读取操作，以分担主节点的压力和提高读性能。\n\n#### [主从复制主要的作用是什么?](#主从复制主要的作用是什么)\n\n①、**数据冗余：** 主从复制实现了数据的热备份，是持久化之外的一种数据冗余方式。\n\n②、**故障恢复：** 如果主节点挂掉了，可以将一个从节点提升为主节点，从而实现故障的快速恢复。\n\n通常会使用 Sentinel 哨兵来实现自动故障转移，当主节点挂掉时，Sentinel 会自动将一个从节点升级为主节点，保证系统的可用性。\n\n\n```shell\n# sentinel.conf\n\nport 26379\nsentinel monitor mymaster 192.168.1.1 6379 2\nsentinel down-after-milliseconds mymaster 5000\nsentinel failover-timeout mymaster 60000\nsentinel parallel-syncs mymaster 1\n```\n\n\n假如是从节点挂掉了，主节点不受影响，但应该尽快修复并重启挂掉的从节点，使其重新加入集群并从主节点同步数据。\n\n③、**负载均衡：** 在主从复制的基础上，配合读写分离，可以由主节点提供写服务，由从节点提供读服务 *（即写 Redis 时连接主节点，读 Redis 时连接从节点）*，分担服务器负载。尤其是在写少读多的场景下，通过多个从节点分担读负载，可以大大提高 Redis 服务器的并发量。\n\n④、**高可用基石：** 除了上述作用以外，主从复制还是哨兵和集群能够实施的 **基础**。\n\n#### [主从复制出现数据不一致怎么办？](#主从复制出现数据不一致怎么办)\n\nRedis 的主从复制是异步进行的，这意味着主节点在执行完写操作后，会立即返回给客户端，而不是等待从节点完成数据同步。\n\n在主节点将数据同步到从节点的过程中，可能会出现网络延迟或中断，从而导致从节点的数据滞后于主节点。\n\n为了解决数据不一致的问题，应该尽量保证主从节点之间的网络连接状况良好，比如说避免在不同机房之间部署主从节点，以减少网络延迟。但可能会带来新的问题，就是整个机房都挂掉的情况。\n\n此外，Redis 本身也提供了一些机制来解决数据不一致的问题，比如说通过 Redis 的 `INFO replication` 命令监控主从节点的复制进度，及时发现和处理复制延迟。\n\n具体做法是获取主节点的 master\\_repl\\_offset 和从节点的 slave\\_repl\\_offset，计算两者的差值。如果差值超过预设的阈值，采取措施（如停止从节点的数据读取）以减少读到不一致数据的情况。\n\n\n\n#### [Redis解决单点故障主要靠什么？](#redis解决单点故障主要靠什么)\n\n主从复制，当主节点发生故障时，可以通过手动或自动方式将某个从节点提升为新的主节点，继续对外提供服务，从而避免单点故障。\n\nRedis 的哨兵机制（Sentinel）可以实现自动化的故障转移，当主节点宕机时，哨兵会自动将一个从节点升级为新的主节点。\n\n另外，集群模式下，当某个节点发生故障时，Redis Cluster 会自动将请求路由到其他节点，并通过从节点进行故障恢复。"
+ },
+ {
+ "id": 269,
+ "question": "Redis 主从有几种常见的拓扑结构？",
+ "answer": "Redis 的复制拓扑结构可以支持单层或多层复制关系，根据拓扑复杂性可以分为以下三种：一主一从、一主多从、树状主从结构。\n\n1.一主一从结构\n\n一主一从结构是最简单的复制拓扑结构，用于主节点出现宕机时从节点提供故障转移支持。\n\n 2.一主多从结构\n\n一主多从结构（又称为星形拓扑结构）使得应用端可以利用多个从节点实现读写分离（见图 6-5）。对于读占比较大的场景，可以把读命令发送到从节点来分担主节点压力。\n\n 3.树状主从结构\n\n树状主从结构（又称为树状拓扑结构）使得从节点不但可以复制主节点数据，同时可以作为其他从节点的主节点继续向下层复制。通过引入复制中间层，可以有效降低主节点负载和需要传送给从节点的数据量。\n\n"
+ },
+ {
+ "id": 270,
+ "question": "Redis 的主从复制原理了解吗？",
+ "answer": "Redis 主从复制的工作流程大概可以分为如下几步： \n\n1. 保存主节点（master）信息 这一步只是保存主节点信息，保存主节点的 ip 和 port。\n2. 主从建立连接 从节点（slave）发现新的主节点后，会尝试和主节点建立网络连接。\n3. 发送 ping 命令 连接建立成功后从节点发送 ping 请求进行首次通信，主要是检测主从之间网络套接字是否可用、主节点当前是否可接受处理命令。\n4. 权限验证 如果主节点要求密码验证，从节点必须正确的密码才能通过验证。\n5. 同步数据集 主从复制连接正常通信后，主节点会把持有的数据全部发送给从节点。\n6. 命令持续复制 接下来主节点会持续地把写命令发送给从节点，保证主从数据一致性。"
+ },
+ {
+ "id": 271,
+ "question": "说说主从数据同步的方式？",
+ "answer": "Redis 在 2.8 及以上版本使用 psync 命令完成主从数据同步，同步过程分为：全量复制和部分复制。\n\n\n\n**全量复制** 一般用于初次复制场景，Redis 早期支持的复制功能只有全量复制，它会把主节点全部数据一次性发送给从节点，当数据量较大时，会对主从节点和网络造成很大的开销。\n\n全量复制的完整运行流程如下： \n\n1. 发送 psync 命令进行数据同步，由于是第一次进行复制，从节点没有复制偏移量和主节点的运行 ID，所以发送 psync-1。\n2. 主节点根据 psync-1 解析出当前为全量复制，回复+FULLRESYNC 响应。\n3. 从节点接收主节点的响应数据保存运行 ID 和偏移量 offset\n4. 主节点执行 bgsave 保存 RDB 文件到本地\n5. 主节点发送 RDB 文件给从节点，从节点把接收的 RDB 文件保存在本地并直接作为从节点的数据文件\n6. 对于从节点开始接收 RDB 快照到接收完成期间，主节点仍然响应读写命令，因此主节点会把这期间写命令数据保存在复制客户端缓冲区内，当从节点加载完 RDB 文件后，主节点再把缓冲区内的数据发送给从节点，保证主从之间数据一致性。\n7. 从节点接收完主节点传送来的全部数据后会清空自身旧数据\n8. 从节点清空数据后开始加载 RDB 文件\n9. 从节点成功加载完 RDB 后，如果当前节点开启了 AOF 持久化功能， 它会立刻做 bgrewriteaof 操作，为了保证全量复制后 AOF 持久化文件立刻可用。\n\n**部分复制** 部分复制主要是 Redis 针对全量复制的过高开销做出的一种优化措施， 使用 psync{runId}{offset}命令实现。当从节点（slave）正在复制主节点 （master）时，如果出现网络闪断或者命令丢失等异常情况时，从节点会向 主节点要求补发丢失的命令数据，如果主节点的复制积压缓冲区内存在这部分数据则直接发送给从节点，这样就可以保持主从节点复制的一致性。\n\n\n\n1. 当主从节点之间网络出现中断时，如果超过 repl-timeout 时间，主节点会认为从节点故障并中断复制连接\n2. 主从连接中断期间主节点依然响应命令，但因复制连接中断命令无法发送给从节点，不过主节点内部存在的复制积压缓冲区，依然可以保存最近一段时间的写命令数据，默认最大缓存 1MB。\n3. 当主从节点网络恢复后，从节点会再次连上主节点\n4. 当主从连接恢复后，由于从节点之前保存了自身已复制的偏移量和主节点的运行 ID。因此会把它们当作 psync 参数发送给主节点，要求进行部分复制操作。\n5. 主节点接到 psync 命令后首先核对参数 runId 是否与自身一致，如果一 致，说明之前复制的是当前主节点；之后根据参数 offset 在自身复制积压缓冲区查找，如果偏移量之后的数据存在缓冲区中，则对从节点发送+CONTINUE 响应，表示可以进行部分复制。\n6. 主节点根据偏移量把复制积压缓冲区里的数据发送给从节点，保证主从复制进入正常状态。"
+ },
+ {
+ "id": 272,
+ "question": "主从复制存在哪些问题呢？",
+ "answer": "Redis 主从复制虽然实现了读写分离和数据备份，但也存在一些明显的缺点：\n\n* 由于主从复制是异步的，如果主节点在数据尚未完全同步到从节点时崩溃，会导致数据丢失。\n* 写操作集中在主节点，从节点只能处理读操作，无法分担写入压力。\n* 在网络分区的情况下，主节点和从节点可能无法相互通信，导致两个节点都被认为是主节点，形成多个主节点的情况，也就是脑裂。\n\n#### [脑裂问题了解吗？](#脑裂问题了解吗)\n\nRedis 的脑裂问题是指在主从模式或集群模式下，由于网络分区或节点故障，可能导致系统中出现多个主节点，从而引发数据不一致、数据丢失等问题。\n\n可以通过 Sentinel 模式和 Cluster 模式中的投票机制和强制下线机制来解决。"
+ },
+ {
+ "id": 273,
+ "question": "Redis 哨兵了解吗？",
+ "answer": "哨兵（Sentinel）机制是 Redis 提供的一个高可用性解决方案，主要用来监控 Redis 主从架构中的实例，并在主节点出现故障时，自动进行故障转移。\n\n"
+ },
+ {
+ "id": 274,
+ "question": "Redis 哨兵实现原理知道吗？",
+ "answer": "哨兵的工作流程包括定时监控、主观下线和客观下线、领导者 Sentinel 节点选举、故障转移等。\n\n\n\n每个 Sentinel 实例会定期通过 PING 命令向主节点和从节点发送心跳包。\n\n\n\n如果一个节点长时间没有响应 PING 命令，Sentinel 会将该节点标记为主观下线。当多个 Sentinel 同时认为一个节点不可用时，该节点被标记为客观下线。\n\n\n\n当主节点被确认下线后，Sentinel 之间会通过类似 Raft 的选举算法进行协商，选出一个领导者 Sentinel 来负责执行故障转移。\n\n\n\n1. 将某个从节点提升为新的主节点。\n2. 通知其他从节点重新复制新的主节点的数据。"
+ },
+ {
+ "id": 275,
+ "question": "领导者 Sentinel 节点选举了解吗？",
+ "answer": "Redis 使用 Raft 算法实现领导者选举的：当主节点挂掉后，新的主节点是由剩余的从节点发起选举后晋升的。\n\n\n\n①、每个在线的 Sentinel 节点都有资格成为领导者，当它确认主节点下线时候，会向其他哨兵节点发送命令，表明希望由自己来执行主从切换，并让所有其他哨兵进行投票。\n\n这个投票过程称为“Leader 选举”。候选者会给自己先投 1 票，然后向其他 Sentinel 节点发送投票的请求。\n\n②、收到请求的 Sentinel 节点会进行判断，如果候选者的日志与自己的日志一样新，任期号也小于自己，且之前没有投票过，就会同意投票，回复 Y。否则回复 N。\n\n③、候选者收到投票后会统计支持自己的得票数，如果候选者获得了集群中超过半数节点的投票支持（即多数原则），它将成为新的主节点。\n\n新的主节点在确立后，会向其他从节点发送心跳信号，告诉它们自己已经成为主节点，并将其他节点的状态重置为从节点。\n\n④、如果多个节点同时成为候选者，并且都有可能获得足够的票数，这种情况下可能会出现选票分裂。也就是没有候选者获得超过半数的选票，那么这次选举就会失败，所有候选者都会再次发起选举。\n\n为了防止无限制的选举失败，每个节点都会有一个选举超时时间，且是随机的。\n\n> 超时时间指从节点在没有收到主节点的心跳信号或日志追加请求后，等待多长时间才会认为主节点已挂掉，从而进入候选状态并发起选举。"
+ },
+ {
+ "id": 276,
+ "question": "新的主节点是怎样被挑选出来的？",
+ "answer": "选出新的主节点，大概分为这么几步： \n\n1. 过滤：“不健康”（主观下线、断线）、5 秒内没有回复过 Sentinel 节 点 ping 响应、与主节点失联超过 down-after-milliseconds\\*10 秒。\n2. 选择 slave-priority（从节点优先级）最高的从节点列表，如果存在则返回，不存在则继续。\n3. 选择复制偏移量最大的从节点（复制的最完整），如果存在则返 回，不存在则继续。\n4. 选择 runid 最小的从节点。"
+ },
+ {
+ "id": 277,
+ "question": "Redis 集群了解吗？",
+ "answer": "前面说到了主从存在高可用和分布式的问题，哨兵解决了高可用的问题，而集群就是终极方案，一举解决高可用和分布式问题。\n\n\n\n1. **数据分区：** 数据分区 *(或称数据分片)* 是集群最核心的功能。集群将数据分散到多个节点，一方面 突破了 Redis 单机内存大小的限制，**存储容量大大增加**；**另一方面** 每个主节点都可以对外提供读服务和写服务，**大大提高了集群的响应能力**。\n2. **高可用：** 集群支持主从复制和主节点的 **自动故障转移** *（与哨兵类似）*，当任一节点发生故障时，集群仍然可以对外提供服务。"
+ },
+ {
+ "id": 278,
+ "question": "Redis Cluster了解吗？（补充）",
+ "answer": "> 2024 年 04 月 26 日新增\n\n切片集群是一种将数据分片存储在多个 Redis 实例上的集群架构，每个 Redis 实例负责存储部分数据。比如说把 25G 的数据平均分为 5 份，每份 5G，然后启动 5 个 Redis 实例，每个实例保存一份数据。\n\n\n\n在 Redis 3.0 之前，官方并没有针对切片集群提供具体的解决方案；但是在 Redis 3.0 之后，官方提供了 Redis Cluster，数据和实例之间的映射通过哈希槽（hash slot）来实现。\n\nRedis Cluster 有 16384 个哈希槽，每个键根据其名字的 CRC16 值被映射到这些哈希槽上。然后，这些哈希槽会被均匀地分配到所有的 Redis 实例上。\n\n> CRC16 是一种哈希算法，它可以将任意长度的输入数据映射为一个 16 位的哈希值。\n\n\n\n例如，如果我们有 3 个 Redis 实例，那么每个实例可能会负责大约 5461 个哈希槽。\n\n当需要存储或检索一个键值对时，Redis Cluster 会先计算这个键的哈希槽，然后找到负责这个哈希槽的 Redis 实例，最后在这个实例上进行操作。"
+ },
+ {
+ "id": 279,
+ "question": "集群中数据如何分区？",
+ "answer": "在 Redis 集群中，数据分区是通过将数据分散到不同的节点来实现的，常见的数据分区规则有三种：节点取余分区、一致性哈希分区、虚拟槽分区。\n\n\n\n#### [说说节点取余分区](#说说节点取余分区)\n\n节点取余分区是一种简单的分区策略，其中数据项通过对某个值（通常是键的哈希值）进行取余操作来分配到不同的节点。\n\n类似 HashMap 中的取余操作，数据项的键经过哈希函数计算后，对节点数量取余，然后将数据项分配到余数对应的节点上。\n\n缺点是扩缩容时，大多数数据需要重新分配，因为节点总数的改变会影响取余结果，这可能导致大量数据迁移。\n\n\n\n#### [说说一致性哈希分区](#说说一致性哈希分区)\n\n一致性哈希分区的原理是：将哈希值空间组织成一个环，数据项和节点都映射到这个环上。数据项由其哈希值直接映射到环上，然后顺时针分配到遇到的第一个节点。\n\n从而来减少节点变动时数据迁移的量。\n\n\n\nKey 1 和 Key 2 会落入到 Node 1 中，Key 3、Key 4 会落入到 Node 2 中，Key 5 落入到 Node 3 中，Key 6 落入到 Node 4 中。\n\n这种方式相比节点取余最大的好处在于加入和删除节点只影响哈希环中相邻的节点，对其他节点无影响。\n\n但它还是存在问题：\n\n* 节点在圆环上分布不平均，会造成部分缓存节点的压力较大\n* 当某个节点故障时，这个节点所要承担的所有访问都会被顺移到另一个节点上，会对后面这个节点造成压力。\n\n#### [说说虚拟槽分区？](#说说虚拟槽分区)\n\n在虚拟槽（也叫哈希槽）分区中，槽位的数量是固定的（例如 Redis Cluster 有 16384 个槽），每个键通过哈希算法（比如 CRC16）映射到这些槽上，每个集群节点负责管理一定范围内的槽。\n\n这种分区可以灵活地将槽（以及槽中的数据）从一个节点迁移到另一个节点，从而实现平滑扩容和缩容；数据分布也更加均匀，Redis Cluster 采用的正是这种分区方式。\n\n\n\n假设系统中有 4 个实际节点，假设为其分配了 16 个槽(0-15)；\n\n* 槽 0-3 位于节点 node1；\n* 槽 4-7 位于节点 node2；\n* 槽 8-11 位于节点 node3；\n* 槽 12-15 位于节点 node4。\n\n如果此时删除 `node2`，只需要将槽 4-7 重新分配即可，例如将槽 4-5 分配给 `node1`，槽 6 分配给 `node3`，槽 7 分配给 `node4`，数据在节点上的分布仍然较为均衡。\n\n如果此时增加 node5，也只需要将一部分槽分配给 node5 即可，比如说将槽 3、槽 7、槽 11、槽 15 迁移给 node5，节点上的其他槽位保留。\n\n当然了，这取决于 `CRC16(key) % 槽的个数` 的具体结果。因为在 Redis Cluster 中，槽的个数刚好是 2 的 14 次方，这和 HashMap 中数组的长度必须是 2 的幂次方有着异曲同工之妙。\n\n它能保证扩容后，大部分数据停留在扩容前的位置，只有少部分数据需要迁移到新的槽上。"
+ },
+ {
+ "id": 280,
+ "question": "能说说 Redis 集群的原理吗？",
+ "answer": "Redis 集群通过数据分区来实现数据的分布式存储，通过自动故障转移实现高可用。\n\n##### [集群创建](#集群创建)\n\n数据分区是在集群创建的时候完成的。\n\n\n\n**设置节点** Redis 集群一般由多个节点组成，节点数量至少为 6 个才能保证组成完整高可用的集群。每个节点需要开启配置 cluster-enabled yes，让 Redis 运行在集群模式下。\n\n\n\n**节点握手** 节点握手是指一批运行在集群模式下的节点通过 Gossip 协议彼此通信， 达到感知对方的过程。节点握手是集群彼此通信的第一步，由客户端发起命 令：cluster meet{ip}{port}。完成节点握手之后，一个个的 Redis 节点就组成了一个多节点的集群。\n\n**分配槽（slot）** Redis 集群把所有的数据映射到 16384 个槽中。每个节点对应若干个槽，只有当节点分配了槽，才能响应和这些槽关联的键命令。通过 cluster addslots 命令为节点分配槽。\n\n\n\n##### [故障转移](#故障转移)\n\nRedis 集群的故障转移和哨兵的故障转移类似，但是 Redis 集群中所有的节点都要承担状态维护的任务。\n\n**故障发现** Redis 集群内节点通过 ping/pong 消息实现节点通信，集群中每个节点都会定期向其他节点发送 ping 消息，接收节点回复 pong 消息作为响应。如果在 cluster-node-timeout 时间内通信一直失败，则发送节 点会认为接收节点存在故障，把接收节点标记为主观下线（pfail）状态。\n\n\n\n当某个节点判断另一个节点主观下线后，相应的节点状态会跟随消息在集群内传播。通过 Gossip 消息传播，集群内节点不断收集到故障节点的下线报告。当 半数以上持有槽的主节点都标记某个节点是主观下线时。触发客观下线流程。\n\n\n\n**故障恢复**\n\n故障节点变为客观下线后，如果下线节点是持有槽的主节点则需要在它 的从节点中选出一个替换它，从而保证集群的高可用。\n\n\n\n1. 资格检查 每个从节点都要检查最后与主节点断线时间，判断是否有资格替换故障 的主节点。\n2. 准备选举时间 当从节点符合故障转移资格后，更新触发故障选举的时间，只有到达该 时间后才能执行后续流程。\n3. 发起选举 当从节点定时任务检测到达故障选举时间（failover\\_auth\\_time）到达后，发起选举流程。\n4. 选举投票 持有槽的主节点处理故障选举消息。投票过程其实是一个领导者选举的过程，如集群内有 N 个持有槽的主节 点代表有 N 张选票。由于在每个配置纪元内持有槽的主节点只能投票给一个 从节点，因此只能有一个从节点获得 N/2+1 的选票，保证能够找出唯一的从节点。\n\n \n5. 替换主节点 当从节点收集到足够的选票之后，触发替换主节点操作。\n\n#### [部署 Redis 集群至少需要几个物理节点？](#部署-redis-集群至少需要几个物理节点)\n\n在投票选举的环节，故障主节点也算在投票数内，假设集群内节点规模是 3 主 3 从，其中有 2 个主节点部署在一台机器上，当这台机器宕机时，由于从节点无法收集到 3/2+1 个主节点选票将导致故障转移失败。这个问题也适用于故障发现环节。因此部署集群时所有主节点最少需要部署在 3 台物理机上才能避免单点问题。"
+ },
+ {
+ "id": 281,
+ "question": "说说集群的伸缩？",
+ "answer": "Redis 集群使用数据分片和哈希槽的机制将数据分布到不同的节点上。集群扩容和缩容的关键，在于槽和节点之间的对应关系。\n\n\n\n当需要扩容时，新的节点被添加到集群中，集群会自动执行数据迁移，以重新分布哈希槽到新的节点。数据迁移的过程可以确保在扩容期间数据的正常访问和插入。\n\n\n\n当数据正在迁移时，客户端请求可能被路由到原有节点或新节点。Redis Cluster 会根据哈希槽的映射关系判断请求应该被路由到哪个节点，并在必要时进行重定向。\n\n如果请求被路由到正在迁移数据的哈希槽，Redis Cluster 会返回一个 MOVED 响应，指示客户端重新路由请求到正确的目标节点。这种机制也就保证了数据迁移过程中的最终一致性。\n\n当需要缩容时，Redis 集群会将槽从要缩容的节点上迁移到其他节点上，然后将要缩容的节点从集群中移除。"
+ }
+ ]
+ },
+ {
+ "id": 42,
+ "categoryName": "缓存设计",
+ "questions": [
+ {
+ "id": 282,
+ "question": "缓存击穿、缓存穿透、缓存雪崩了解吗？",
+ "answer": "缓存穿透、缓存击穿和缓存雪崩是指在使用 Redis 做缓存时可能遇到的三种高并发场景下的问题。\n\n#### [什么是缓存击穿？](#什么是缓存击穿)\n\n缓存击穿是指某一个或少数几个数据被高频访问，当这些数据在缓存中过期的那一刻，大量请求就会直接到达数据库，导致数据库瞬间压力过大。\n\n\n\n解决⽅案：\n\n①、加锁更新，⽐如请求查询 A，发现缓存中没有，对 A 这个 key 加锁，同时去数据库查询数据，写⼊缓存，再返回给⽤户，这样后⾯的请求就可以从缓存中拿到数据了。\n\n\n\n②、将过期时间组合写在 value 中，通过异步的⽅式不断的刷新过期时间，防⽌此类现象。\n\n#### [什么是缓存穿透？](#什么是缓存穿透)\n\n缓存穿透是指查询不存在的数据，由于缓存没有命中（因为数据根本就不存在），请求每次都会穿过缓存去查询数据库。如果这种查询非常频繁，就会给数据库造成很大的压力。\n\n\n\n缓存穿透意味着缓存失去了减轻数据压力的意义。缓存穿透可能有两种原因：\n\n1. 自身业务代码问题\n2. 恶意攻击，爬虫造成空命中\n\n它主要有两种解决办法：\n\n①、**缓存空值/默认值**\n\n客户端请求某个 ID 的数据，首先检查缓存是否命中。如果缓存未命中，查询数据库。如果数据库查询结果为空，将该空结果（如 null 或 {}）缓存起来，并设置一个合理的过期时间。当后续请求再访问相同 ID 时，缓存直接返回空结果，避免每次都打到数据库。\n\n\n\n代码示例：\n\n\n```java\nString cacheKey = \"product::\" + productId;\nString result = cache.get(cacheKey);\n\nif (result == null) {\n result = database.queryProductById(productId);\n\n if (result == null) {\n // 缓存空值，设置较短的过期时间\n cache.set(cacheKey, \"null\", shortTTL);\n } else {\n // 缓存有效数据\n cache.set(cacheKey, result, longTTL);\n }\n}\n```\n\n\n②、**布隆过滤器**\n\n通过布隆过滤器存储所有可能存在的合法数据的键，当请求到达时，先通过布隆过滤器判断该键是否存在：\n\n* 如果布隆过滤器认为该键不存在，直接返回空，不会查询数据库。\n* 如果布隆过滤器认为该键可能存在，则查询缓存和数据库。\n\n\n\n代码示例：\n\n\n```java\nBloomFilter bloomFilter = new BloomFilter<>(expectedInsertions, fpp); // 期望插入量和误判率\nbloomFilter.put(\"valid_key_1\");\nbloomFilter.put(\"valid_key_2\");\n\n// 判断请求的键是否存在于布隆过滤器中\nif (!bloomFilter.mightContain(requestedKey)) {\n // 如果布隆过滤器认为该键不存在，则直接返回空\n return null;\n} else {\n // 继续正常的缓存查询和数据库查询流程\n}\n```\n\n\n两种解决方案的对比：\n\n\n\n#### [什么是缓存雪崩？](#什么是缓存雪崩)\n\n缓存雪崩是指在某一个时间点，由于大量的缓存数据同时过期或缓存服务器突然宕机了，导致所有的请求都落到了数据库上（比如 MySQL），从而对数据库造成巨大压力，甚至导致数据库崩溃的现象。\n\n总之就是，崩了，崩的非常严重，就叫雪崩了（电影电视里应该看到过，非常夸张）。\n\n\n\n#### [如何解决缓存雪崩呢？](#如何解决缓存雪崩呢)\n\n第一种：提高缓存可用性\n\n**01、集群部署**：采用分布式缓存而不是单一缓存服务器，可以降低单点故障的风险。即使某个缓存节点发生故障，其他节点仍然可以提供服务，从而避免对数据库的大量直接访问。\n\n可以利用 Redis Cluster。\n\n\n\n或者第三方集群方案 Codis。\n\n\n\n**02、备份缓存**：对于关键数据，除了在主缓存中存储，还可以在备用缓存中保存一份。当主缓存不可用时，可以快速切换到备用缓存，确保系统的稳定性和可用性。\n\n在中，我们采用了多级缓存的策略，其中就包括使用本地缓存 Guava Cache 和 Caffeine 来作为二级缓存，在 Redis 出现问题时，系统会自动切换到本地缓存。\n\n这个过程称为“降级”，意味着系统在失去优先级高的资源时仍能继续提供服务。\n\n当从 Redis 获取数据失败时，尝试从本地缓存读取数据。\n\n\n```java\nLoadingCache permissionsCache = Caffeine.newBuilder()\n .maximumSize(1000)\n .expireAfterWrite(10, TimeUnit.MINUTES)\n .build(this::loadPermissionsFromRedis);\n\npublic UserPermissions loadPermissionsFromRedis(String userId) {\n try {\n return redisClient.getPermissions(userId);\n } catch (Exception ex) {\n // Redis 异常处理，尝试从本地缓存获取\n return permissionsCache.getIfPresent(userId);\n }\n}\n```\n\n\n第二种：过期时间\n\n对于缓存数据，设置不同的过期时间，避免大量缓存数据同时过期。可以通过在原有过期时间的基础上添加一个随机值来实现，这样可以分散缓存过期时间，减少同一时间对数据库的访问压力。\n\n第三种：限流和降级\n\n通过设置合理的系统限流策略，如令牌桶或漏斗算法，来控制访问流量，防止在缓存失效时数据库被打垮。\n\n此外，系统可以实现降级策略，在缓存雪崩或系统压力过大时，暂时关闭一些非核心服务，确保核心服务的正常运行。"
+ },
+ {
+ "id": 283,
+ "question": "能说说布隆过滤器吗？",
+ "answer": "布隆过滤器是一种空间效率极高的概率型数据结构，用于快速检查一个元素是否存在于一个集合中。\n\n\n\n布隆过滤器由一个长度为 m 的位数组和 k 个哈希函数组成。\n\n* 开始时，布隆过滤器的每个位都被设置为 0。\n* 当一个元素被添加到过滤器中时，它会被 k 个哈希函数分别计算得到 k 个位置，然后将位数组中对应的位设置为 1。\n* 当检查一个元素是否存在于过滤器中时，同样使用 k 个哈希函数计算位置，如果任一位置的位为 0，则该元素肯定不在过滤器中；如果所有位置的位都为 1，则该元素可能在过滤器中。\n\n#### [布隆过滤器存在误判吗？](#布隆过滤器存在误判吗)\n\n布隆过滤器的优点是空间效率和查询时间都远远超过一般的算法，缺点是存在误判和删除困难。\n\n\n\n当布隆过滤器保存的元素越多，被置为 1 的 bit 位就会越多。假设元素 x 没有存储过，但其他元素的哈希函数映射到位数组的三个位刚好都为 1 且恰好覆盖了元素 x 映射的位置，那么对于布隆过滤器来讲，元素 x 这个值就是存在的，也就是说布隆过滤器存在一定的误判率。\n\n布隆过滤器的误判率取决于以下几个因素：\n\n1. 位数组的大小（m）：位数组的大小决定了可以存储的标志位数量。如果位数组过小，那么哈希碰撞的几率就会增加，从而导致更高的误判率。\n2. 哈希函数的数量（k）：哈希函数的数量决定了每个元素在位数组中标记的位数。哈希函数越多，碰撞的概率也会相应变化。如果哈希函数太少，则过滤器很快会变得不精确；如果太多，误判率也会升高，效率下降。\n3. 存入的元素数量（n）：存入的元素越多，哈希碰撞的几率越大，从而导致更高的误判率。\n\n\n\n误判率公式如下：\n\nf(k)=(1−e−knm)k\n\n虽然布隆过滤器会产生误判，但在很多场景下一定的误判率是可以接受的，这是因为布隆过滤器的主要优点是其高效的查询速度和低内存占用。相比其他精确的集合数据结构（如哈希表、树等），布隆过滤器可以在空间效率和查询速度上表现更优。\n\n#### [布隆过滤器支持删除吗？](#布隆过滤器支持删除吗)\n\n布隆过滤器其实并不支持删除元素，因为多个元素可能哈希到一个布隆过滤器的同一个位置，如果直接删除该位置的元素，则会影响其他元素的判断。\n\n#### [为什么不能用哈希表而是用布隆过滤器？](#为什么不能用哈希表而是用布隆过滤器)\n\n布隆过滤器是一种基于位数组和多个哈希函数的概率型数据结构，适合在内存资源有限、数据量大且能容忍一定误判的场景下使用。\n\n相比哈希表，布隆过滤器的内存开销非常小，能快速判断一个元素是否存在。虽然它存在误判，但不会漏报，因此在防止缓存穿透、黑名单过滤和推荐系统去重等场景中广泛使用。\n\n哈希表虽然可以精准判断元素存在与否，但需要存储实际数据，内存开销大，不适合大规模数据存储。\n\n#### [布隆过滤器的优点？](#布隆过滤器的优点)\n\n1. **内存效率高**：布隆过滤器只需要存储每个元素的哈希值，而不需要存储元素本身，因此内存占用非常小。\n2. **查询速度快**：布隆过滤器只需要将元素通过多个哈希函数映射到位数组，并检查位状态即可。它不需要哈希表那样的复杂键值操作，时间复杂度接近常数时间，速度非常快。"
+ },
+ {
+ "id": 284,
+ "question": "如何保证缓存和数据库的数据⼀致性？",
+ "answer": "在中，我们采用的是先写 MySQL，再删除 Redis 的方式来保证缓存和数据库的数据一致性。\n\n我举例说明一下。\n\n对于第一次查询，请求 B 查询到的缓存数据是 10，但 MySQL 被请求 A 更新为了 11，此时数据库和缓存不一致。\n\n但也只存在这一次不一致的情况，对于不是强一致性的业务，可以容忍。\n\n当请求 B 第二次查询时，因为请求 A 更新完数据库把缓存删除了，所以请求 B 这次不会命中缓存，会重新查一次 MySQL，然后回写到 Redis。\n\n缓存和数据库又一致了。\n\n#### [那再来说说为什么要删除缓存而不是更新缓存](#那再来说说为什么要删除缓存而不是更新缓存)\n\n因为相对而言，删除缓存的速度比更新缓存的速度要快得多。举个例子：假设商品 product\\_123 的当前库存是 10，现在有一次购买操作，库存减 1，我们需要更新 Redis 中的库存信息。\n\n\n```java\nproduct_id = \"product_123\"\n# 假设这是购买操作后的新库存值\nnew_stock = 9\n\n# 更新Redis中的库存信息\nredis.set(product_id, new_stock)\n```\n\n\n更新操作至少涉及到两个步骤：计算新的库存值和更新 Redis 中的库存值。\n\n假如是直接删除操作，直接就一步到位了：\n\n\n```java\nproduct_id = \"product_123\"\n\n# 删除Redis中的库存缓存\nredis.del(product_id)\n```\n\n\n假如是更新缓存，那么可能请求 A 更新完 MySQL 后在更新 Redis 中，请求 B 已经读取到 Redis 中的旧值返回了，又一次导致了缓存和数据库不一致。\n\n#### [那再说说为什么要先更新数据库，再删除缓存](#那再说说为什么要先更新数据库-再删除缓存)\n\n因为更新数据库的速度比删除缓存的速度要慢得多。因为更新 MySQL 是磁盘 IO 操作，而 Redis 是内存操作。内存操作比磁盘 IO 快得多（这是硬件层面的天然差距）。\n\n那假如是先删除缓存，再更新数据库，就会造成这样的情况：\n\n缓存中不存在，数据库又没有完成更新，此时有请求进来读取数据，并写入到缓存，那么在更新完缓存后，缓存中这个 key 就成了一个脏数据。\n\n\n\n目前最流行的缓存读写策略 Cache Aside Pattern（[旁路缓存模式](https://coolshell.cn/articles/17416.html)）就是采用的先写数据库，再删缓存的方式。\n\n* 失效：应用程序先从缓存读取数据，如果数据不存在，再从数据库中读取数据，成功后，放入缓存。\n* 命中：应用程序从缓存读取数据，如果数据存在，直接返回。\n* 更新：先把数据写入数据库，成功后，再让缓存失效。\n\n\n\n#### [那假如对一致性要求很高，该怎么办呢？](#那假如对一致性要求很高-该怎么办呢)\n\n缓存和数据库数据不一致的原因，常见的有两种：\n\n* 缓存删除失败\n* 并发导致写入了脏数据\n\n那通常有四种方案可以解决。\n\n\n\n**①、引入消息队列保证缓存被删除**\n\n使用消息队列（如 Kafka、RabbitMQ）保证数据库更新和缓存更新之间的最终一致性。当数据库更新完成后，将更新事件发送到消息队列。有专门的服务监听这些事件并负责更新或删除缓存。\n\n\n\n这种方案很不错，缺点是对业务代码有一定的侵入，毕竟引入了消息队列嘛。\n\n**②、数据库订阅+消息队列保证缓存被删除**\n\n可以专门起一个服务（比如 [Canal](https://github.com/alibaba/canal)，阿里巴巴 MySQL binlog 增量订阅&消费组件）去监听 MySQL 的 binlog，获取需要操作的数据。\n\n然后用一个公共的服务获取订阅程序传来的信息，进行缓存删除。\n\n\n\n这种方式虽然降低了对业务的侵入，但增加了整个系统的复杂度，适合基建完善的大厂。\n\n**③、延时双删防止脏数据**\n\n简单说，就是在第一次删除缓存之后，过一段时间之后，再次删除缓存。\n\n主要针对缓存不存在，但写入了脏数据的情况。在先删缓存，再写数据库的更新策略下发生的比较多。\n\n\n\n这种方式的延时时间需要仔细考量和测试。\n\n**④：设置缓存过期时间兜底**\n\n这是一个朴素但有用的兜底策略，给缓存设置一个合理的过期时间，即使发生了缓存和数据库的数据不一致问题，也不会永远不一致下去，缓存过期后，自然就一致了。"
+ },
+ {
+ "id": 285,
+ "question": "如何保证本地缓存和分布式缓存的一致？",
+ "answer": "在中，为了减轻 Redis 的负载，我又追加了一层本地缓存 Caffeine。\n\n\n\n为了保证本地缓存和 Redis 缓存的一致性，通常采用的策略有：\n\n①、设置本地缓存的过期时间，这是最简单也是最直接的方法，当本地缓存过期时，就从 Redis 缓存中去同步。\n\n②、使用 Redis 的 Pub/Sub 机制，当 Redis 缓存发生变化时，发布一个消息，本地缓存订阅这个消息，然后删除对应的本地缓存。\n\n③、Redis 缓存发生变化时，引入消息队列，比如 RocketMQ、RabbitMQ 去更新本地缓存。\n\n\n\n由于技术派本身对缓存的一致性要求不是特别高，所以我就采用第一种方式。\n\n另外，在技术派实战项目中，我对缓存的使用场景做了细化。比如说，使用 CacheBuilder 来完成 Guava Cache 的构建，像一些简单的缓存场景，比如说获取菜单分类、获取登录验证码、获取用户转存图片等，都使用了 Guava Cache。\n\n像首页侧边栏、专栏侧边栏、文章详情侧边栏等缓存场景，就使用了 Caffeine 作为本地缓存，通过 @Cacheable、@CacheEvit、@CachePut 等注解实现，非常轻巧。\n\n而像用户 Session 和网站地图 SiteMap 等缓存场景，就使用了 Redis 来作为缓存。\n\n#### [如果在项目中多个地方都要使用到二级缓存的逻辑，如何设计这一块？](#如果在项目中多个地方都要使用到二级缓存的逻辑-如何设计这一块)\n\n在设计时，应该清楚地区分何时使用一级缓存和何时使用二级缓存。通常情况下，对于频繁访问但不经常更改的数据，可以放在本地缓存中以提供最快的访问速度。而对于需要共享或者一致性要求较高的数据，应当放在一级缓存中。\n\n#### [本地缓存和 Redis 缓存的区别和效率对比？](#本地缓存和-redis-缓存的区别和效率对比)\n\nRedis 可以部署在多个节点上，支持数据分片，适用于跨服务器的缓存共享。而本地缓存只能在单个服务器上使用。\n\nRedis 还可以持久化数据，支持数据备份和恢复，适用于对数据安全性要求较高的场景。并且支持发布/订阅、事务、Lua 脚本等高级功能。\n\n效率上，Redis 和本地缓存都是存储在内存中，读写速度都非常快。"
+ },
+ {
+ "id": 286,
+ "question": "怎么处理热 key？",
+ "answer": "* [阿里：发现并处理 Redis 的大 Key 和热 Key](https://help.aliyun.com/zh/redis/user-guide/identify-and-handle-large-keys-and-hotkeys)\n* [董宗磊：Redis 热 Key 发现以及解决办法](https://dongzl.github.io/2021/01/14/03-Redis-Hot-Key/index.html)\n\n所谓的热 key，就是指在很短时间内被频繁访问的键。\n\n比如，热门新闻或热门商品，这类 key 通常会有大流量的访问，对存储这类信息的 Redis 来说，是不小的压力。\n\n> 某天某流量明星突然爆出一个大瓜，微博突然就崩了，这就是热 key 的压力。\n\n再比如说 Redis 是集群部署，热 key 可能会造成整体流量的不均衡（网络带宽、CPU 和内存资源），个别节点出现 OPS 过大的情况，极端情况下热点 key 甚至会超过 Redis 本身能够承受的 OPS。\n\n> OPS（Operations Per Second）是 Redis 的一个重要指标，表示 Redis 每秒钟能够处理的命令数。\n\n通常以 Key 被请求的频率来判定，比如：\n\n* **QPS 集中在特定的 Key**：总的 QPS（每秒查询率）为 10000，其中一个 Key 的 QPS 飙到了 8000。\n* **带宽使用率集中在特定的 Key**：一个拥有上千成员且总大小为 1M 的哈希 Key，每秒发送大量的 HGETALL 请求。\n* **CPU 使用率集中在特定的 Key**：一个拥有数万个成员的 ZSET Key，每秒发送大量的 ZRANGE 请求。\n\n> * HGETALL 命令用于返回哈希表中，所有的字段和值。\n> * ZRANGE 命令用于返回有序集中，指定区间内的成员。\n\n#### [怎么处理热 key？](#怎么处理热-key)\n\n\n\n对热 key 的处理，最关键的是对热 key 的监控:\n\n①、客户端\n\n客户端其实是距离 key“最近”的地方，因为 Redis 命令就是从客户端发出的，例如在客户端设置全局字典（key 和调用次数），每次调用 Redis 命令时，使用这个字典进行记录。\n\n②、代理端\n\n像 Twemproxy、Codis 这些基于代理的 Redis 分布式架构，所有客户端的请求都是通过代理端完成的，可以在代理端进行监控。\n\n③、Redis 服务端\n\n使用 monitor 命令统计热点 key 是很多开发和运维人员首先想到的方案，monitor 命令可以监控到 Redis 执行的所有命令。\n\n> monitor 命令的使用：`redis-cli monitor`\n\n\n\n还可以通过 bigkeys 参数来分析热 Key。\n\n> bigkeys 命令的使用：`redis-cli --bigkeys`\n\n\n\n只要监控到了热 key，对热 key 的处理就简单了：\n\n①、把热 key 打散到不同的服务器，降低压⼒。\n\n基本思路就是给热 Key 加上前缀或者后缀，见下例：\n\n\n```java\n// N 为 Redis 实例个数，M 为 N 的 2倍\nconst M = N * 2\n//生成随机数\nrandom = GenRandom(0, M)\n//构造备份新 Key\nbakHotKey = hotKey + \"_\" + random\ndata = redis.GET(bakHotKey)\nif data == NULL {\n data = redis.GET(hotKey)\n if data == NULL {\n data = GetFromDB()\n // 可以利用原子锁来写入数据保证数据一致性\n redis.SET(hotKey, data, expireTime)\n redis.SET(bakHotKey, data, expireTime + GenRandom(0, 5))\n } else {\n redis.SET(bakHotKey, data, expireTime + GenRandom(0, 5))\n }\n}\n```\n\n\n②、加⼊⼆级缓存，当出现热 Key 后，把热 Key 加载到 JVM 中，后续针对这些热 Key 的请求，直接从 JVM 中读取。\n\n这些本地的缓存工具有很多，比如 Caffeine、Guava 等，或者直接使用 HashMap 作为本地缓存都是可以的。\n\n注意，如果对热 Key 进行本地缓存，需要防止本地缓存过大。"
+ },
+ {
+ "id": 287,
+ "question": "缓存预热怎么做呢？",
+ "answer": "缓存预热是指在系统启动时，提前将一些预定义的数据加载到缓存中，以避免在系统运行初期由于缓存未命中（cache miss）导致的性能问题。\n\n通过缓存预热，可以确保系统在上线后能够立即提供高效的服务，减少首次访问时的延迟。\n\n缓存预热的方法有多种，在中，我们采用了项目启动时自动加载和定时预热两种方式，比如说每天定时更新站点地图到 Redis 缓存中。\n\n\n```java\n/**\n * 采用定时器方案，每天5:15分刷新站点地图，确保数据的一致性\n */\n@Scheduled(cron = \"0 15 5 * * ?\")\npublic void autoRefreshCache() {\n log.info(\"开始刷新sitemap.xml的url地址，避免出现数据不一致问题!\");\n refreshSitemap();\n log.info(\"刷新完成！\");\n}\n\n@Override\npublic void refreshSitemap() {\n initSiteMap();\n}\n\nprivate synchronized void initSiteMap() {\n long lastId = 0L;\n RedisClient.del(SITE_MAP_CACHE_KEY);\n while (true) {\n List list = articleDao.getBaseMapper().listArticlesOrderById(lastId, SCAN_SIZE);\n\n // 刷新站点地图信息\n Map map = list.stream().collect(Collectors.toMap(s -> String.valueOf(s.getId()), s -> s.getCreateTime().getTime(), (a, b) -> a));\n RedisClient.hMSet(SITE_MAP_CACHE_KEY, map);\n if (list.size() < SCAN_SIZE) {\n break;\n }\n lastId = list.get(list.size() - 1).getId();\n }\n}\n```"
+ },
+ {
+ "id": 288,
+ "question": "热点 key 重建？问题？解决？",
+ "answer": "开发的时候一般使用“缓存+过期时间”的策略，既可以加速数据读写，又保证数据的定期更新，这种模式基本能够满足绝大部分需求。\n\n但是有两个问题如果同时出现，可能就会出现比较大的问题：\n\n* 当前 key 是一个热点 key（例如一个热门的娱乐新闻），并发量非常大。\n* 重建缓存不能在短时间完成，可能是一个复杂计算，例如复杂的 SQL、多次 IO、多个依赖等。 在缓存失效的瞬间，有大量线程来重建缓存，造成后端负载加大，甚至可能会让应用崩溃。\n\n#### [怎么处理热key呢？](#怎么处理热key呢)\n\n要解决这个问题也不是很复杂，解决问题的要点在于：\n\n* 减少重建缓存的次数。\n* 数据尽可能一致。\n* 较少的潜在危险。\n\n所以一般采用如下方式：\n\n1. 互斥锁（mutex key） 这种方法只允许一个线程重建缓存，其他线程等待重建缓存的线程执行完，重新从缓存获取数据即可。\n2. 永远不过期 “永远不过期”包含两层意思：\n\n* 从缓存层面来看，确实没有设置过期时间，所以不会出现热点 key 过期后产生的问题，也就是“物理”不过期。\n* 从功能层面来看，为每个 value 设置一个逻辑过期时间，当发现超过逻辑过期时间后，会使用单独的线程去构建缓存。"
+ },
+ {
+ "id": 289,
+ "question": "无底洞问题吗？如何解决？",
+ "answer": "2010 年，Facebook 的 Memcache 节点已经达到了 3000 个，承载着 TB 级别的缓存数据。但开发和运维人员发现了一个问题，为了满足业务要求添加了大量新 Memcache 节点，但是发现性能不但没有好转反而下降了，当时将这 种现象称为缓存的“**无底洞**”现象。\n\n那么为什么会产生这种现象呢?\n\n通常来说添加节点使得 Memcache 集群 性能应该更强了，但事实并非如此。键值数据库由于通常采用哈希函数将 key 映射到各个节点上，造成 key 的分布与业务无关，但是由于数据量和访问量的持续增长，造成需要添加大量节点做水平扩容，导致键值分布到更多的 节点上，所以无论是 Memcache 还是 Redis 的分布式，批量操作通常需要从不同节点上获取，相比于单机批量操作只涉及一次网络操作，分布式批量操作会涉及多次网络时间。\n\n#### [无底洞问题如何优化呢？](#无底洞问题如何优化呢)\n\n先分析一下无底洞问题：\n\n* 客户端一次批量操作会涉及多次网络操作，也就意味着批量操作会随着节点的增多，耗时会不断增大。\n* 网络连接数变多，对节点的性能也有一定影响。\n\n常见的优化思路如下：\n\n* 命令本身的优化，例如优化操作语句等。\n* 减少网络通信次数。\n* 降低接入成本，例如客户端使用长连/连接池、NIO 等。"
+ }
+ ]
+ },
+ {
+ "id": 43,
+ "categoryName": "Redis 运维",
+ "questions": [
+ {
+ "id": 290,
+ "question": "Redis 报内存不足怎么处理？",
+ "answer": "Redis 内存不足有这么几种处理方式：\n\n* 修改配置文件 redis.conf 的 maxmemory 参数，增加 Redis 可用内存\n* 也可以通过命令 set maxmemory 动态设置内存上限\n* 修改内存淘汰策略，及时释放内存空间\n* 使用 Redis 集群模式，进行横向扩容。"
+ },
+ {
+ "id": 291,
+ "question": "Redis key 过期策略有哪些？",
+ "answer": "Redis 的 key 过期回收策略主要有两种：惰性删除和定期删除。\n\n\n\n当某个键被访问时，如果发现它已经过期，Redis 会立即删除该键，俗称惰性删除。但这也意味着如果一个已过期的键从未被访问，它就不会被删除，会占用额外的内存空间。\n\n那还有一种定期删除策略，即每隔一段时间，Redis 就会随机检查一些键是否过期，如果过期就删除。这种策略可以保证过期键及时被删除，但也会增加 Redis 的 CPU 消耗。\n\n可以通过 `config get hz` 命令查看 Redis 内部定时任务的频率。\n\n\n\n结果显示 hz 的值为 \"10\"，意味着 Redis 服务器每秒执行定时任务的频率是 10 次。可以通过 `CONFIG SET hz 20` 进行调整。\n\n"
+ },
+ {
+ "id": 292,
+ "question": "Redis 有哪些内存淘汰策略？",
+ "answer": "当 Redis 的内存使用达到最大值时，它会根据配置的内存淘汰策略来决定如何处理新的请求。\n\n> 最大值通过 maxmemory 参数设置\n\n\n\n常见的策略有：\n\n1. noeviction：默认策略，不进行任何数据淘汰，直接返回错误信息。\n2. allkeys-lru：从所有键中，使用 LRU 算法淘汰最近最少使用的键。\n3. allkeys-lfu：从所有键中，使用 LFU 算法淘汰最少使用的键。\n4. volatile-lru：从设置了过期时间的键中淘汰最近最少使用的键。\n5. volatile-ttl：从设置了过期时间的键中淘汰即将过期的键。\n\n> TTL，Time To Live，存活时间\n\n#### [LRU 和 LFU 的区别是什么？](#lru-和-lfu-的区别是什么)\n\nLRU（Least Recently Used）：基于时间维度，淘汰最近最少访问的键。适合访问具有时间特性的场景。\n\nLFU（Least Frequently Used）：基于次数维度，淘汰访问频率最低的键。更适合长期热点数据场景。"
+ },
+ {
+ "id": 293,
+ "question": "Redis 阻塞？怎么解决？",
+ "answer": "Redis 发生阻塞，可以从以下几个方面排查： \n\n* **API 或数据结构使用不合理**\n\n 通常 Redis 执行命令速度非常快，但是不合理地使用命令，可能会导致执行速度很慢，导致阻塞，对于高并发的场景，应该尽量避免在大对象上执行算法复杂 度超过 O（n）的命令。\n\n 对慢查询的处理分为两步：\n\n 1. 发现慢查询： slowlog get{n}命令可以获取最近 的 n 条慢查询命令；\n 2. 发现慢查询后，可以从两个方向去优化慢查询： 1）修改为低算法复杂度的命令，如 hgetall 改为 hmget 等，禁用 keys、sort 等命 令 2）调整大对象：缩减大对象数据或把大对象拆分为多个小对象，防止一次命令操作过多的数据。\n* **CPU 饱和的问题**\n\n 单线程的 Redis 处理命令时只能使用一个 CPU。而 CPU 饱和是指 Redis 单核 CPU 使用率跑到接近 100%。\n\n 针对这种情况，处理步骤一般如下：\n\n 1. 判断当前 Redis 并发量是否已经达到极限，可以使用统计命令 redis-cli-h{ip}-p{port}--stat 获取当前 Redis 使用情况\n 2. 如果 Redis 的请求几万+，那么大概就是 Redis 的 OPS 已经到了极限，应该做集群化水品扩展来分摊 OPS 压力\n 3. 如果只有几百几千，那么就得排查命令和内存的使用\n* **持久化相关的阻塞**\n\n 对于开启了持久化功能的 Redis 节点，需要排查是否是持久化导致的阻塞。\n\n 1. fork 阻塞 fork 操作发生在 RDB 和 AOF 重写时，Redis 主线程调用 fork 操作产生共享 内存的子进程，由子进程完成持久化文件重写工作。如果 fork 操作本身耗时过长，必然会导致主线程的阻塞。\n 2. AOF 刷盘阻塞 当我们开启 AOF 持久化功能时，文件刷盘的方式一般采用每秒一次，后台线程每秒对 AOF 文件做 fsync 操作。当硬盘压力过大时，fsync 操作需要等 待，直到写入完成。如果主线程发现距离上一次的 fsync 成功超过 2 秒，为了 数据安全性它会阻塞直到后台线程执行 fsync 操作完成。\n 3. HugePage 写操作阻塞 对于开启 Transparent HugePages 的 操作系统，每次写命令引起的复制内存页单位由 4K 变为 2MB，放大了 512 倍，会拖慢写操作的执行时间，导致大量写操作慢查询。"
+ },
+ {
+ "id": 294,
+ "question": "大 key 问题了解吗？",
+ "answer": "大 key 指的是存储了大量数据的键，比如：\n\n* 单个简单的 key 存储的 value 很大，size 超过 10KB\n* hash，set，zset，list 中存储过多的元素（以万为单位）\n\n**大 key 会造成什么问题呢？**\n\n* 客户端耗时增加，甚至超时\n* 对大 key 进行 IO 操作时，会严重占用带宽和 CPU\n* 造成 Redis 集群中数据倾斜\n* 主动删除、被动删等，可能会导致阻塞\n\n**如何找到大 key?**\n\n①、bigkeys 参数：使用 bigkeys 命令以遍历的方式分析 Redis 实例中的所有 Key，并返回整体统计信息与每个数据类型中 Top1 的大 Key\n\n> bigkeys 命令的使用：`redis-cli --bigkeys`\n\n\n\n②、redis-rdb-tools：redis-rdb-tools 是由 Python 语言编写的用来分析 Redis 中 rdb 快照文件的工具。\n\n源码地址：\n select * from user\n where user_name = #{0} and dept_id = #{1}\n \n```\n\n\n* `\\#{}`里面的数字代表传入参数的顺序。\n* 这种方法不建议使用，sql 层表达不直观，且一旦顺序调整容易出错。\n\n**方法 2：@Param 注解传参法**\n\n\n```java\npublic User selectUser(@Param(\"userName\") String name, int @Param(\"deptId\") deptId);\n\n\n select * from user\n where user_name = #{userName} and dept_id = #{deptId}\n \n```\n\n\n* `\\#{}`里面的名称对应的是注解@Param 括号里面修饰的名称。\n* 这种方法在参数不多的情况还是比较直观的，（推荐使用）。\n\n**方法 3：Map 传参法**\n\n\n```java\npublic User selectUser(Map params);\n\n\n select * from user\n where user_name = #{userName} and dept_id = #{deptId}\n \n```\n\n\n* `\\#{}`里面的名称对应的是 Map 里面的 key 名称。\n* 这种方法适合传递多个参数，且参数易变能灵活传递的情况。\n\n**方法 4：Java Bean 传参法**\n\n\n```java\npublic User selectUser(User user);\n\n\n select * from user\n where user_name = #{userName} and dept_id = #{deptId}\n \n```\n\n\n* `\\#{}`里面的名称对应的是 User 类里面的成员属性。\n* 这种方法直观，需要建一个实体类，扩展不容易，需要加属性，但代码可读性强，业务逻辑处理方便，推荐使用。（推荐使用）。"
+ },
+ {
+ "id": 315,
+ "question": "实体类属性名和表中字段名不一样 ，怎么办?",
+ "answer": "* 第 1 种： 通过在查询的 SQL 语句中定义字段名的别名，让字段名的别名和实体类的属性名一致。\n\n\n```java\n\n select order_id id, order_no orderno ,order_price price form orders where order_id=#{id};\n \n```\n\n\n* 第 2 种： 通过 resultMap 中的来映射字段名和实体类属性名的一一对应的关系。\n\n\n```java\n\n select * from orders where order_id=#{id}\n \n\n\n \n \n \n \n \n```"
+ },
+ {
+ "id": 316,
+ "question": "Mybatis 是否可以映射 Enum 枚举类？",
+ "answer": "* Mybatis 当然可以映射枚举类，不单可以映射枚举类，Mybatis 可以映射任何对象到表的一列上。映射方式为自定义一个 TypeHandler，实现 TypeHandler 的 setParameter()和 getResult()接口方法。\n* TypeHandler 有两个作用，一是完成从 javaType 至 jdbcType 的转换，二是完成 jdbcType 至 javaType 的转换，体现为 setParameter()和 getResult()两个方法，分别代表设置 sql 问号占位符参数和获取列查询结果。"
+ },
+ {
+ "id": 317,
+ "question": "#{}和${}的区别?",
+ "answer": "`#{}` 是预编译处理，`${}` 是字符串替换。\n\n①、当使用 `#{}` 时，MyBatis 会在 SQL 执行之前，将占位符替换为问号 `?`，并使用参数值来替代这些问号。\n\n由于 `#{}` 使用了预处理，所以能有效防止 SQL 注入，确保参数值在到达数据库之前被正确地处理和转义。\n\n\n```xml\n\n SELECT * FROM users WHERE id = #{id}\n \n```\n\n\n②、当使用 `${}` 时，参数的值会直接替换到 SQL 语句中去，而不会经过预处理。\n\n这就存在 SQL 注入的风险，因为参数值会直接拼接到 SQL 语句中，假如参数值是 `1 or 1=1`，那么 SQL 语句就会变成 `SELECT * FROM users WHERE id = 1 or 1=1`，这样就会导致查询出所有用户的结果。\n\n`${}` 通常用于那些不能使用预处理的场合，比如说动态表名、列名、排序等，要提前对参数进行安全性校验。\n\n\n```xml\n\n SELECT * FROM users ORDER BY ${columnName} ASC\n \n```"
+ },
+ {
+ "id": 318,
+ "question": "模糊查询 like 语句该怎么写?",
+ "answer": "\n\n* 1 ’`%${question}%`’ 可能引起 SQL 注入，不推荐\n* 2 `\"%\"#{question}\"%\"` 注意：因为`#{…}`解析成 sql 语句时候，会在变量外侧自动加单引号’ '，所以这里 % 需要使用双引号\" \"，不能使用单引号 ’ '，不然会查不到任何结果。\n* 3 `CONCAT('%',#{question},'%')` 使用 CONCAT()函数，（推荐 ✨）\n* 4 使用 bind 标签（不推荐）\n\n\n```java\n\n \n```"
+ },
+ {
+ "id": 319,
+ "question": "Mybatis 能执行一对一、一对多的关联查询吗？",
+ "answer": "当然可以，不止支持一对一、一对多的关联查询，还支持多对多、多对一的关联查询。\n\n\n\n* **一对一**\n\n比如订单和支付是一对一的关系，这种关联的实现：\n\n实体类:\n\n\n```java\npublic class Order {\n private Integer orderId;\n private String orderDesc;\n\n /**\n * 支付对象\n */\n private Pay pay;\n //……\n}\n```\n\n\n结果映射\n\n\n```java\n\n\n \n \n \n \n \n \n \n```\n\n\n查询就是普通的关联查\n\n\n```java\n\n select * from order o\n left join pay p on o.order_id=p.order_id\n where o.order_id=#{orderId}\n \n```\n\n\n* **一对多``**\n\n比如商品分类和商品，是一对多的关系。\n\n* 实体类\n\n\n```java\npublic class Category {\n private int categoryId;\n private String categoryName;\n\n /**\n * 商品列表\n **/\n List products;\n //……\n}\n```\n\n\n* 结果映射\n\n\n```java\n\n \n \n \n```\n\n\n* 查询\n\n查询就是一个普通的关联查询\n\n\n```java\n\n\n select c.*, p.* from category_ c left join product_ p on c.id = p.cid\n \n```\n\n\n 那么多对一、多对多怎么实现呢？还是利用和，篇幅所限，这里就不展开了。"
+ },
+ {
+ "id": 320,
+ "question": "Mybatis 是否支持延迟加载？原理？",
+ "answer": "* Mybatis 支持 association 关联对象和 collection 关联集合对象的延迟加载，association 指的就是一对一，collection 指的就是一对多查询。在 Mybatis 配置文件中，可以配置是否启用延迟加载 lazyLoadingEnabled=true|false。\n* 它的原理是，使用 CGLIB 创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用 a.getB().getName()，拦截器 invoke()方法发现 a.getB()是 null 值，那么就会单独发送事先保存好的查询关联 B 对象的 sql，把 B 查询上来，然后调用 a.setB(b)，于是 a 的对象 b 属性就有值了，接着完成 a.getB().getName()方法的调用。这就是延迟加载的基本原理。\n* 当然了，不光是 Mybatis，几乎所有的包括 Hibernate，支持延迟加载的原理都是一样的。"
+ },
+ {
+ "id": 321,
+ "question": "如何获取生成的主键?",
+ "answer": "* 新增标签中添加：keyProperty=\" ID \" 即可\n\n\n```java\n\n insert into user(\n user_name, user_password, create_time)\n values(#{userName}, #{userPassword} , #{createTime, jdbcType= TIMESTAMP})\n \n```\n\n\n* 这时候就可以完成回填主键\n\n\n```java\nmapper.insert(user);\nuser.getId;\n```"
+ },
+ {
+ "id": 322,
+ "question": "MyBatis 支持动态 SQL 吗？",
+ "answer": "MyBatis 中有一些支持动态 SQL 的标签，它们的原理是使用 OGNL 从 SQL 参数对象中计算表达式的值，根据表达式的值动态拼接 SQL，以此来完成动态 SQL 的功能。\n\n\n\n* if\n\n根据条件来组成 where 子句\n\n\n```java\n\nSELECT * FROM BLOG\nWHERE state = ‘ACTIVE’\n\n AND title like #{title}\n \n \n```\n\n\n* choose (when, otherwise)\n\n这个和 Java 中的 switch 语句有点像\n\n\n```java\n\nSELECT * FROM BLOG WHERE state = ‘ACTIVE’\n\n \n AND title like #{title}\n \n \n AND author_name like #{author.name}\n \n \n AND featured = 1\n \n \n \n```\n\n\n* trim (where, set)\n* 可以用在所有的查询条件都是动态的情况\n\n\n```java\n\nSELECT * FROM BLOG\n\n \n state = #{state}\n \n \n AND title like #{title}\n \n \n AND author_name like #{author.name}\n \n \n \n```\n\n\n* 可以用在动态更新的时候\n\n\n```java\n\n update Author\n \n username=#{username}, \n password=#{password}, \n email=#{email}, \n bio=#{bio} \n \n where id=#{id}\n \n```\n\n\n* foreach\n\n 看到名字就知道了，这个是用来循环的，可以对集合进行遍历\n\n\n```java\n\nSELECT *\nFROM POST P\n\n \n #{item}\n \n \n \n```"
+ },
+ {
+ "id": 323,
+ "question": "MyBatis 如何执行批量操作？",
+ "answer": "\n\n**第一种方法：使用 foreach 标签**\n\nforeach 的主要用在构建 in 条件中，它可以在 SQL 语句中进行迭代一个集合。foreach 标签的属性主要有 item，index，collection，open，separator，close。\n\n* item 表示集合中每一个元素进行迭代时的别名，随便起的变量名；\n* index 指定一个名字，用于表示在迭代过程中，每次迭代到的位置，不常用；\n* open 表示该语句以什么开始，常用“(”；\n* separator 表示在每次进行迭代之间以什么符号作为分隔符，常用“,”；\n* close 表示以什么结束，常用“)”。\n\n在使用 foreach 的时候最关键的也是最容易出错的就是 collection 属性，该属性是必须指定的，但是在不同情况下，该属性的值是不一样的，主要有以下 3 种情况：\n\n1. 如果传入的是单参数且参数类型是一个 List 的时候，collection 属性值为 list\n2. 如果传入的是单参数且参数类型是一个 array 数组的时候，collection 的属性值为 array\n3. 如果传入的参数是多个的时候，我们就需要把它们封装成一个 Map 了，当然单参数也可以封装成 map，实际上如果你在传入参数的时候，在 MyBatis 里面也是会把它封装成一个 Map 的，map 的 key 就是参数名，所以这个时候 collection 属性值就是传入的 List 或 array 对象在自己封装的 map 里面的 key\n\n看看批量保存的两种用法：\n\n\n```java\n //推荐使用\n\n INSERT INTO emp(ename,gender,email,did)\n VALUES\n \n (#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})\n \n \n```\n\n```java\n\n\n \n INSERT INTO emp(ename,gender,email,did)\n VALUES(#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})\n \n \n```\n\n\n**第二种方法：使用 ExecutorType.BATCH**\n\n* Mybatis 内置的 ExecutorType 有 3 种，默认为 simple，该模式下它为每个语句的执行创建一个新的预处理语句，单条提交 sql；而 batch 模式重复使用已经预处理的语句，并且批量执行所有更新语句，显然 batch 性能将更优； 但 batch 模式也有自己的问题，比如在 Insert 操作时，在事务没有提交之前，是没有办法获取到自增的 id，在某些情况下不符合业务的需求。\n\n具体用法如下：\n\n\n```java\n//批量保存方法测试\n@Test\npublic void testBatch() throws IOException{\n SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();\n //可以执行批量操作的sqlSession\n SqlSession openSession = sqlSessionFactory.openSession(ExecutorType.BATCH);\n\n //批量保存执行前时间\n long start = System.currentTimeMillis();\n try {\n EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);\n for (int i = 0; i < 1000; i++) {\n mapper.addEmp(new Employee(UUID.randomUUID().toString().substring(0, 5), \"b\", \"1\"));\n }\n\n openSession.commit();\n long end = System.currentTimeMillis();\n //批量保存执行后的时间\n System.out.println(\"执行时长\" + (end - start));\n //批量 预编译sql一次==》设置参数==》10000次==》执行1次 677\n //非批量 （预编译=设置参数=执行 ）==》10000次 1121\n\n } finally {\n openSession.close();\n }\n}\n```\n\n\n* mapper 和 mapper.xml 如下\n\n\n```java\npublic interface EmployeeMapper {\n //批量保存员工\n Long addEmp(Employee employee);\n}\n```\n\n```java\n\n \n insert into employee(lastName,email,gender)\n values(#{lastName},#{email},#{gender})\n \n \n```"
+ },
+ {
+ "id": 324,
+ "question": "说说 Mybatis 的一级、二级缓存？",
+ "answer": "1. 一级缓存: 基于 PerpetualCache 的 HashMap 本地缓存，其存储作用域为 SqlSession，各个 SqlSession 之间的缓存相互隔离，当 Session flush 或 close 之后，该 SqlSession 中的所有 Cache 就将清空，MyBatis 默认打开一级缓存。\n\n\n\n2. 二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap 存储，不同之处在于其存储作用域为 Mapper(Namespace)，可以在多个 SqlSession 之间共享，并且可自定义存储源，如 Ehcache。默认不打开二级缓存，要开启二级缓存，使用二级缓存属性类需要实现 Serializable 序列化接口(可用来保存对象的状态),可在它的映射文件中配置。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 48,
+ "categoryName": "原理",
+ "questions": [
+ {
+ "id": 325,
+ "question": "能说说 MyBatis 的工作原理吗？",
+ "answer": "我们已经大概知道了 MyBatis 的工作流程，按工作原理，可以分为两大步：`生成会话工厂`、`会话运行`。\n\n\n\nMyBatis 是一个成熟的框架，篇幅限制，这里抓大放小，来看看它的主要工作流程。\n\n> **构建会话工厂**\n\n构造会话工厂也可以分为两步：\n\n\n\n* 获取配置\n\n获取配置这一步经过了几步转化，最终由生成了一个配置类 Configuration 实例，这个配置类实例非常重要，主要作用包括：\n\n* 读取配置文件，包括基础配置文件和映射文件\n* 初始化基础配置，比如 MyBatis 的别名，还有其它的一些重要的类对象，像插件、映射器、ObjectFactory 等等\n* 提供一个单例，作为会话工厂构建的重要参数\n* 它的构建过程也会初始化一些环境变量，比如数据源\n\n\n```java\npublic SqlSessionFactory build(Reader reader, String environment, Properties properties) {\n SqlSessionFactory var5;\n //省略异常处理\n //xml配置构建器\n XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);\n //通过转化的Configuration构建SqlSessionFactory\n var5 = this.build(parser.parse());\n}\n```\n\n\n* 构建 SqlSessionFactory\n\nSqlSessionFactory 只是一个接口，构建出来的实际上是它的实现类的实例，一般我们用的都是它的实现类 DefaultSqlSessionFactory，\n\n\n```java\npublic SqlSessionFactory build(Configuration config) {\n return new DefaultSqlSessionFactory(config);\n}\n```\n\n> **会话运行**\n\n会话运行是 MyBatis 最复杂的部分，它的运行离不开四大组件的配合：\n\n\n\n* Executor（执行器）\n\nExecutor 起到了至关重要的作用，SqlSession 只是一个门面，相当于客服，真正干活的是是 Executor，就像是默默无闻的工程师。它提供了相应的查询和更新方法，以及事务方法。\n\n\n```java\nEnvironment environment = this.configuration.getEnvironment();\nTransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);\ntx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);\n//通过Configuration创建executor\nExecutor executor = this.configuration.newExecutor(tx, execType);\nvar8 = new DefaultSqlSession(this.configuration, executor, autoCommit);\n```\n\n\n* StatementHandler（数据库会话器）\n\nStatementHandler，顾名思义，处理数据库会话的。我们以 SimpleExecutor 为例，看一下它的查询方法，先生成了一个 StatementHandler 实例，再拿这个 handler 去执行 query。\n\n\n```java\n public List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {\n Statement stmt = null;\n\n List var9;\n try {\n Configuration configuration = ms.getConfiguration();\n StatementHandler handler = configuration.newStatementHandler(this.wrapper, ms, parameter, rowBounds, resultHandler, boundSql);\n stmt = this.prepareStatement(handler, ms.getStatementLog());\n var9 = handler.query(stmt, resultHandler);\n } finally {\n this.closeStatement(stmt);\n }\n\n return var9;\n}\n```\n\n\n再以最常用的 PreparedStatementHandler 看一下它的 query 方法，其实在上面的`prepareStatement`已经对参数进行了预编译处理，到了这里，就直接执行 sql，使用 ResultHandler 处理返回结果。\n\n\n```java\npublic List query(Statement statement, ResultHandler resultHandler) throws SQLException {\n PreparedStatement ps = (PreparedStatement)statement;\n ps.execute();\n return this.resultSetHandler.handleResultSets(ps);\n}\n```\n\n\n* ParameterHandler （参数处理器）\n\nPreparedStatementHandler 里对 sql 进行了预编译处理\n\n\n```java\npublic void parameterize(Statement statement) throws SQLException {\n this.parameterHandler.setParameters((PreparedStatement)statement);\n}\n```\n\n\n这里用的就是 ParameterHandler，setParameters 的作用就是设置预编译 SQL 语句的参数。\n\n里面还会用到 typeHandler 类型处理器，对类型进行处理。\n\n\n```java\npublic interface ParameterHandler {\n Object getParameterObject();\n\n void setParameters(PreparedStatement var1) throws SQLException;\n}\n```\n\n\n* ResultSetHandler（结果处理器）\n\n 我们前面也看到了，最后的结果要通过 ResultSetHandler 来进行处理，handleResultSets 这个方法就是用来包装结果集的。Mybatis 为我们提供了一个 DefaultResultSetHandler，通常都是用这个实现类去进行结果的处理的。\n\n\n```java\npublic interface ResultSetHandler {\n List handleResultSets(Statement var1) throws SQLException;\n\n Cursor handleCursorResultSets(Statement var1) throws SQLException;\n\n void handleOutputParameters(CallableStatement var1) throws SQLException;\n}\n```\n\n\n它会使用 typeHandle 处理类型，然后用 ObjectFactory 提供的规则组装对象，返回给调用者。\n\n整体上总结一下会话运行：\n\n\n> 我们最后把整个的工作流程串联起来，简单总结一下：\n\n\n\n1. 读取 MyBatis 配置文件——mybatis-config.xml 、加载映射文件——映射文件即 SQL 映射文件，文件中配置了操作数据库的 SQL 语句。最后生成一个配置对象。\n2. 构造会话工厂：通过 MyBatis 的环境等配置信息构建会话工厂 SqlSessionFactory。\n3. 创建会话对象：由会话工厂创建 SqlSession 对象，该对象中包含了执行 SQL 语句的所有方法。\n4. Executor 执行器：MyBatis 底层定义了一个 Executor 接口来操作数据库，它将根据 SqlSession 传递的参数动态地生成需要执行的 SQL 语句，同时负责查询缓存的维护。\n5. StatementHandler：数据库会话器，串联起参数映射的处理和运行结果映射的处理。\n6. 参数处理：对输入参数的类型进行处理，并预编译。\n7. 结果处理：对返回结果的类型进行处理，根据对象映射规则，返回相应的对象。"
+ },
+ {
+ "id": 326,
+ "question": "MyBatis 的功能架构是什么样的？",
+ "answer": "\n\n我们一般把 Mybatis 的功能架构分为三层：\n\n* API 接口层：提供给外部使用的接口 API，开发人员通过这些本地 API 来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。\n* 数据处理层：负责具体的 SQL 查找、SQL 解析、SQL 执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。\n* 基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。"
+ },
+ {
+ "id": 327,
+ "question": "为什么 Mapper 接口不需要实现类？",
+ "answer": "四个字回答：**动态代理**，我们来看一下获取 Mapper 的过程：\n\n\n\n* 获取 Mapper\n\n我们都知道定义的 Mapper 接口是没有实现类的，Mapper 映射其实是通过**动态代理**实现的。\n\n\n```java\nBlogMapper mapper = session.getMapper(BlogMapper.class);\n```\n\n\n七拐八绕地进去看一下，发现获取 Mapper 的过程，需要先获取 MapperProxyFactory——Mapper 代理工厂。\n\n\n```java\npublic T getMapper(Class type, SqlSession sqlSession) {\n MapperProxyFactory mapperProxyFactory = (MapperProxyFactory)this.knownMappers.get(type);\n if (mapperProxyFactory == null) {\n throw new BindingException(\"Type \" + type + \" is not known to the MapperRegistry.\");\n } else {\n try {\n return mapperProxyFactory.newInstance(sqlSession);\n } catch (Exception var5) {\n throw new BindingException(\"Error getting mapper instance. Cause: \" + var5, var5);\n }\n }\n}\n```\n\n\n* MapperProxyFactory\n\nMapperProxyFactory 的作用是生成 MapperProxy（Mapper 代理对象）。\n\n\n```java\npublic class MapperProxyFactory {\n private final Class mapperInterface;\n ……\n protected T newInstance(MapperProxy mapperProxy) {\n return Proxy.newProxyInstance(this.mapperInterface.getClassLoader(), new Class[]{this.mapperInterface}, mapperProxy);\n }\n\n public T newInstance(SqlSession sqlSession) {\n MapperProxy mapperProxy = new MapperProxy(sqlSession, this.mapperInterface, this.methodCache);\n return this.newInstance(mapperProxy);\n }\n}\n```\n\n\n这里可以看到动态代理对接口的绑定，它的作用就是生成动态代理对象（占位），而代理的方法被放到了 MapperProxy 中。\n\n* MapperProxy\n\nMapperProxy 里，通常会生成一个 MapperMethod 对象，它是通过 cachedMapperMethod 方法对其进行初始化的，然后执行 excute 方法。\n\n\n```java\npublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {\n try {\n return Object.class.equals(method.getDeclaringClass()) ? method.invoke(this, args) : this.cachedInvoker(method).invoke(proxy, method, args, this.sqlSession);\n } catch (Throwable var5) {\n throw ExceptionUtil.unwrapThrowable(var5);\n }\n}\n```\n\n\n* MapperMethod\n\nMapperMethod 里的 excute 方法，会真正去执行 sql。这里用到了命令模式，其实绕一圈，最终它还是通过 SqlSession 的实例去运行对象的 sql。\n\n\n```java\npublic Object execute(SqlSession sqlSession, Object[] args) {\n Object result;\n Object param;\n ……\n case SELECT:\n if (this.method.returnsVoid() && this.method.hasResultHandler()) {\n this.executeWithResultHandler(sqlSession, args);\n result = null;\n } else if (this.method.returnsMany()) {\n result = this.executeForMany(sqlSession, args);\n } else if (this.method.returnsMap()) {\n result = this.executeForMap(sqlSession, args);\n } else if (this.method.returnsCursor()) {\n result = this.executeForCursor(sqlSession, args);\n } else {\n param = this.method.convertArgsToSqlCommandParam(args);\n result = sqlSession.selectOne(this.command.getName(), param);\n if (this.method.returnsOptional() && (result == null || !this.method.getReturnType().equals(result.getClass()))) {\n result = Optional.ofNullable(result);\n }\n }\n break;\n ……\n }\n```"
+ },
+ {
+ "id": 328,
+ "question": "Mybatis 都有哪些 Executor 执行器？",
+ "answer": "\n\nMybatis 有三种基本的 Executor 执行器，SimpleExecutor、ReuseExecutor、BatchExecutor。\n\n* **SimpleExecutor**：每执行一次 update 或 select，就开启一个 Statement 对象，用完立刻关闭 Statement 对象。\n* **ReuseExecutor**：执行 update 或 select，以 sql 作为 key 查找 Statement 对象，存在就使用，不存在就创建，用完后，不关闭 Statement 对象，而是放置于 Map内，供下一次使用。简言之，就是重复使用 Statement 对象。\n* **BatchExecutor**：执行 update（没有 select，JDBC 批处理不支持 select），将所有 sql 都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个 Statement 对象，每个 Statement 对象都是 addBatch()完毕后，等待逐一执行 executeBatch()批处理。与 JDBC 批处理相同。\n\n作用范围：Executor 的这些特点，都严格限制在 SqlSession 生命周期范围内。\n\n> **Mybatis 中如何指定使用哪一种 Executor 执行器？**\n\n* 在 Mybatis 配置文件中，在设置（settings）可以指定默认的 ExecutorType 执行器类型，也可以手动给 DefaultSqlSessionFactory 的创建 SqlSession 的方法传递 ExecutorType 类型参数，如`SqlSession openSession(ExecutorType execType)`。\n* 配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。"
+ }
+ ]
+ },
+ {
+ "id": 49,
+ "categoryName": "插件",
+ "questions": [
+ {
+ "id": 329,
+ "question": "说说 Mybatis 的插件运行原理，如何编写一个插件？",
+ "answer": "> **插件的运行原理？**\n\nMybatis 会话的运行需要 ParameterHandler、ResultSetHandler、StatementHandler、Executor 这四大对象的配合，插件的原理就是在这四大对象调度的时候，插入一些我我们自己的代码。\n\n\n\nMybatis 使用 JDK 的动态代理，为目标对象生成代理对象。它提供了一个工具类`Plugin`，实现了`InvocationHandler`接口。\n\n\n\n使用`Plugin`生成代理对象，代理对象在调用方法的时候，就会进入 invoke 方法，在 invoke 方法中，如果存在签名的拦截方法，插件的 intercept 方法就会在这里被我们调用，然后就返回结果。如果不存在签名方法，那么将直接反射调用我们要执行的方法。\n\n> **如何编写一个插件？**\n\n我们自己编写 MyBatis 插件，只需要实现拦截器接口 `Interceptor (org.apache.ibatis. plugin Interceptor ）`，在实现类中对拦截对象和方法进行处理。\n\n* 实现 Mybatis 的 Interceptor 接口并重写 intercept()方法\n\n这里我们只是在目标对象执行目标方法的前后进行了打印；\n\n\n```java\npublic class MyInterceptor implements Interceptor {\n Properties props=null;\n\n @Override\n public Object intercept(Invocation invocation) throws Throwable {\n System.out.println(\"before……\");\n //如果当前代理的是一个非代理对象，那么就会调用真实拦截对象的方法\n // 如果不是它就会调用下个插件代理对象的invoke方法\n Object obj=invocation.proceed();\n System.out.println(\"after……\");\n return obj;\n }\n}\n```\n\n\n* 然后再给插件编写注解，确定要拦截的对象，要拦截的方法\n\n\n```java\n@Intercepts({@Signature(\n type = Executor.class, //确定要拦截的对象\n method = \"update\", //确定要拦截的方法\n args = {MappedStatement.class,Object.class} //拦截方法的参数\n)})\npublic class MyInterceptor implements Interceptor {\n Properties props=null;\n\n @Override\n public Object intercept(Invocation invocation) throws Throwable {\n System.out.println(\"before……\");\n //如果当前代理的是一个非代理对象，那么就会调用真实拦截对象的方法\n // 如果不是它就会调用下个插件代理对象的invoke方法\n Object obj=invocation.proceed();\n System.out.println(\"after……\");\n return obj;\n }\n}\n```\n\n\n* 最后，再 MyBatis 配置文件里面配置插件\n\n\n```java\n\n \n \n \n \n```"
+ },
+ {
+ "id": 330,
+ "question": "MyBatis 是如何进行分页的？分页插件的原理是什么？",
+ "answer": "> **MyBatis 是如何分页的？**\n\nMyBatis 使用 RowBounds 对象进行分页，它是针对 ResultSet 结果集执行的内存分页，而非物理分页。可以在 sql 内直接书写带有物理分页的参数来完成物理分页功能，也可以使用分页插件来完成物理分页。\n\n> **分页插件的原理是什么？**\n\n* 分页插件的基本原理是使用 Mybatis 提供的插件接口，实现自定义插件，拦截 Executor 的 query 方法\n* 在执行查询的时候，拦截待执行的 sql，然后重写 sql，根据 dialect 方言，添加对应的物理分页语句和物理分页参数。\n* 举例：`select * from student`，拦截 sql 后重写为：`select t.* from (select * from student) t limit 0, 10`\n\n可以看一下一个大概的 MyBatis 通用分页拦截器：\n\n"
+ }
+ ]
+ },
+ {
+ "id": 50,
+ "categoryName": "补充",
+ "questions": [
+ {
+ "id": 331,
+ "question": "说说 JDBC 的执行步骤？",
+ "answer": "> 2024 年 03 月 19 日增补\n\nJava 数据库连接（JDBC）是一个用于执行 SQL 语句的 Java API，它为多种关系数据库提供了统一访问的机制。使用 JDBC 操作数据库通常涉及以下步骤：\n\n第一步，加载数据库驱动\n\n在与数据库建立连接之前，首先需要通过`Class.forName()`方法加载对应的数据库驱动。这一步确保 JDBC 驱动注册到了`DriverManager`类中。\n\n\n```java\nClass.forName(\"com.mysql.cj.jdbc.Driver\");\n```\n\n\n第二步，建立数据库连接\n\n使用`DriverManager.getConnection()`方法建立到数据库的连接。这一步需要提供数据库 URL、用户名和密码作为参数。\n\n\n```java\nConnection conn = DriverManager.getConnection(\n \"jdbc:mysql://localhost:3306/databaseName\", \"username\", \"password\");\n```\n\n\n第三步，创建`Statement`对象\n\n通过建立的数据库连接对象`Connection`创建`Statement`、`PreparedStatement`或`CallableStatement`对象，用于执行 SQL 语句。\n\n\n```java\nStatement stmt = conn.createStatement();\n```\n\n\n或者创建`PreparedStatement`对象（预编译 SQL 语句，适用于带参数的 SQL）：\n\n\n```java\nPreparedStatement pstmt = conn.prepareStatement(\"SELECT * FROM tableName WHERE column = ?\");\npstmt.setString(1, \"value\");\n```\n\n\n第四步，执行 SQL 语句\n\n使用`Statement`或`PreparedStatement`对象执行 SQL 语句。\n\n执行查询（SELECT）语句时，使用`executeQuery()`方法，它返回`ResultSet`对象；\n\n执行更新（INSERT、UPDATE、DELETE）语句时，使用`executeUpdate()`方法，它返回一个整数表示受影响的行数。\n\n\n```java\nResultSet rs = stmt.executeQuery(\"SELECT * FROM tableName\");\n```\n\n\n或\n\n\n```java\nint affectedRows = stmt.executeUpdate(\"UPDATE tableName SET column = 'value' WHERE condition\");\n```\n\n\n第五步，处理结果集\n\n如果执行的是查询操作，需要处理`ResultSet`对象来获取数据。\n\n\n```java\nwhile (rs.next()) {\n String data = rs.getString(\"columnName\");\n // 处理每一行数据\n}\n```\n\n\n第六步，关闭资源\n\n最后，需要依次关闭`ResultSet`、`Statement`和`Connection`等资源，释放数据库连接等资源。\n\n\n```java\nif (rs != null) rs.close();\nif (stmt != null) stmt.close();\nif (conn != null) conn.close();\n```\n\n\n在 Java 开发中，通常会使用 JDBC 模板库（如 Spring 的 JdbcTemplate）或 ORM 框架（如 Hibernate、MyBatis、MyBatis-Plus）来简化数据库操作和资源管理。"
+ },
+ {
+ "id": 332,
+ "question": "创建连接拿到的是什么对象？",
+ "answer": "在 JDBC 的执行步骤中，创建连接后拿到的对象是`java.sql.Connection`对象。这个对象是 JDBC API 中用于表示数据库连接的接口，它提供了执行 SQL 语句、管理事务等一系列操作的方法。\n\n`Connection`对象代表了应用程序和数据库的一个连接会话。\n\n通过调用`DriverManager.getConnection()`方法并传入数据库的 URL、用户名和密码等信息来获得这个对象。\n\n一旦获得`Connection`对象，就可以使用它来创建执行 SQL 语句的`Statement`、`PreparedStatement`和`CallableStatement`对象，以及管理事务等。"
+ },
+ {
+ "id": 333,
+ "question": "Statement 与 PreparedStatement 的区别",
+ "answer": "> 2024 年 03 月 19 日增补\n\n`Statement`和`PreparedStatement`都是用于执行 SQL 语句的接口，但它们之间存在几个关键的区别：\n\n①、每次执行`Statement`对象的`executeQuery`或`executeUpdate`方法时，SQL 语句在数据库端都需要重新编译和执行。这适用于一次性执行的 SQL 语句。\n\n**Statement** 不支持参数化查询。如果需要在 SQL 语句中插入变量，通常需要通过字符串拼接的方式来实现，这会增加 SQL 注入攻击的风险。\n\n②、**PreparedStatement** 代表预编译的 SQL 语句的对象。这意味着 SQL 语句在`PreparedStatement`对象创建时就被发送到数据库进行预编译。\n\n之后，可以通过设置参数值来多次高效地执行这个 SQL 语句。这不仅减少了数据库编译 SQL 语句的开销，也提高了性能，尤其是对于重复执行的 SQL 操作。\n\n**PreparedStatement** 支持参数化查询，即可以在 SQL 语句中使用问号（`?`）作为参数占位符。通过`setXxx`方法（如`setString`、`setInt`）设置参数，可以有效防止 SQL 注入。\n\n总的来说，`PreparedStatement`相比`Statement`有着更好的性能和更高的安全性，是执行 SQL 语句的首选方式，尤其是在处理含有用户输入的动态查询时。"
+ },
+ {
+ "id": 334,
+ "question": "什么是 SQL 注入？如何防止 SQL 注入？",
+ "answer": "SQL 注入是一种代码注入技术，通过在输入字段中插入专用的 SQL 语句，从而欺骗数据库执行恶意 SQL，以获取敏感数据、修改数据，或者删除数据等。\n\n比如说有这样一段代码：\n\n\n```java\nstudentId = getRequestString(\"studentId\");\nlookupStudent = \"SELECT * FROM students WHERE studentId = \" + studentId\n```\n\n\n用户在输入框中输入 117 进行查询：\n\n\n\n实际的 SQL 语句类似于：\n\n\n```sql\nSELECT * FROM students WHERE studentId = 117\n```\n\n\n这是我们期望用户输入的正确方式。但是，如果用户输入了`117 OR 1=1`，那么 SQL 语句就变成了：\n\n\n```sql\nSELECT * FROM students WHERE studentId = 117 OR 1=1\n```\n\n\n由于`1=1`为真，所以这个查询将返回所有学生的信息，而不仅仅是 ID 为 117 的学生。\n\n\n\n为了防止 SQL 注入，可以采取以下措施：\n\n①、使用参数化查询\n\n使用参数化查询，即使用`PreparedStatement`对象，通过`setXxx`方法设置参数值，而不是通过字符串拼接 SQL 语句。这样可以有效防止 SQL 注入。\n\n\n```java\nString query = \"SELECT * FROM users WHERE username = ?\";\nPreparedStatement pstmt = connection.prepareStatement(query);\npstmt.setString(1, userName); // userName 是用户输入\nResultSet rs = pstmt.executeQuery();\n```\n\n\n`?` 是一个参数占位符，userName 是外部输入。这样即便用户输入了恶意的 SQL 语句，也只会被视为参数的一部分，不会改变查询的结构。\n\n②、限制用户输入\n\n对用户输入进行验证和过滤，只允许输入预期的数据，不允许输入特殊字符或 SQL 关键字。\n\n③、使用 ORM 框架\n\n比如，在 MyBatis 中，使用`#{}`占位符来代替直接拼接 SQL 语句，MyBatis 会自动进行参数化处理。\n\n\n```xml\n\n SELECT * FROM users WHERE username = #{userName}\n \n```\n\n\n假如 userName 传入的值是 `9;DROP TABLE SYS_USER;`，传入的删除表 SQL 也不会执行，因为它会被当作参数值。\n\n\n```sql\nSELECT * FROM users WHERE username = '9;DROP TABLE SYS_USER;'\n```\n\n\n---\n\n图文详解 23 道 MyBatis 面试高频题，这次吊打面试官，我觉得稳了（手动 dog）。整理：练习伴侣二，戳[转载链接](https://mp.weixin.qq.com/s/en2RgcVx52Ql3tYGLfv3Kw)，作者：三分恶，戳[原文链接](https://mp.weixin.qq.com/s/O_5Id2o9IP4loPazJuiHng)。\n\n*没有什么使我停留——除了目的，纵然岸旁有玫瑰、有绿荫、有宁静的港湾，我是不系之舟*。\n\n**系列内容**：\n\n\n\n---"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 8,
+ "topicName": "MySQL",
+ "categories": [
+ {
+ "id": 51,
+ "categoryName": "MySQL 基础",
+ "questions": [
+ {
+ "id": 335,
+ "question": "什么是 MySQL？",
+ "answer": "MySQL 是一个开源的关系型数据库，现在隶属于 Oracle 公司。是我们国内使用频率最高的一种数据库，我在本地安装的是最新的 8.3 版本。\n\n\n\n#### [怎么删除/创建一张表？](#怎么删除-创建一张表)\n\n可以使用 `DROP TABLE` 来删除表，使用 `CREATE TABLE` 来创建表。\n\n创建表的时候，可以通过 `PRIMARY KEY` 设定主键。\n\n\n```sql\nCREATE TABLE users (\n id INT AUTO_INCREMENT,\n name VARCHAR(100) NOT NULL,\n email VARCHAR(100),\n PRIMARY KEY (id)\n);\n```\n\n\n#### [请写一个升序/降序的 SQL 语句？](#请写一个升序-降序的-sql-语句)\n\n在 SQL 中，可以使用 `ORDER BY` 子句来对查询结果进行升序或者降序。默认情况下，查询结果是升序的，如果需要降序，可以通过 `DESC` 关键字来实现。\n\n比如说在员工表中，我们要按工资降序，就可以使用 `ORDER BY salary DESC` 来完成：\n\n\n```sql\nSELECT id, name, salary\nFROM employees\nORDER BY salary DESC;\n```\n\n\n如果需对多个字段进行排序，例如按工资降序，按名字升序，就可以 `ORDER BY salary DESC, name ASC` 来完成：\n\n\n```sql\nSELECT id, name, salary\nFROM employees\nORDER BY salary DESC, name ASC;\n```\n\n\n#### [MySQL出现性能差的原因有哪些？](#mysql出现性能差的原因有哪些)\n\n可能是 SQL 查询使用了全表扫描，也可能是查询语句过于复杂，如多表 JOIN 或嵌套子查询。\n\n也有可能是单表数据量过大。\n\n通常情况下，添加索引就能解决大部分性能问题。对于一些热点数据，还可以通过增加 Redis 缓存，来减轻数据库的访问压力。"
+ },
+ {
+ "id": 336,
+ "question": "两张表怎么进行连接？",
+ "answer": "可以通过内连接 `inner join`、外连接 `outer join`、交叉连接 `cross join` 来合并多个表的查询结果。\n\n#### [什么是内连接？](#什么是内连接)\n\n内连接用于返回两个表中有匹配关系的行。假设有两张表，用户表和订单表，想查询有订单的用户，就可以使用内连接 `users INNER JOIN orders`，按照用户 ID 关联就行了。\n\n\n```sql\nSELECT users.name, orders.order_id\nFROM users\nINNER JOIN orders ON users.id = orders.user_id;\n```\n\n\n只有那些在两个表中都存在 user\\_id 的记录才会出现在查询结果中。\n\n#### [什么是外连接？](#什么是外连接)\n\n和内连接不同，外连接不仅返回两个表中匹配的行，还返回没有匹配的行，用 `null` 来填充。\n\n外连接又分为左外连接 `left join` 和右外连接 `right join`。\n\nleft join 会保留左表中符合条件的所有记录，如果右表中有匹配的记录，就返回匹配的记录，否则就用 null 填充，常用于某表中有，但另外一张表中可能没有的数据的查询场景。\n\n假设要查询所有用户及他们的订单，即使用户没有下单，就可以使用左连接：\n\n\n```sql\nSELECT users.id, users.name, orders.order_id\nFROM users\nLEFT JOIN orders ON users.id = orders.user_id;\n```\n\n\n查询前：\n\n| users | orders |\n| --- | --- |\n| id | name |\n| 1 | 练习伴侣二 |\n| 2 | 张三 |\n| 3 | 李四 |\n\n查询后：\n\n| id | name | order\\_id |\n| --- | --- | --- |\n| 1 | 练习伴侣二 | 10 |\n| 2 | 张三 | 20 |\n| 3 | 李四 | null |\n\n右连接就是左连接的镜像，right join 会保留右表中符合条件的所有记录，如果左表中有匹配的记录，就返回匹配的记录，否则就用 null 填充。\n\n#### [什么是交叉连接？](#什么是交叉连接)\n\n交叉连接会返回两张表的笛卡尔积，也就是将左表的每一行与右表的每一行进行组合，返回的行数是两张表行数的乘积。\n\n假设有 A 表和 B 表，A 表有 2 行数据，B 表有 3 行数据，那么交叉连接的结果就是 2 ✖️ 3 = 6 行。\n\n\n```sql\nSELECT A.id, B.id\nFROM A\nCROSS JOIN B;\n```\n\n\n笛卡尔积是数学中的一个概念，例如集合 `A={a,b}`，集合 `B={0,1,2}`，那么 A✖️B=`{,,,,,,}`。"
+ },
+ {
+ "id": 337,
+ "question": "内连接、左连接、右连接有什么区别？",
+ "answer": "MySQL 的连接主要分为内连接和外连接，外连接又可以分为左连接和右连接。\n\n\n\n内连接可以用来找出两个表中共同的记录，相当于两个数据集的交集。\n\n左连接和右连接可以用来找出两个表中不同的记录，相当于两个数据集的并集。两者的区别是，左连接会保留左表中符合条件的所有记录，右连接则刚好相反。\n\n拿的表为例来详细验证下。\n\n有三张表，一张文章表 article，主要存文章标题 title， 一张文章详情表 article\\_detail，主要存文章的内容 content，一张文章评论表 comment，主要存评论 content，三个表通过文章 id 关联。\n\n先来看内连接：\n\n\n```sql\nSELECT LEFT(a.title, 20) AS ArticleTitle, LEFT(c.content, 20) AS CommentContent\nFROM article a\nINNER JOIN comment c ON a.id = c.article_id\nLIMIT 2;\n```\n\n\n返回至少有一条评论的文章标题和评论内容（前 20 个字符），只返回符合条件的前 2 条记录。\n\n再来看做连接：\n\n\n```sql\nSELECT LEFT(a.title, 20) AS ArticleTitle, LEFT(c.content, 20) AS CommentContent\nFROM article a\nLEFT JOIN comment c ON a.id = c.article_id\nLIMIT 2;\n```\n\n\n返回所有文章的标题和文章评论，即使某些文章没有评论（填充为 NULL）。\n\n最后来看右连：\n\n\n```sql\nSELECT LEFT(a.title, 20) AS ArticleTitle, LEFT(c.content, 20) AS CommentContent\nFROM comment c\nRIGHT JOIN article a ON a.id = c.article_id\nLIMIT 2;\n```"
+ },
+ {
+ "id": 338,
+ "question": "说一下数据库的三大范式？",
+ "answer": "\n\n第一范式，确保表的每一列都是不可分割的基本数据单元，比如说用户地址，应该拆分成省、市、区、详细地址等 4 个字段。\n\n\n\n第二范式，要求表中的每一列都和主键直接相关。比如在订单表中，商品名称、单位、商品价格等字段应该拆分到商品表中。\n\n\n\n然后新建一个订单商品关联表，用订单编号和商品编号进行关联就好了。\n\n\n\n第三范式，非主键列应该只依赖于主键列。比如说在设计订单信息表的时候，可以把客户名称、所属公司、联系方式等信息拆分到客户信息表中，然后在订单信息表中用客户编号进行关联。\n\n\n\n#### [建表的时候需要考虑哪些问题？](#建表的时候需要考虑哪些问题)\n\n首先需要考虑表是否符合数据库的三大范式，确保字段不可再分，消除非主键依赖，确保字段仅依赖于主键等。\n\n然后在选择字段类型时，应该尽量选择合适的数据类型。\n\n在字符集上，尽量选择 utf8mb4，这样不仅可以支持中文和英文，还可以支持表情符号等。\n\n当数据量较大时，比如上千万行数据，需要考虑分表。比如订单表，可以采用水平分表的方式来分散单表存储压力。"
+ },
+ {
+ "id": 339,
+ "question": "varchar 与 char 的区别？",
+ "answer": "varchar 是可变长度的字符类型，原则上最多可以容纳 65535 个字符，但考虑字符集，以及 MySQL 需要 1 到 2 个字节来表示字符串长度，所以实际上最大可以设置到 65533。\n\n> latin1 字符集，且列属性定义为 NOT NULL。\n\n\n\nchar 是固定长度的字符类型，当定义一个 `CHAR(10)` 字段时，不管实际存储的字符长度是多少，都只会占用 10 个字符的空间。如果插入的数据小于 10 个字符，剩余的部分会用空格填充。\n\n| 值 | CHAR(4) | 存储需求（字节） | VARCHAR(4) | 存储需求（字节） |\n| --- | --- | --- | --- | --- |\n| '' | ' ' | 4 | '' | 1 |\n| 'ab' | 'ab ' | 4 | 'ab' | 3 |\n| 'abcd' | 'abcd' | 4 | 'abcd' | 5 |\n| 'abcdefgh' | 'abcd' | 4 | 'abcd' | 5 |"
+ },
+ {
+ "id": 340,
+ "question": "blob 和 text 有什么区别？",
+ "answer": "blob 用于存储二进制数据，比如图片、音频、视频、文件等；但实际开发中，我们都会把这些文件存储到 OSS 或者文件服务器上，然后在数据库中存储文件的 URL。\n\ntext 用于存储文本数据，比如文章、评论、日志等。\n\n"
+ },
+ {
+ "id": 341,
+ "question": "DATETIME 和 TIMESTAMP 有什么区别？",
+ "answer": "DATETIME 直接存储日期和时间的完整值，与时区无关。\n\nTIMESTAMP 存储的是 Unix 时间戳，1970-01-01 00:00:01 UTC 以来的秒数，受时区影响。\n\n\n\n另外，DATETIME 的默认值为 null，占用 8 个字节；TIMESTAMP 的默认值为当前时间——CURRENT\\_TIMESTAMP，占 4 个字节，实际开发中更常用，因为可以自动更新。\n\n"
+ },
+ {
+ "id": 342,
+ "question": "in 和 exists 的区别？",
+ "answer": "当使用 IN 时，MySQL 会首先执行子查询，然后将子查询的结果集用于外部查询的条件。这意味着子查询的结果集需要全部加载到内存中。\n\n而 EXISTS 会对外部查询的每一行，执行一次子查询。如果子查询返回任何行，则 `EXISTS` 条件为真。`EXISTS` 关注的是子查询是否返回行，而不是返回的具体值。\n\n\n```sql\n-- IN 的临时表可能成为性能瓶颈\nSELECT * FROM users \nWHERE id IN (SELECT user_id FROM orders WHERE amount > 100);\n\n-- EXISTS 可以利用关联索引\nSELECT * FROM users u\nWHERE EXISTS (SELECT 1 FROM orders o \n WHERE o.user_id = u.id AND o.amount > 100);\n```\n\n\n`IN` 适用于子查询结果集较小的情况。如果子查询返回大量数据，`IN` 的性能可能会下降，因为它需要将整个结果集加载到内存。\n\n而 EXISTS 适用于子查询结果集可能很大的情况。由于 `EXISTS` 只需要判断子查询是否返回行，而不需要加载整个结果集，因此在某些情况下性能更好，特别是当子查询可以使用索引时。\n\n#### [NULL值陷了解吗？](#null值陷了解吗)\n\n`IN`: 如果子查询的结果集中包含 `NULL` 值，可能会导致意外的结果。例如，`WHERE column IN (subquery)`，如果 `subquery` 返回 `NULL`，则 `column IN (subquery)` 永远不会为真，除非 `column` 本身也为 `NULL`。\n\n`EXISTS`: 对 `NULL` 值的处理更加直接。`EXISTS` 只是检查子查询是否返回行，不关心行的具体值，因此不受 `NULL` 值的影响。"
+ },
+ {
+ "id": 343,
+ "question": "记录货币用什么类型比较好？",
+ "answer": "如果是电商、交易、账单等涉及货币的场景，建议使用 DECIMAL 类型，因为 DECIMAL 类型是精确数值类型，不会出现浮点数计算误差。\n\n例如，`DECIMAL(19,4)` 可以存储最多 19 位数字，其中 4 位是小数。\n\n\n```sql\nCREATE TABLE orders (\n id INT AUTO_INCREMENT,\n amount DECIMAL(19,4),\n PRIMARY KEY (id)\n);\n```\n\n\n如果是银行，涉及到支付的场景，建议使用 BIGINT 类型。可以将货币金额乘以一个固定因子，比如 100，表示以“分”为单位，然后存储为 `BIGINT`。这种方式既避免了浮点数问题，同时也提供了不错的性能。但在展示的时候需要除以相应的因子。\n\n#### [为什么不推荐使用 FLOAT 或 DOUBLE？](#为什么不推荐使用-float-或-double)\n\n因为 FLOAT 和 DOUBLE 都是浮点数类型，会存在精度问题。\n\n在许多编程语言中，`0.1 + 0.2` 的结果会是类似 `0.30000000000000004` 的值，而不是预期的 `0.3`。"
+ },
+ {
+ "id": 344,
+ "question": "怎么存储 emoji?",
+ "answer": "因为 emoji（😊）是 4 个字节的 UTF-8 字符，而 MySQL 的 utf8 字符集只支持最多 3 个字节的 UTF-8 字符，所以在 MySQL 中存储 emoji 时，需要使用 utf8mb4 字符集。\n\n\n```sql\nALTER TABLE mytable CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;\n```\n\n\nMySQL 8.0 已经默认支持 utf8mb4 字符集，可以通过 `SHOW VARIABLES WHERE Variable_name LIKE 'character\\_set\\_%' OR Variable_name LIKE 'collation%';` 查看。\n\n"
+ },
+ {
+ "id": 345,
+ "question": "drop、delete 与 truncate 的区别？",
+ "answer": "DROP 是物理删除，用来删除整张表，包括表结构，且不能回滚。\n\nDELETE 支持行级删除，可以带 WHERE 条件，可以回滚。\n\nTRUNCATE 用于清空表中的所有数据，但会保留表结构，不能回滚。"
+ },
+ {
+ "id": 346,
+ "question": "UNION 与 UNION ALL 的区别？",
+ "answer": "UNION 会自动去除合并后结果集中的重复行。UNION ALL 不会去重，会将所有结果集合并起来。"
+ },
+ {
+ "id": 347,
+ "question": "count(1)、count(*) 与 count(列名) 的区别？",
+ "answer": "在 InnoDB 引擎中，`COUNT(1)` 和 `COUNT(*)` 没有区别，都是用来统计所有行，包括 NULL。\n\n如果表有索引，`COUNT(*)` 会直接用索引统计，而不是全表扫描，而 `COUNT(1)` 也会被 MySQL 优化为 `COUNT(*)`。\n\n`COUNT(列名)` 只统计列名不为 NULL 的行数。\n\n\n```text\n-- 假设 users 表：\n+----+-------+------------+\n| id | name | email |\n+----+-------+------------+\n| 1 | 张三 | zhang@xx.com |\n| 2 | 李四 | NULL |\n| 3 | 练习伴侣二 | wang@xx.com |\n+----+-------+------------+\n\n-- COUNT(*)\nSELECT COUNT(*) FROM users;\n-- 结果：3 （统计所有行）\n\n-- COUNT(1)\nSELECT COUNT(1) FROM users;\n-- 结果：3 （统计所有行）\n\n-- COUNT(email)\nSELECT COUNT(email) FROM users;\n-- 结果：2 （NULL 不计入统计）\n```\n\n\n这里解释一下，假设有这样一张表：\n\n\n```sql\nCREATE TABLE t1 (\n id INT,\n name VARCHAR(50),\n value INT\n);\n```\n\n\n插入的数据为：\n\n\n```sql\nINSERT INTO t1 VALUES \n (1, 'A', 10),\n (2, 'B', NULL), -- NULL in value column\n (3, 'C', 30),\n (4, NULL, 40), -- NULL in name column\n (5, 'E', NULL); -- NULL in value column\n```\n\n\n因为 id 列没有索引，所以 `select count(*)` 是全表扫描。\n\n\n\n然后我们给 id 列加上索引。\n\n\n```sql\nalter table t1 add primary key (id);\n```\n\n\n再来看一下 `select count(*)`，发现用了索引（MySQL 默认为给主键添加索引）。\n\n\n\n另外，MySQL 8.0 官方手册有明确说明，InnoDB 引擎对 `SELECT COUNT(*)` 和 `SELECT COUNT(1)` 的处理方式完全一致，性能并无差异。\n\n"
+ },
+ {
+ "id": 348,
+ "question": "SQL 查询语句的执行顺序了解吗？",
+ "answer": "了解。先执行 FROM 确定主表，再执行 JOIN 连接，然后 WHERE 进行过滤，接着 GROUP BY 进行分组，HAVING 过滤聚合结果，SELECT 选择最终列，ORDER BY 排序，最后 LIMIT 限制返回行数。\n\nWHERE 先执行是为了减少数据量，HAVING 只能过滤聚合数据，ORDER BY 必须在 SELECT 之后排序最终结果，LIMIT 最后执行以减少数据传输。\n\n\n\n| 执行顺序 | SQL 关键字 | 作用 |\n| --- | --- | --- |\n| ① | FROM | 确定主表，准备数据 |\n| ② | ON | 连接多个表的条件 |\n| ③ | JOIN | 执行 INNER JOIN / LEFT JOIN 等 |\n| ④ | WHERE | 过滤行数据（提高效率） |\n| ⑤ | GROUP BY | 进行分组 |\n| ⑥ | HAVING | 过滤聚合后的数据 |\n| ⑦ | SELECT | 选择最终返回的列 |\n| ⑧ | DISTINCT | 进行去重 |\n| ⑨ | ORDER BY | 对最终结果排序 |\n| ⑩ | LIMIT | 限制返回行数 |\n\n这个执行顺序与编写 SQL 语句的顺序不同，这也是为什么有时候在 SELECT 子句中定义的别名不能在 WHERE 子句中使用得原因，因为 WHERE 是在 SELECT 之前执行的。\n\n#### [LIMIT 为什么在最后执行？](#limit-为什么在最后执行)\n\n因为 LIMIT 是在最终结果集上执行的，如果在 WHERE 之前执行 LIMIT，那么就会先返回所有行，然后再进行 LIMIT 限制，这样会增加数据传输的开销。\n\n#### [ORDER BY 为什么在 SELECT 之后执行？](#order-by-为什么在-select-之后执行)\n\n因为排序需要基于最终返回的列，如果 ORDER BY 早于 SELECT 执行，计算 `COUNT(*)` 之类的聚合函数就会出问题。\n\n\n```sql\nSELECT name, COUNT(*) AS order_count\nFROM orders\nGROUP BY name\nORDER BY order_count DESC;\n```"
+ },
+ {
+ "id": 349,
+ "question": "介绍一下 MySQL 的常用命令（补充）",
+ "answer": "> 2024 年 03 月 13 日增补。\n\n\n\nMySQL 的常用命令主要包括数据库操作命令、表操作命令、行数据 CRUD 命令、索引和约束的创建修改命令、用户和权限管理的命令、事务控制的命令等。\n\n#### [说说数据库操作命令？](#说说数据库操作命令)\n\n`CREATE DATABASE database_name;` 用于创建数据库；`DROP DATABASE database_name;` 用于删除数据库；`SHOW DATABASES;` 用于显示所有数据库；`USE database_name;` 用于切换数据库。\n\n#### [说说表操作命令？](#说说表操作命令)\n\n`CREATE TABLE table_name (列名1 数据类型1, 列名2 数据类型2,...);` 用于创建表；`DROP TABLE table_name;` 用于删除表；`SHOW TABLES;` 用于显示所有表；`DESCRIBE table_name;` 用于查看表结构；`ALTER TABLE table_name ADD column_name datatype;` 用于修改表。\n\n#### [说说行数据的 CRUD 命令？](#说说行数据的-crud-命令)\n\n`INSERT INTO table_name (column1, column2, ...) VALUES (value1, value2, ...);` 用于插入数据；`SELECT column_names FROM table_name WHERE condition;` 用于查询数据；`UPDATE table_name SET column1 = value1, column2 = value2 WHERE condition;` 用于更新数据；`DELETE FROM table_name WHERE condition;` 用于删除数据。\n\n#### [说说索引和约束的创建修改命令？](#说说索引和约束的创建修改命令)\n\n`CREATE INDEX index_name ON table_name (column_name);` 用于创建索引；`ALTER TABLE table_name ADD PRIMARY KEY (column_name);` 用于添加主键；`ALTER TABLE table_name ADD CONSTRAINT fk_name FOREIGN KEY (column_name) REFERENCES parent_table (parent_column_name);` 用于添加外键。\n\n#### [说说用户和权限管理的命令？](#说说用户和权限管理的命令)\n\n`CREATE USER 'username'@'host' IDENTIFIED BY 'password';` 用于创建用户；`GRANT ALL PRIVILEGES ON database_name.table_name TO 'username'@'host';` 用于授予权限；`REVOKE ALL PRIVILEGES ON database_name.table_name FROM 'username'@'host';` 用于撤销权限；`DROP USER 'username'@'host';` 用于删除用户。\n\n#### [说说事务控制的命令？](#说说事务控制的命令)\n\n`START TRANSACTION;` 用于开始事务；`COMMIT;` 用于提交事务；`ROLLBACK;` 用于回滚事务。"
+ },
+ {
+ "id": 350,
+ "question": "MySQL bin 目录下的可执行文件了解吗（补充）",
+ "answer": "> 2024 年 03 月 13 日增补\n\n了解的。MySQL 的 bin 目录下有很多可执行文件，主要用于管理 MySQL 服务器、数据库、表、数据等。比如说：\n\n* mysql：用于连接 MySQL 服务器\n* mysqldump：用于数据库备份，对数据备份、迁移或恢复时非常有用\n* mysqladmin：用来执行一些管理操作，比如说创建数据库、删除数据库、查看 MySQL 服务器的状态等。\n* mysqlcheck：用于检查、修复、分析和优化数据库表，对数据库的维护和性能优化非常有用。\n* mysqlimport：用于从文本文件中导入数据到数据库表中，适合批量数据导入。\n* mysqlshow：用于显示 MySQL 数据库服务器中的数据库、表、列等信息。\n* mysqlbinlog：用于查看 MySQL 二进制日志文件的内容，可以用于恢复数据、查看数据变更等。"
+ },
+ {
+ "id": 351,
+ "question": "MySQL 第 3-10 条记录怎么查？（补充）",
+ "answer": "> 2024 年 03 月 30 日增补\n\n可以使用 limit 语句，结合偏移量和行数来实现。\n\n\n```sql\nSELECT * FROM table_name LIMIT 2, 8;\n```\n\n\nlimit 语句用于限制查询结果的数量，偏移量表示从哪条记录开始，行数表示返回的记录数量。\n\n* 2：偏移量，表示跳过前两条记录，从第三条记录开始。\n* 8：行数，表示从偏移量开始，返回 8 条记录。\n\n偏移量是从 0 开始的，即第一条记录的偏移量是 0；如果想从第 3 条记录开始，偏移量就应该是 2。"
+ },
+ {
+ "id": 352,
+ "question": "用过哪些 MySQL 函数？（补充）",
+ "answer": "> 2024 年 04 月 12 日增补\n\n用过挺多的，比如说处理字符串的函数：\n\n* `CONCAT()`: 用于连接两个或多个字符串。\n* `LENGTH()`: 用于返回字符串的长度。\n* `SUBSTRING()`: 从字符串中提取子字符串。\n* `REPLACE()`: 替换字符串中的某部分。\n* `TRIM()`: 去除字符串两侧的空格或其他指定字符。\n\n实测数据：\n\n\n```sql\n-- 连接字符串\nSELECT CONCAT('practice-mate', ' ', '练习伴侣二') AS concatenated_string;\n\n-- 获取字符串长度\nSELECT LENGTH('practice-mate 练习伴侣二') AS string_length;\n\n-- 提取子字符串\nSELECT SUBSTRING('practice-mate 练习伴侣二', 1, 5) AS substring;\n\n-- 替换字符串内容\nSELECT REPLACE('practice-mate 练习伴侣二', '练习伴侣二', 'MySQL') AS replaced_string;\n\n-- 去除字符串两侧的空格\nSELECT TRIM(' practice-mate 练习伴侣二 ') AS trimmed_string;\n```\n\n\n处理数字的函数：\n\n* `ABS()`: 返回一个数的绝对值。\n* `ROUND()`: 四舍五入到指定的小数位数。\n* `MOD()`: 返回除法操作的余数。\n\n实测数据：\n\n\n```sql\n-- 返回绝对值\nSELECT ABS(-123) AS absolute_value;\n\n-- 四舍五入\nSELECT ROUND(123.4567, 2) AS rounded_value;\n\n-- 余数\nSELECT MOD(10, 3) AS modulus;\n```\n\n\n日期和时间处理函数：\n\n* `NOW()`: 返回当前的日期和时间。\n* `CURDATE()`: 返回当前的日期。\n\n实测数据：\n\n\n```sql\n-- 返回当前日期和时间\nSELECT NOW() AS current_date_time;\n\n-- 返回当前日期\nSELECT CURDATE() AS current_date;\n```\n\n\n汇总函数：\n\n* `SUM()`: 计算数值列的总和。\n* `AVG()`: 计算数值列的平均值。\n* `COUNT()`: 计算某列的行数。\n\n实测数据：\n\n\n```sql\n-- 创建一个表并插入数据进行聚合查询\nCREATE TABLE sales (\n product_id INT,\n sales_amount DECIMAL(10, 2)\n);\n\nINSERT INTO sales (product_id, sales_amount) VALUES (1, 100.00);\nINSERT INTO sales (product_id, sales_amount) VALUES (1, 150.00);\nINSERT INTO sales (product_id, sales_amount) VALUES (2, 200.00);\n\n-- 计算总和\nSELECT SUM(sales_amount) AS total_sales FROM sales;\n\n-- 计算平均值\nSELECT AVG(sales_amount) AS average_sales FROM sales;\n\n-- 计算总行数\nSELECT COUNT(*) AS total_entries FROM sales;\n```\n\n\n逻辑函数：\n\n* `IF()`: 如果条件为真，则返回一个值；否则返回另一个值。\n* `CASE`: 根据一系列条件返回值。\n\n\n```sql\n-- IF函数\nSELECT IF(1 > 0, 'True', 'False') AS simple_if;\n\n-- CASE表达式\nSELECT CASE WHEN 1 > 0 THEN 'True' ELSE 'False' END AS case_expression;\n```"
+ },
+ {
+ "id": 353,
+ "question": "说说 SQL 的隐式数据类型转换？（补充）",
+ "answer": "> 2024 年 04 月 25 日增补\n\n当一个整数和一个浮点数相加时，整数会被转换为浮点数。\n\n\n```sql\nSELECT 1 + 1.0; -- 结果为 2.0\n```\n\n\n当一个字符串和一个整数相加时，字符串会被转换为整数。\n\n\n```sql\nSELECT '1' + 1; -- 结果为 2\n```\n\n\n隐式转换会导致意想不到的结果，最好通过显式转换来规避。\n\n\n```sql\nSELECT CAST('1' AS SIGNED INTEGER) + 1; -- 结果为 2\n```\n\n\n实际验证结果：\n\n"
+ },
+ {
+ "id": 354,
+ "question": "说说 SQL 的语法树解析？（补充）",
+ "answer": "> 2024 年 09 月 19 日增补\n\nSQL 语法树解析是将 SQL 查询语句转换成抽象语法树 —— AST 的过程，是数据库引擎处理查询的第一步，也是防止 SQL 注入的重要手段。\n\n通常分为 3 个阶段。\n\n第一个阶段，词法分析：拆解 SQL 语句，识别关键字、表名、列名等。\n\n---这部分是帮助大家理解 start，面试中可不背---\n\n比如说：\n\n\n```sql\nSELECT id, name FROM users WHERE age > 18;\n```\n\n\n将会被拆解为：\n\n\n```text\n[SELECT] [id] [,] [name] [FROM] [users] [WHERE] [age] [>] [18] [;]\n```\n\n\n---这部分是帮助大家理解 end，面试中可不背---\n\n第二个阶段，语法分析：检查 SQL 是否符合语法规则，并构建抽象语法树。\n\n---这部分是帮助大家理解 start，面试中可不背---\n\n比如说上面的语句会被构建成如下的语法树：\n\n\n```text\n SELECT\n / \\\n Columns FROM\n / \\ |\n id name users\n |\n WHERE\n |\n age > 18\n```\n\n\n或者这样表示：\n\n\n```text\nSELECT\n ├── COLUMNS: id, name\n ├── FROM: users\n ├── WHERE\n │ ├── CONDITION: age > 18\n```\n\n\n---这部分是帮助大家理解 end，面试中可不背---\n\n第三个阶段，语义分析：检查表、列是否存在，进行权限验证等。\n\n---这部分是帮助大家理解 start，面试中可不背---\n\n比如说执行：\n\n\n```sql\nSELECT id, name FROM users WHERE age > 'eighteen';\n```\n\n\n会报错：\n\n\n```text\nERROR: Column 'age' is INT, but 'eighteen' is STRING.\n```\n\n\n---这部分是帮助大家理解 end，面试中可不背---"
+ }
+ ]
+ },
+ {
+ "id": 52,
+ "categoryName": "数据库架构",
+ "questions": [
+ {
+ "id": 355,
+ "question": "说说 MySQL 的基础架构？",
+ "answer": "MySQL 采用分层架构，主要包括连接层、服务层、和存储引擎层。\n\n\n\n①、连接层主要负责客户端连接的管理，包括验证用户身份、权限校验、连接管理等。可以通过数据库连接池来提升连接的处理效率。\n\n②、服务层是 MySQL 的核心，主要负责查询解析、优化、执行等操作。在这一层，SQL 语句会经过解析、优化器优化，然后转发到存储引擎执行，并返回结果。这一层包含查询解析器、优化器、执行计划生成器、日志模块等。\n\n③、存储引擎层负责数据的实际存储和提取。MySQL 支持多种存储引擎，如 InnoDB、MyISAM、Memory 等。\n\n#### [binlog写入在哪一层？](#binlog写入在哪一层)\n\nbinlog 在服务层，负责记录 SQL 语句的变化。它记录了所有对数据库进行更改的操作，用于数据恢复、主从复制等。"
+ },
+ {
+ "id": 356,
+ "question": "一条查询语句是如何执行的？",
+ "answer": "当我们执行一条 SELECT 语句时，MySQL 并不会直接去磁盘读取数据，而是经过 6 个步骤来解析、优化、执行，然后再返回结果。\n\n\n\n第一步，客户端发送 SQL 查询语句到 MySQL 服务器。\n\n第二步，MySQL 服务器的连接器开始处理这个请求，跟客户端建立连接、获取权限、管理连接。\n\n第三步，解析器对 SQL 语句进行解析，检查语句是否符合 SQL 语法规则，确保数据库、表和列都是存在的，并处理 SQL 语句中的名称解析和权限验证。\n\n第四步，优化器负责确定 SQL 语句的执行计划，这包括选择使用哪些索引，以及决定表之间的连接顺序等。\n\n第五步，执行器会调用存储引擎的 API 来进行数据的读写。\n\n第六步，存储引擎负责查询数据，并将执行结果返回给客户端。客户端接收到查询结果，完成这次查询请求。"
+ },
+ {
+ "id": 357,
+ "question": "一条更新语句是如何执行的？",
+ "answer": "总的来说，一条 UPDATE 语句的执行过程包括读取数据页、加锁解锁、事务提交、日志记录等多个步骤。\n\n\n\n拿 `update test set a=1 where id=2` 举例来说：\n\n在事务开始前，MySQL 需要记录undo log，用于事务回滚。\n\n| 操作 | id | 旧值 | 新值 |\n| --- | --- | --- | --- |\n| update | 2 | N | 1 |\n\n除了记录 undo log，存储引擎还会将更新操作写入 redo log，状态标记为 prepare，并确保 redo log 持久化到磁盘。这一步可以保证即使系统崩溃，数据也能通过 redo log 恢复到一致状态。\n\n写完 redo log 后，MySQL 会获取行锁，将 a 的值修改为 1，标记为脏页，此时数据仍然在内存的 buffer pool 中，不会立即写入磁盘。后台线程会在适当的时候将脏页刷盘，以提高性能。\n\n最后提交事务，redo log 中的记录被标记为 committed，行锁释放。\n\n如果 MySQL 开启了 binlog，还会将更新操作记录到 binlog 中，主要用于主从复制。\n\n以及数据恢复，可以结合 redo log 进行点对点的恢复。binlog 的写入通常发生在事务提交时，与 redo log 共同构成“两阶段提交”，确保两者的一致性。\n\n注意，redo log 的写入有两个阶段的提交，一是 binlog 写入之前`prepare` 状态的写入，二是 binlog 写入之后 `commit` 状态的写入。"
+ },
+ {
+ "id": 358,
+ "question": "说说 MySQL 的段区页行（补充）",
+ "answer": "> 2024 年 04 月 26 日增补\n\nMySQL 是以表的形式存储数据的，而表空间的结构则由段、区、页、行组成。\n\n\n\n①、段：表空间由多个段组成，常见的段有数据段、索引段、回滚段等。\n\n创建索引时会创建两个段，数据段和索引段，数据段用来存储叶子节点中的数据；索引段用来存储非叶子节点的数据。\n\n回滚段包含了事务执行过程中用于数据回滚的旧数据。\n\n②、区：段由一个或多个区组成，区是一组连续的页，通常包含 64 个连续的页，也就是 1M 的数据。\n\n使用区而非单独的页进行数据分配可以优化磁盘操作，减少磁盘寻道时间，特别是在大量数据进行读写时。\n\n③、页：页是 InnoDB 存储数据的基本单元，标准大小为 16 KB，索引树上的一个节点就是一个页。\n\n也就意味着数据库每次读写都是以 16 KB 为单位的，一次最少从磁盘中读取 16KB 的数据到内存，一次最少写入 16KB 的数据到磁盘。\n\n④、行：InnoDB 采用行存储方式，意味着数据按照行进行组织和管理，行数据可能有多个格式，比如说 COMPACT、REDUNDANT、DYNAMIC 等。\n\nMySQL 8.0 默认的行格式是 DYNAMIC，由COMPACT 演变而来，意味着这些数据如果超过了页内联存储的限制，则会被存储在溢出页中。\n\n可以通过 `show table status like '%article%'` 查看行格式。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 53,
+ "categoryName": "存储引擎",
+ "questions": [
+ {
+ "id": 359,
+ "question": "MySQL 有哪些常见存储引擎？",
+ "answer": "MySQL 支持多种存储引擎，常见的有 MyISAM、InnoDB、MEMORY 等。\n\n---这部分是帮助大家理解 start，面试中可不背---\n\n\n\n我来做一个表格对比：\n\n| 功能 | InnoDB | MyISAM | MEMORY |\n| --- | --- | --- | --- |\n| 支持事务 | Yes | No | No |\n| 支持全文索引 | Yes | Yes | No |\n| 支持 B+树索引 | Yes | Yes | Yes |\n| 支持哈希索引 | Yes | No | Yes |\n| 支持外键 | Yes | No | No |\n\n---这部分是帮助大家理解 end，面试中可不背---\n\n除此之外，我还了解到：\n\n①、MySQL 5.5 之前，默认存储引擎是 MyISAM，5.5 之后是 InnoDB。\n\n②、InnoDB 支持的哈希索引是自适应的，不能人为干预。\n\n③、InnoDB 从 MySQL 5.6 开始，支持全文索引。\n\n④、InnoDB 的最小表空间略小于 10M，最大表空间取决于页面大小。\n\n\n\n#### [如何切换 MySQL 的数据引擎？](#如何切换-mysql-的数据引擎)\n\n可以通过 alter table 语句来切换 MySQL 的数据引擎。\n\n\n```sql\nALTER TABLE your_table_name ENGINE=InnoDB;\n```\n\n\n不过不建议，应该提前设计好到底用哪一种存储引擎。"
+ },
+ {
+ "id": 360,
+ "question": "存储引擎应该怎么选择？",
+ "answer": "大多数情况下，使用默认的 InnoDB 就可以了，InnoDB 可以提供事务、行级锁、外键、B+ 树索引等能力。\n\nMyISAM 适合读多写少的场景。\n\nMEMORY 适合临时表，数据量不大的情况。因为数据都存放在内存，所以速度非常快。"
+ },
+ {
+ "id": 361,
+ "question": "InnoDB 和 MyISAM 主要有什么区别？",
+ "answer": "InnoDB 和 MyISAM 的最大区别在于事务支持和锁机制。InnoDB 支持事务、行级锁，适合大多数业务系统；而 MyISAM 不支持事务，用的是表锁，查询快但写入性能差，适合读多写少的场景。\n\n\n\n另外，从存储结构上来说，MyISAM 用三种格式的文件来存储，.frm 文件存储表的定义；.MYD 存储数据；.MYI 存储索引；而 InnoDB 用两种格式的文件来存储，.frm 文件存储表的定义；.ibd 存储数据和索引。\n\n从索引类型上来说，MyISAM 为非聚簇索引，索引和数据分开存储，索引保存的是数据文件的指针。\n\n\n\nInnoDB 为聚簇索引，索引和数据不分开。\n\n\n\n更细微的层面上来讲，MyISAM 不支持外键，可以没有主键，表的具体行数存储在表的属性中，查询时可以直接返回；InnoDB 支持外键，必须有主键，具体行数需要扫描整个表才能返回，有索引的情况下会扫描索引。\n\n#### [InnoDB的内存结构了解吗？](#innodb的内存结构了解吗)\n\n> 2025 年 04 月 04 日增补\n\nInnoDB 的内存区域主要有两块，buffer pool 和 log buffer。 buffer pool 用于缓存数据页和索引页，提升读写性能；log buffer 用于缓存 redo log，提升写入性能。\n\n\n\n#### [数据页的结构了解吗？](#数据页的结构了解吗)\n\nInnoDB 的数据页由 7 部分组成，其中文件头、页头和文件尾的大小是固定的，分别为 38、56 和 8 个字节，用来标记该页的一些信息。行记录、空闲空间和页目录的大小是动态的，为实际的行记录存储空间。\n\n\n\n来个表格总结下：\n\n| 名称 | 中文名 | 大小（单位：B） | 描述 |\n| --- | --- | --- | --- |\n| File Header | 文件头部 | 38 | 页的一些通用信息 |\n| Page Header | 页面头部 | 56 | 数据页专有的一些信息 |\n| Infimum + Supermum | 最小记录和最大记录 | 26 | 两个虚拟的行记录 |\n| User Records | 用户真实记录 | 不确定 | 实际存储的行记录内容 |\n| Free Space | 空闲空间 | 不确定 | 页中尚未使用的空间 |\n| Page Directory | 页面目录 | 不确定 | 页中的某些记录的相对位置 |\n| File Trailer | 文件尾部 | 8 | 校验页是否完整 |\n\n真实的记录会按照指定的行格式存储到 User Records 中。\n\n\n\n每个数据页的 File Header 都有一个上一页和下一页的编号，所有的数据页会形成一个双向链表。\n\n\n\n在 InnoDB 中，默认的页大小是 16KB。可以通过 `show variables like 'innodb_page_size';` 查看。\n\n"
+ },
+ {
+ "id": 362,
+ "question": "InnoDB 的 Buffer Pool了解吗？（补充）",
+ "answer": "> 2024 年 11 月 04 日增补\n\nBuffer Pool 是 InnoDB 存储引擎中的一个内存缓冲区，它会将经常使用的数据页、索引页加载进内存，读的时候先查询 Buffer Pool，如果命中就不用访问磁盘了。\n\n\n\n如果没有命中，就从磁盘读取，并加载到 Buffer Pool，此时可能会触发页淘汰，将不常用的页移出 Buffer Pool。\n\n\n\n写操作时不会直接写入磁盘，而是先修改内存中的页，此时页被标记为脏页，后台线程会定期将脏页刷新到磁盘。\n\nBuffer Pool 可以显著减少磁盘的读写次数，从而提升 MySQL 的读写性能。\n\n#### [Buffer Pool 的默认大小是多少？](#buffer-pool-的默认大小是多少)\n\n我本机上 InnoDB 的 Buffer Pool 默认大小是 128MB。\n\n\n```sql\nSHOW VARIABLES LIKE 'innodb_buffer_pool_size';\n```\n\n\n另外，在具有 1GB-4GB RAM 的系统上，默认值为系统 RAM 的 25%；在具有超过 4GB RAM 的系统上，默认值为系统 RAM 的 50%，但不超过 4GB。\n\n\n\n#### [InnoDB 对 LRU 算法的优化了解吗？](#innodb-对-lru-算法的优化了解吗)\n\n了解，InnoDB 对 LRU 算法进行了改良，最近访问的数据并不直接放到 LRU 链表的头部，而是放在一个叫 midpoiont 的位置。默认情况下，midpoint 位于 LRU 列表的 5/8 处。\n\n\n\n比如 Buffer Pool 有 100 页，新页插入的位置大概是在第 80 页；当页数据被频繁访问后，再将其移动到 young 区，这样做的好处是热点页能长时间保留在内存中，不容易被挤出去。\n\n----这部分是帮助大家理解 start，面试中可不背----\n\n可以通过 `innodb_old_blocks_pct` 参数来调整 Buffer Pool 中 old 和 young 区的比例；通过 `innodb_old_blocks_time` 参数来调整页在 young 区的停留时间。\n\n\n\n默认情况下，LRU 链表中 old 区占 37%；同一页再次访问提升的最小时间间隔是 1000 毫秒。\n\n也就是说，如果某页在 1 秒内被多次访问，只会计算一次，不会立刻升级为热点页，防止短时间批量访问导致缓存污染。\n\n----这部分是帮助大家理解 end，面试中可不背----"
+ }
+ ]
+ },
+ {
+ "id": 54,
+ "categoryName": "日志",
+ "questions": [
+ {
+ "id": 363,
+ "question": "MySQL 日志文件有哪些？",
+ "answer": "有 6 大类，其中错误日志用于问题诊断，慢查询日志用于 SQL 性能分析，general log 用于记录所有的 SQL 语句，binlog 用于主从复制和数据恢复，redo log 用于保证事务持久性，undo log 用于事务回滚和 MVCC。\n\n\n\n----这部分是帮助大家理解 start，面试中可不背----\n\n①、**错误日志**（Error Log）：记录 MySQL 服务器启动、运行或停止时出现的问题。\n\n②、**慢查询日志**（Slow Query Log）：记录执行时间超过 long\\_query\\_time 值的所有 SQL 语句。这个时间值是可配置的，默认情况下，慢查询日志功能是关闭的。\n\n③、**一般查询日志**（General Query Log）：记录 MySQL 服务器的启动关闭信息，客户端的连接信息，以及更新、查询的 SQL 语句等。\n\n④、**二进制日志**（Binary Log）：记录所有修改数据库状态的 SQL 语句，以及每个语句的执行时间，如 INSERT、UPDATE、DELETE 等，但不包括 SELECT 和 SHOW 这类的操作。\n\n⑤、**重做日志**（Redo Log）：记录对于 InnoDB 表的每个写操作，不是 SQL 级别的，而是物理级别的，主要用于崩溃恢复。\n\n⑥、**回滚日志**（Undo Log，或者叫事务日志）：记录数据被修改前的值，用于事务的回滚。\n\n----这部分是帮助大家理解 end，面试中可不背----\n\n#### [请重点说说 binlog？](#请重点说说-binlog)\n\nbinlog 是一种物理日志，会在磁盘上记录数据库的所有修改操作。\n\n如果误删了数据，就可以使用 binlog 进行回退到误删之前的状态。\n\n\n```sql\n# 步骤1：恢复全量备份\nmysql -u root -p < full_backup.sql\n# 步骤2：应用Binlog到指定时间点\nmysqlbinlog --start-datetime=\"2025-03-13 14:00:00\" --stop-datetime=\"2025-03-13 15:00:00\" binlog.000001 | mysql -u root -p\n```\n\n\n如果要搭建主从复制，就可以让从库定时读取主库的 binlog。\n\nMySQL 提供了三种格式的 binlog：Statement、Row 和 Mixed，分别对应 SQL 语句级别、行级别和混合级别，默认为行级别。\n\n\n\n从后缀名上来看，binlog 文件分为两类：以 .index 结尾的索引文件，以 .00000\\* 结尾的二进制日志文件。\n\nbinlog 默认是没有启用的。\n\n生产环境中是一定要启用的，可以通过在 my.cnf 文件中配置 log\\_bin 参数，以启用 binlog。\n\n\n```text\nlog_bin = mysql-bin #开启binlog\n\n#mysql-bin.*日志文件最大字节（单位：字节）\n#设置最大100MB\nmax_binlog_size=104857600\n\n#设置了只保留7天BINLOG（单位：天）\nexpire_logs_days = 7\n\n#binlog日志只记录指定库的更新\n#binlog-do-db=db_name\n\n#binlog日志不记录指定库的更新\n#binlog-ignore-db=db_name\n\n#写缓冲多少次，刷一次磁盘，默认0\nsync_binlog=0\n```\n\n\n#### [binlog 的配置参数都了解哪些？](#binlog-的配置参数都了解哪些)\n\n`log_bin = mysql-bin` 用于启用 binlog，这样就可以在 MySQL 的数据目录中找到 db-bin.000001、db-bin.000002 等日志文件。\n\n\n\n`max_binlog_size=104857600` 用于设置每个 binlog 文件的大小，不建议设置太大，网络传送起来比较麻烦。\n\n当 binlog 文件达到 max\\_binlog\\_size 时，MySQL 会关闭当前文件并创建一个新的 binlog 文件。\n\n`expire_logs_days = 7` 用于设置 binlog 文件的自动过期时间为 7 天。过期的 binlog 文件会被自动删除。防止长时间累积的 binlog 文件占用过多存储空间，所在的项目是丐版服务器，所以这个配置很重要。\n\n`binlog-do-db=db_name`，指定哪些数据库表的更新应该被记录。\n\n`binlog-ignore-db=db_name`，指定忽略哪些数据库表的更新。\n\n`sync_binlog=0`，设置每多少次 binlog 写操作会触发一次磁盘同步操作。默认值为 0，表示 MySQL 不会主动触发同步操作，而是依赖操作系统的磁盘缓存策略。\n\n即当执行写操作时，数据会先写入缓存，当缓存区满了再由操作系统将数据一次性刷入磁盘。\n\n如果设置为 1，表示每次 binlog 写操作后都会同步到磁盘，虽然可以保证数据能够及时写入磁盘，但会降低性能。\n\n可以通过 `show variables like '%log_bin%';` 查看 binlog 是否开启。\n\n\n\n#### [有了binlog为什么还要undolog redolog？](#有了binlog为什么还要undolog-redolog)\n\nbinlog 属于 Server 层，与存储引擎无关，无法直接操作物理数据页。而 redo log 和 undo log 是 InnoDB 存储引擎实现 ACID 的基石。\n\nbinlog 关注的是逻辑变更的全局记录；redo log 用于确保物理变更的持久性，确保事务最终能够刷盘成功；undo log 是逻辑逆向操作日志，记录的是旧值，方便恢复到事务开始前的状态。\n\n> 另外一种回答方式。\n\nbinlog 会记录整个 SQL 或行变化；redo log 是为了恢复“已提交但未刷盘”的数据，undo log 是为了撤销未提交的事务。\n\n以一次事务更新为例：\n\n\n```sql\n# 开启事务\nBEGIN;\n# 更新数据\nUPDATE users SET age = age + 1 WHERE id = 1;\n# 提交事务\nCOMMIT;\n```\n\n\n事务开始的时候会生成 undo log，记录更新前的数据，比如原值是 18：\n\n\n```text\nundo log: id=1, age=18\n```\n\n\n修改数据的时候，会将数据写入到 redo log。\n\n比如数据页 page\\_id=123 上，id=1 的用户被更新为 age=26：\n\n\n```text\nredo log (prepare):\npage_id=123, offset=0x40, before=18, after=26\n```\n\n\n等事务提交的时候，redo log 刷盘，binlog 刷盘。\n\nbinlog 写完之后，redo log 的状态会变为 commit：\n\n\n```text\nredo log (commit):\npage_id=123, offset=0x40, before=18, after=26\n```\n\n\nbinlog 如果是 Statement 格式，会记录一条 SQL 语句：\n\n\n```sql\nUPDATE users SET age = age + 1 WHERE id = 1;\n```\n\n\nbinlog 如果是 Row 格式，会记录：\n\n\n```text\n表：users\nbefore: id=1, age=18\nafter: id=1, age=26\n```\n\n\n随后，后台线程会将 redo log 中的变更异步刷新到磁盘。"
+ },
+ {
+ "id": 364,
+ "question": "binlog 和 redo log 有什么区别？",
+ "answer": "binlog 由 MySQL 的 Server 层实现，与存储引擎无关；redo log 由 InnoDB 存储引擎实现。\n\n\n\nbinlog 记录的是逻辑日志，包括原始的 SQL 语句或者行数据变化，例如“将 id=2 这行数据的 age 字段+1”。\n\nredo log 记录物理日志，即数据页的具体修改，例如“将 page\\_id=123 上 offset=0x40 的数据从 18 修改为 26”。\n\nbinlog 是追加写入的，文件写满后会新建文件继续写入，不会覆盖历史日志，保存的是全量操作记录；redo log 是循环写入的，空间是固定的，写满后会覆盖旧的日志，仅保存未刷盘的脏页日志，已持久化的数据会被清除。\n\n另外，为保证两种日志的一致性，innodb 采用了两阶段提交策略，redo log 在事务执行过程中持续写入，并在事务提交前进入 prepare 状态；binlog 在事务提交的最后阶段写入，之后 redo log 会被标记为 commit 状态。\n\n可以通过回放 binlog 实现数据同步或者恢复到指定时间点；redo log 用来确保事务提交后即使系统宕机，数据仍然可以通过重放 redo log 恢复。"
+ },
+ {
+ "id": 365,
+ "question": "为什么要两阶段提交呢？",
+ "answer": "为了保证 redo log 和 binlog 中的数据一致性，防止主从复制和事务状态不一致。\n\n\n\n#### [为什么 2PC 能保证 redo log 和 binlog 的强⼀致性？](#为什么-2pc-能保证-redo-log-和-binlog-的强一致性)\n\n假如 MySQL 在预写 redo log 之后、写入 binlog 之前崩溃。那么 MySQL 重启后 InnoDB 会回滚该事务，因为 redo log 不是提交状态。并且由于 binlog 中没有写入数据，所以从库也不会有该事务的数据。\n\n\n\n假如 MySQL 在写入 binlog 之后、redo log 提交之前崩溃。那么 MySQL 重启后 InnoDB 会提交该事务，因为 redo log 是提交状态。并且由于 binlog 中有写入数据，所以从库也会同步到该事务的数据。\n\n伪代码如下所示：\n\n\n```java\n// 事务开始\nbegin;\n\n// try\n{\n // 执行 SQL\n execute SQL;\n\n // 写入 redo log 并标记为 prepare\n write redo log prepare xid;\n\n // 写入 binlog\n write binlog xid sql;\n\n // 提交 redo log\n commit redo log xid;\n}\n// catch\n{\n // 回滚 redo log\n innodb rollback redo log xid;\n}\n\n// 事务结束\nend;\n```\n\n\n#### [XID 了解吗？](#xid-了解吗)\n\nXID 是 binlog 中用来标识事务提交的唯一标识符。\n\n\n\n在事务提交时，会写入一个 XID\\_EVENT 到 binlog，表示这个事务真正完成了。\n\n\n```sql\n Log_name | Pos | Event_type | Server_id | End_log_pos | Info \n| mysql-bin.000003 | 2005 | Gtid | 1013307 | 2070 | SET @@SESSION.GTID_NEXT= 'f971d5f1-d450-11ec-9e7b-5254000a56df:11' |\n| mysql-bin.000003 | 2070 | Query | 1013307 | 2142 | BEGIN |\n| mysql-bin.000003 | 2142 | Table_map | 1013307 | 2187 | table_id: 109 (test.t1) |\n| mysql-bin.000003 | 2187 | Write_rows | 1013307 | 2227 | table_id: 109 flags: STMT_END_F |\n| mysql-bin.000003 | 2227 | Xid | 1013307 | 2258 | COMMIT /* xid=121 */\n```\n\n\n它不仅用于主从复制中事务完整性的判断，也在崩溃恢复中对 redo log 和 binlog 的一致性校验起到关键作用。\n\nXID 可以帮助 MySQL 判断哪些 redo log 是已提交的，哪些是未提交需要回滚的，是两阶段提交机制中非常关键的一环。"
+ },
+ {
+ "id": 366,
+ "question": "redo log 的写入过程了解吗？",
+ "answer": "InnoDB 会先将 Redo Log 写入内存中的 Redo Log Buffer，之后再以一定的频率刷入到磁盘的 Redo Log File 中。\n\n\n\n#### [哪些场景会触发 redo log 的刷盘动作？](#哪些场景会触发-redo-log-的刷盘动作)\n\n比如说 Redo Log Buffer 的空间不足时，事务提交时，触发 Checkpoint 时，后台线程定期刷盘时。\n\n不过，Redo Log Buffer 刷盘到 Redo Log File 还会涉及到操作系统的磁盘缓存策略，可能不会立即刷盘，而是等待一定时间后才刷盘。\n\n\n\n#### [innodb\\_flush\\_log\\_at\\_trx\\_commit 参数你了解多少？](#innodb-flush-log-at-trx-commit-参数你了解多少)\n\ninnodb\\_flush\\_log\\_at\\_trx\\_commit 参数是用来控制事务提交时，Redo Log 的刷盘策略，一共有三种。\n\n\n\n0 表示事务提交时不刷盘，而是交给后台线程每隔 1 秒执行一次。这种方式性能最好，但是在 MySQL 宕机时可能会丢失一秒内的事务。\n\n1 表示事务提交时会立即刷盘，确保事务提交后数据就持久化到磁盘。这种方式是最安全的，也是 InnoDB 的默认值。\n\n\n\n2 表示事务提交时只把 Redo Log Buffer 写入到 Page Cache，由操作系统决定什么时候刷盘。操作系统宕机时，可能会丢失一部分数据。\n\n#### [一个没有提交事务的 redo log，会不会刷盘？](#一个没有提交事务的-redo-log-会不会刷盘)\n\nInnoDB 有一个后台线程，每隔 1 秒会把 Redo Log Buffer 中的日志写入到文件系统的缓存中，然后调用刷盘操作。\n\n\n\n因此，一个没有提交事务的 Redo Log 也可能会被刷新到磁盘中。\n\n另外，如果当 Redo Log Buffer 占用的空间即将达到 innodb\\_log\\_buffer\\_size 的一半时，也会触发刷盘操作。"
+ }
+ ]
+ },
+ {
+ "id": 55,
+ "categoryName": "SQL 优化",
+ "questions": [
+ {
+ "id": 367,
+ "question": "什么是慢 SQL？",
+ "answer": "MySQL 中有一个叫 long\\_query\\_time 的参数，原则上执行时间超过该参数值的 SQL 就是慢 SQL，会被记录到慢查询日志中。\n\n----这部分是帮助大家理解 start，面试中可不背----\n\n可通过 `show variables like 'long_query_time';` 查看当前的 long\\_query\\_time 的参数值。\n\n\n\n----这部分是帮助大家理解 end，面试中可不背----\n\n#### [SQL 的执行过程了解吗？](#sql-的执行过程了解吗)\n\n了解。\n\nSQL 的执行过程大致可以分为六个阶段：连接管理、语法解析、语义分析、查询优化、执行器调度、存储引擎读写等。Server 层负责理解和规划 SQL 怎么执行，存储引擎层负责数据的真正读写。\n\n\n\n----这部分是帮助大家理解 start，面试中可不背----\n\n来详细拆解一下：\n\n1. 客户端发送 SQL 语句给 MySQL 服务器。\n2. 如果查询缓存打开则会优先查询缓存，缓存中有对应的结果就直接返回。不过，MySQL 8.0 已经移除了查询缓存。这部分的功能正在被 Redis 等缓存中间件取代。\n3. 分析器对 SQL 语句进行语法分析，判断是否有语法错误。\n4. 搞清楚 SQL 语句要干嘛后，MySQL 会通过优化器生成执行计划。\n5. 执行器调用存储引擎的接口，执行 SQL 语句。\n\nSQL 执行过程中，优化器通过成本计算预估出执行效率最高的方式，基本的预估维度为：\n\n* IO 成本：从磁盘读取数据到内存的开销。\n* CPU 成本：CPU 处理内存中数据的开销。\n\n基于这两个维度，可以得出影响 SQL 执行效率的因素有：\n\n**①、IO 成本**，数据量越大，IO 成本越高。所以要尽量查询必要的字段；尽量分页查询；尽量通过索引加快查询。\n\n**②、CPU 成本**，尽量避免复杂的查询条件，如有必要，考虑对子查询结果进行过滤。\n\n----这部分是帮助大家理解 end，面试中可不背----\n\n#### [如何优化慢 SQL 呢？](#如何优化慢-sql-呢)\n\n首先，需要找到那些比较慢的 SQL，可以通过启用慢查询日志，记录那些超过指定执行时间的 SQL 查询。\n\n也可以使用 `show processlist;` 命令查看当前正在执行的 SQL 语句，找出执行时间较长的 SQL。\n\n\n\n或者在业务基建中加入对慢 SQL 的监控，常见的方案有字节码插桩、连接池扩展、ORM 框架扩展等。\n\n\n\n然后，使用 EXPLAIN 查看慢 SQL 的执行计划，看看有没有用索引，大部分情况下，慢 SQL 的原因都是因为没有用到索引。\n\n\n```sql\nEXPLAIN SELECT * FROM your_table WHERE conditions;\n```\n\n\n最后，根据分析结果，通过添加索引、优化查询条件、减少返回字段等方式进行优化。\n\n#### [慢sql日志怎么开启？](#慢sql日志怎么开启)\n\n编辑 MySQL 的配置文件 my.cnf，设置 slow\\_query\\_log 参数为 1。\n\n\n```ini\n[mysqld]\nslow_query_log = 1\nslow_query_log_file = /var/log/mysql/slow.log\nlong_query_time = 2 # 记录执行时间超过2秒的查询\n```\n\n\n然后重启 MySQL 就好了。\n\n也可以通过 set global 命令动态设置。\n\n\n```sql\nSET GLOBAL slow_query_log = 'ON';\nSET GLOBAL slow_query_log_file = '/var/log/mysql/slow.log';\nSET GLOBAL long_query_time = 2;\n```"
+ },
+ {
+ "id": 368,
+ "question": "你知道哪些方法来优化 SQL？",
+ "answer": "SQL 优化的方法非常多，但本质上就一句话：尽可能少地扫描、尽快地返回结果。\n\n最常见的做法就是加索引、改写 SQL 让它用上索引，比如说使用覆盖索引、让联合索引遵守最左前缀原则等。\n\n\n\n#### [如何利用覆盖索引？](#如何利用覆盖索引)\n\n覆盖索引的核心是“查询所需的字段都在同一个索引里”，这样 MySQL 就不需要回表，直接从索引中返回结果。\n\n\n\n实际使用中，我会优先考虑把 WHERE 和 SELECT 涉及的字段一起建联合索引，并通过 EXPLAIN 观察结果是否有 Using index，确认命中索引。\n\n----这部分是帮助大家理解 start，面试中可不背----\n\n举个例子，现在要从 test 表中查询 city 为上海的 name 字段。\n\n\n```sql\nselect name from test where city='上海'\n```\n\n\n如果仅在 city 字段上添加索引，那么这条查询语句会先通过索引找到 city 为上海的行，然后再回表查询 name 字段。\n\n为了避免回表查询，可以在 city 和 name 字段上建立联合索引，这样查询结果就可以直接从索引中获取。\n\n\n```sql\nalter table test add index index1(city,name);\n```\n\n\n----这部分是帮助大家理解 end，面试中可不背----\n\n#### [如何正确使用联合索引？](#如何正确使用联合索引)\n\n使用联合索引最重要的一条是遵守最左前缀原则，也就是查询条件需要从索引的左侧字段开始。\n\n----这部分是帮助大家理解 start，面试中可不背----\n\n比如说我们创建了一个三列的联合索引。\n\n\n```sql\nCREATE INDEX idx_name_age_sex ON user(name, age, sex);\n```\n\n\n我们来看一下什么样的查询条件可以用到这个索引：\n\n| 查询条件 | 能否用上 idx\\_name\\_age\\_sex？ | 说明 |\n| --- | --- | --- |\n| WHERE name = 'itwanger' | ✅ 可以 | 匹配第一列，命中索引 |\n| WHERE name = 'itwanger' AND age=20 | ✅ 可以 | 匹配前两列，命中索引 |\n| WHERE age = 20 | ❌ 不行 | 第一列没用上，索引失效 |\n| WHERE name='itwanger' AND sex='女' | ✅ 部分可用（只用前一列） | age 被跳过，后面的列无法使用 |\n| WHERE name LIKE 'it%' | ✅ 可以（前缀匹配） | name 是前缀匹配，不影响使用 |\n| WHERE name LIKE '%wanger%' | ❌ 不行 | 通配符在前，不能用索引 |\n\n----这部分是帮助大家理解 end，面试中可不背----\n\n#### [如何进行分页优化？](#如何进行分页优化)\n\n分页优化的核心是避免深度偏移带来的全表扫描，可以通过两种方式来优化：延迟关联和添加书签。\n\n延迟关联适用于需要从多个表中获取数据且主表行数较多的情况。它首先从索引表中检索出需要的行 ID，然后再根据这些 ID 去关联其他的表获取详细信息。\n\n\n```sql\nSELECT e.id, e.name, d.details\nFROM employees e\nJOIN department d ON e.department_id = d.id\nORDER BY e.id\nLIMIT 1000, 20;\n```\n\n\n延迟关联后，第一步只查主键，速度快，第二步只处理 20 条数据，效率高。\n\n\n```sql\nSELECT e.id, e.name, d.details\nFROM (\n SELECT id\n FROM employees\n ORDER BY id\n LIMIT 1000, 20\n) AS sub\nJOIN employees e ON sub.id = e.id\nJOIN department d ON e.department_id = d.id;\n```\n\n\n添加书签的方式是通过记住上一次查询返回的最后一行主键值，然后在下一次查询的时候从这个值开始，从而跳过偏移量计算，仅扫描目标数据，适合翻页、资讯流等场景。\n\n假设需要对用户表进行分页。\n\n\n```sql\nSELECT id, name\nFROM users\nORDER BY id\nLIMIT 1000, 20;\n```\n\n\n通过添加书签来优化后，查询不再使用`OFFSET`，而是从上一页最后一个用户的 ID 开始查询。这种方法可以有效避免不必要的数据扫描，提高了分页查询的效率。\n\n\n```sql\nSELECT id, name\nFROM users\nWHERE id > last_max_id -- 假设last_max_id是上一页最后一行的ID\nORDER BY id\nLIMIT 20;\n```\n\n\n#### [为什么分页会变慢？](#为什么分页会变慢)\n\n分页查询的效率问题主要是由于 OFFSET 的存在，OFFSET 会导致 MySQL 必须扫描和跳过 offset + limit 条数据，这个过程是非常耗时的。\n\n比如说，我们要查询第 100000 条数据，那么 MySQL 就必须扫描 100000 条数据，然后再返回 10 条数据。\n\n\n```sql\nSELECT * FROM user ORDER BY id LIMIT 100000, 10;\n```\n\n\n数据越多、偏移越大，就越慢！"
+ },
+ {
+ "id": 369,
+ "question": "explain平常有用过吗？",
+ "answer": "经常用，explain 是 MySQL 提供的一个用于查看 SQL 执行计划的工具，可以帮助我们分析查询语句的性能问题。\n\n一共有 10 来个输出参数。\n\n\n\n比如说 `type=ALL,key=NULL` 表示 SQL 正在全表扫描，可以考虑为 where 字段添加索引进行优化；`Extra=Using filesort` 表示 SQL 正在文件排序，可以考虑为 order by 字段添加索引。\n\n使用方式也非常简单，直接在 select 前加上 `explain` 关键字就可以了。\n\n\n```sql\nexplain select * from students where name='练习伴侣二';\n```\n\n\n更高级的用法可以配合 `format=json` 参数，将 explain 的输出结果以 JSON 格式返回。\n\n\n```sql\nexplain format=json select * from students where name='练习伴侣二';\n```\n\n\n#### [explain 输出结果中常见的字段含义理解吗？](#explain-输出结果中常见的字段含义理解吗)\n\n在 EXPLAIN 输出结果中我最关注的字段是 type、key、rows 和 Extra。\n\n我会通过它们判断 SQL 有没有走索引、是否全表扫描、预估扫描行数是否太大，以及是否触发了 filesort 或临时表。一旦发现问题，比如 type=ALL 或者 Extra=Using filesort，我会考虑建索引、改写 SQL 或控制查询结果集来做优化。\n\n----这部分是帮助大家理解 start，面试中可不背----\n\n以 `EXPLAIN SELECT * FROM orders WHERE user_id = 100` 的输出为例：\n\n| 字段 | 值 | 含义与优化指导 |\n| --- | --- | --- |\n| id | 1 | 查询序列号。 |\n| select\\_type | SIMPLE | 简单查询（无子查询或 UNION）。复杂场景还有 PRIMARY、SUBQUERY、DERIVED 等。 |\n| table | orders | 当前步骤操作的表名。 |\n| partitions | NULL | 涉及的分区。 |\n| type | ref | 访问类型：关键性能指标，常见类型： - system/const：唯一值匹配（性能最佳） - eq\\_ref：主键/唯一索引连接 - ref：非唯一索引匹配 - range：索引范围扫描 - index：全索引扫描 - ALL：全表扫描（需优化） |\n| possible\\_keys | idx\\_user\\_id | 可能使用的索引。若为空，说明无合适索引。 |\n| key | idx\\_user\\_id | 实际选择的索引。若为 NULL，表示未使用索引。 |\n| key\\_len | 4 | 索引使用的字节数，可判断是否使用完整索引。例如，联合索引 (a,b)，若 key\\_len=4 可能只用到了 a 列。 |\n| ref | const | 与索引比较的列或常量（如 WHERE user\\_id=100 中的 100）。 |\n| rows | 50 | 预估扫描行数。数值越小越好，若与实际差距大，可能统计信息过期（需 ANALYZE TABLE）。 |\n| filtered | 100.00 | 查询条件过滤后剩余行的百分比。例如 rows=1000 且 filtered=10%，则最终返回约 100 行。 |\n| Extra | Using where | 附加信息： - Using index：覆盖索引（无需回表） - Using temporary：使用临时表 - Using filesort：文件排序 |\n\n非表格版本：\n\n①、**id** 列：查询的执行顺序编号。id 相同：同一执行层级，按 table 列从上到下顺序执行（如多表 JOIN）；id 递增：嵌套子查询，数值越大优先级越高，越先执行。\n\n\n```sql\nEXPLAIN SELECT * FROM t1 JOIN (SELECT * FROM t2 WHERE id = 1) AS sub;\n```\n\n\nt2 子查询的 id=2，优先执行。\n\n②、**select\\_type** 列：查询的类型。常见的类型有：\n\n* SIMPLE：简单查询，不包含子查询或者 UNION。\n* PRIMARY：查询中如果包含子查询，则最外层查询被标记为 PRIMARY。需要关注子查询或派生表性能。\n* SUBQUERY：子查询；需要避免多层嵌套，尽量改写为 JOIN。\n* DERIVED：派生表（FROM 子句中的子查询）。需要减少派生表数据量，或物化为临时表。\n\n③、**table** 列：查的哪个表。\n\n* derivedN：表示派生表（N 对应 id）。\n* unionNM,N：表示 UNION 合并的结果（M、N 为参与 UNION 的 id）。\n\n④、**type** 列：表示 MySQL 在表中找到所需行的方式。\n\n* system，表仅有一行（系统表或衍生表），无需优化。\n* const：通过主键或唯一索引找到一行（如 WHERE id = 1）。理想情况。\n* eq\\_ref：对主键/唯一索引 JOIN 匹配（如 `A JOIN B ON A.id = B.id`）。确保 JOIN 字段有索引。\n* ref：非唯一索引匹配（如 `WHERE name = '练习伴侣二'`，name 有普通索引）。\n* range：只检索给定范围的行，使用索引来检索。在`where`语句中使用 `bettween...and`、`<`、`>`、`<=`、`in` 等条件查询 `type` 都是 `range`。\n* index：全索引扫描，如果不需要回表，可接受；否则考虑覆盖索引。\n* ALL：全表扫描，效率最低。\n\n⑤、**possible\\_keys** 列：可能会用到的索引，但并不一定实际被使用。\n\n⑥、**key** 列：实际使用的索引。如果为 NULL，则没有使用索引。如果为 PRIMARY，则使用了主键索引。\n\n⑦、**key\\_len** 列：使用的索引字节数，反映索引列的利用率。使用联合索引 (a, b)，key\\_len 是 a 和 b 的字节总和（仅当查询条件用到 a 或 a+b 时有效）。\n\n\n```sql\n-- 表结构：CREATE TABLE t (a INT, b VARCHAR(20), INDEX idx_a_b (a, b));\nEXPLAIN SELECT * FROM t WHERE a = 1 AND b = 'test';\n```\n\n\nkey\\_len = 4（INT） + 20\\*3（utf8） + 2 = 66 字节。\n\n⑧、**ref** 列：与索引列比较的值或列。\n\n* const：常量。例如 WHERE `column = 'value'`。\n* func：函数。例如 WHERE `column = func(column)`。\n\n⑨、**rows** 列：优化器估算的需要扫描的行数。数值越小越好，若与实际差距大，可能统计信息过期（需 ANALYZE TABLE）。结合 filtered 字段可以计算最终返回行数（rows × filtered）。\n\n⑩、**Extra** 列：附加信息。\n\n* Using index：覆盖索引，无需回表。\n* Using where：存储引擎返回结果后，Server 层需要再次过滤（条件未完全下推）。\n* Using temporary ：使用临时表（常见于 GROUP BY、DISTINCT）。\n* Using filesort：文件排序（常见于 ORDER BY）。考虑为 ORDER BY 字段添加索引。\n* Select tables optimized away：优化器已优化（如 COUNT(\\*) 通过索引直接统计）。\n* Using join buffer：使用连接缓冲区（Block Nested Loop 或 Hash Join）。考虑增大 join\\_buffer\\_size。\n\n示例：\n\n\n\n----这部分是帮助大家理解 end，面试中可不背----\n\n#### [type的执行效率等级，达到什么级别比较合适？](#type的执行效率等级-达到什么级别比较合适)\n\n从高到低的效率排序是 system、const、eq\\_ref、ref、range、index 和 ALL。\n\n一般情况下，建议 type 值达到 const、eq\\_ref 或 ref，因为这些类型表明查询使用了索引，效率较高。\n\n如果是范围查询，range 类型也是可以接受的。\n\nALL 类型表示全表扫描，性能最差，往往不可接受，需要优化。"
+ }
+ ]
+ },
+ {
+ "id": 56,
+ "categoryName": "索引",
+ "questions": [
+ {
+ "id": 370,
+ "question": "索引为什么能提高MySQL查询效率？",
+ "answer": "索引就像一本书的目录，能让 MySQL 快速定位数据，避免全表扫描。\n\n\n\n它一般是 B+ 树结构，查找效率是 O(log n)，比从头到尾扫一遍数据要快得多。\n\n\n\n除了查得快，索引还能加速排序、分组、连接等操作。\n\n可以通过 `create index` 创建索引，比如：\n\n\n```sql\ncreate index idx_name on students(name);\n```\n\n\n----这部分是帮助大家理解 start，面试中可不背----\n\n我们通过 wrap 的 agent 验证一下有没有索引的查询效率。\n\n先上结果，有索引的查询时间是 0.007 秒，没有索引的查询时间是 0.036 秒。\n\n\n\n创建数据库和表。\n\n\n\n插入 10 万条数据。\n\n\n\n然后依次执行 explain 查看没有索引和有索引时的执行计划。\n\n\n\n----这部分是帮助大家理解 end，面试中可不背----"
+ },
+ {
+ "id": 371,
+ "question": "能简单说一下索引的分类吗？",
+ "answer": "从功能上分类的话，有主键索引、唯一索引、全文索引；从数据结构上分类的话，有 B+ 树索引、哈希索引；从存储内容上分类的话，有聚簇索引、非聚簇索引。\n\n\n\n#### [你对主键索引了解多少？](#你对主键索引了解多少)\n\n主键索引用于唯一标识表中的每条记录，其列值必须唯一且非空。创建主键时，MySQL 会自动生成对应的唯一索引。\n\n\n\n每个表只能有一个主键索引，一般是表中的自增 id 字段。\n\n\n```sql\nCREATE TABLE emp6 (emp_id INT PRIMARY KEY, name VARCHAR(50)); -- 单列主键\nCREATE TABLE CountryLanguage (\n CountryCode CHAR(3),\n Language VARCHAR(30),\n PRIMARY KEY (CountryCode, Language) -- 复合主键\n);\n```\n\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n如果创建表的时候没有指定主键，MySQL 的 InnoDB 存储引擎会优先选择一个非空的唯一索引作为主键；如果没有符合条件的索引，MySQL 会自动生成一个隐藏的 \\_rowid 列作为主键。\n\n\n\n可以通过 `show index from table_name` 查看索引信息：\n\n\n\n* `Table` 当前索引所属的表名。\n* `Non_unique` 是否唯一索引，0 表示唯一索引（如主键），1 表示非唯一。\n* `Key_name` 主键索引默认叫 PRIMARY；普通索引为自定义名。\n* `Seq_in_index` 索引中的列顺序，在联合索引中这个字段表示第几列（第 1 个）。\n* `Column_name` 当前索引中包含的字段名。\n* `Collation` A 表示升序（Ascend）；D 表示降序。\n* `Cardinality` 索引的基数，即不重复的索引值的数量。越高说明区分度越好（影响优化器是否用此索引）。\n* `Sub_part` 前缀索引的长度。\n* `Packed` 是否压缩存储索引；一般不用，默认为 NULL。\n* `Null` 字段是否允许为 NULL；主键字段不允许为 NULL。\n* `Index_type` 索引底层结构，InnoDB 默认是 B+ 树（BTREE）。\n* `Comment` 索引的注释。\n* `Visible` 是否可见；MySQL 8.0+ 可隐藏索引。\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----\n\n#### [唯一索引和主键索引有什么区别？](#唯一索引和主键索引有什么区别)\n\n主键索引=唯一索引+非空。每个表只能有一个主键索引，但可以有多个唯一索引。\n\n\n```sql\n-- 在 email 列上添加唯一索引\nCREATE TABLE users (\n id INT AUTO_INCREMENT PRIMARY KEY,\n username VARCHAR(50) NOT NULL,\n email VARCHAR(100) NOT NULL,\n UNIQUE KEY uk_email (email) -- 唯一索引\n);\n\n-- 复合唯一索引（保证 user_id 和 role 组合唯一）\nCREATE TABLE user_roles (\n user_id INT NOT NULL,\n role VARCHAR(20) NOT NULL,\n UNIQUE KEY uk_user_role (user_id, role)\n);\n```\n\n\n主键索引不允许插入 NULL 值，尝试插入 NULL 会报错；唯一索引允许插入多个 NULL 值。\n\n\n\n#### [unique key 和 unique index 有什么区别？](#unique-key-和-unique-index-有什么区别)\n\n创建唯一键时，MySQL 会自动生成一个同名的唯一索引；反之，创建唯一索引也会隐式添加唯一性约束。\n\n可通过 UNIQUE KEY uk\\_name 定义或者 CONSTRAINT uk\\_name UNIQUE 定义唯一键。\n\n\n```sql\nCREATE TABLE users (\n id INT PRIMARY KEY,\n email VARCHAR(100),\n -- 显式命名唯一键\n CONSTRAINT uk_email UNIQUE (email)\n);\n\nCREATE TABLE users3 (\n id INT PRIMARY KEY,\n email VARCHAR(100),\n UNIQUE KEY uk_email (email) -- 唯一索引\n);\n```\n\n\n可通过 CREATE UNIQUE INDEX 创建唯一索引。\n\n\n```sql\nCREATE TABLE users (\n id INT PRIMARY KEY,\n email VARCHAR(100)\n);\n\n-- 手动创建唯一索引\nCREATE UNIQUE INDEX uk_email ON users(email);\n```\n\n\n通过 `SHOW CREATE TABLE table_name` 查看表结构时，结果都是一样的。\n\n\n\n#### [普通索引和唯一索引有什么区别？](#普通索引和唯一索引有什么区别)\n\n普通索引仅用于加速查询，不限制字段值的唯一性；适用于高频写入的字段、范围查询的字段。\n\n\n```sql\n-- 日志时间戳允许重复，无需唯一性检查\nCREATE INDEX idx_log_time ON access_logs(access_time);\n\n-- 订单状态允许重复，但需频繁按状态过滤数据\nCREATE INDEX idx_order_status ON orders(status);\n```\n\n\n唯一索引强制字段值的唯一性，插入或更新时会触发唯一性检查；适用于业务唯一性约束的字段、防止数据重复插入的字段。\n\n\n```sql\n-- 用户邮箱必须唯一\nCREATE UNIQUE INDEX uk_email ON users(email);\n\n-- 确保同一用户对同一商品只能有一条未支付订单\nCREATE UNIQUE INDEX uk_user_product ON orders(user_id, product_id) WHERE status = 'unpaid';\n```"
+ },
+ {
+ "id": 372,
+ "question": "创建索引有哪些注意点？",
+ "answer": "第一，选择合适的字段\n\n* 比如说频繁出现在 WHERE、JOIN、ORDER BY、GROUP BY 中的字段。\n* 优先选择区分度高的字段，比如用户 ID、手机号等唯一值多的，而不是性别、状态等区分度极低的字段，如果真的需要，可以考虑联合索引。\n\n第二，要控制索引的数量，避免过度索引，每个索引都要占用存储空间，单表的索引数量不建议超过 5 个。\n\n要定期通过 `SHOW INDEX FROM table_name` 查看索引的使用情况，删除不必要的索引。比如说已经有联合索引 (a, b)，单索引（a）就是冗余的。\n\n第三，联合索引的时候要遵循最左前缀原则，即在查询条件中使用联合索引的第一个字段，才能充分利用索引。\n\n比如说联合索引 `(A, B, C)` 可支持 `A、A+B、A+B+C` 的查询，但无法支持 B 或 C 的单独查询。\n\n区分度高的字段放在左侧，等值查询的字段优先于范围查询的字段。例如 `WHERE A=1 AND B>10 AND C=2`，优先 `(A, C, B)`。\n\n如果联合索引包含查询的所需字段，还可以避免回表，提高查询效率。"
+ },
+ {
+ "id": 373,
+ "question": "索引哪些情况下会失效呢？",
+ "answer": "简版：比如索引列使用了函数、使用了通配符开头的模糊查询、联合索引不满足最左前缀原则，或者使用 or 的时候部分字段无索引等。\n\n第一，对索引列使用函数或表达式会导致索引失效。\n\n\n```sql\n-- 索引失效\nSELECT * FROM users WHERE YEAR(create_time) = 2023;\nSELECT * FROM products WHERE price*2 > 100;\n\n-- 优化方案（使用范围查询）\nSELECT * FROM users WHERE create_time BETWEEN '2023-01-01' AND '2023-12-31';\nSELECT * FROM products WHERE price > 50;\n```\n\n\n第二，LIKE 模糊查询以通配符开头会导致索引失效。\n\n\n```sql\n-- 索引失效\nSELECT * FROM articles WHERE title LIKE '%数据库%';\n\n-- 可以使用索引（但范围有限）\nSELECT * FROM articles WHERE title LIKE '数据库%';\n\n-- 解决方案：考虑全文索引或搜索引擎\nSELECT * FROM articles WHERE MATCH(title) AGAINST('数据库');\n```\n\n\n第三，联合索引违反了最左前缀原则，索引会失效。\n\n\n```sql\n-- 假设有联合索引 (a, b, c)\nSELECT * FROM table WHERE b = 2 AND c = 3; -- 索引失效\nSELECT * FROM table WHERE a = 1 AND c = 3; -- 只使用a列索引\n\n-- 正确使用联合索引\nSELECT * FROM table WHERE a = 1 AND b = 2 AND c = 3;\n```\n\n\n* 联合索引，但 WHERE 不满足最左前缀原则，索引无法起效。例如：`SELECT * FROM table WHERE column2 = 2`，联合索引为 `(column1, column2)`。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n第四，使用 OR 连接非索引列条件，会导致索引失效。\n\n\n```sql\n-- 假设name有索引但age没有\nSELECT * FROM users WHERE name = '张三' OR age = 25; -- 全表扫描\n\n-- 优化方案1：使用UNION ALL\nSELECT * FROM users WHERE name = '张三'\nUNION ALL\nSELECT * FROM users WHERE age = 25 AND name != '张三';\n\n-- 优化方案2：考虑为age添加索引\n```\n\n\n第五，使用 `!=` 或 `<>` 不等值查询会导致索引失效。\n\n\n```sql\nSELECT * FROM user WHERE status != 1; -- 若大部分行 `status=1`，可能全表扫描\n\n-- 优化方案：使用范围查询\nSELECT * FROM user WHERE status < 1 OR status > 1;\n```\n\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----\n\n#### [什么情况下模糊查询不走索引？](#什么情况下模糊查询不走索引)\n\n模糊查询主要使用 LIKE 语句，结合通配符来实现。\n\n> %（代表任意多个字符）和 \\_（代表单个字符）\n\n\n```sql\nSELECT * FROM table WHERE column LIKE '%xxx%';\n```\n\n\n这个查询会返回所有 column 列中包含 xxx 的记录。\n\n但是，如果模糊查询的通配符 % 出现在搜索字符串的开始位置，如 `LIKE '%xxx'`，MySQL 将无法使用索引，因为数据库必须扫描全表以匹配任意位置的字符串。"
+ },
+ {
+ "id": 374,
+ "question": "索引不适合哪些场景呢？",
+ "answer": "第一，区分度低的列，可以和其他高区分度的列组成联合索引。\n\n第二，频繁更新的列，索引会增加更新的成本。\n\n第三，TEXT、BLOB 等大对象类型的字段，可以使用前缀索引、全文索引替代。\n\n第四，当表的数据量很小的时候，不超过 1000 行，全表扫描可能比使用索引更快。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n为了验证第四条，我们创建了一个小表，然后分别执行全表扫描和索引查询。\n\n\n\n得出的结论的确是这样的，全表扫描更快一些。\n\n\n\n原因时当数据量很小时，全表扫描的成本很低，因为所有的数据可能都加载到内存中了，使用索引反而需要先查找索引，再通过索引去找到实际的数据行，增加了额外的 I/O 寻址时间。\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----\n\n#### [性别字段要建立索引吗？](#性别字段要建立索引吗)\n\n性别字段不适合建立单独索引。因为性别字段的区分度很低。\n\n如果性别字段确实经常用于查询条件，数据规模也比较大，可以将性别字段作为联合索引的一部分，与区分度高的字段一起，效果会好很多。\n\n#### [什么是区分度？](#什么是区分度)\n\n区分度是衡量一个字段在 MySQL 表中唯一值的比例。\n\n区分度 = 字段的唯一值数量 / 字段的总记录数；越接近 1，就越适合作为索引。因为索引可以更有效地缩小查询范围。\n\n例如，一个表中有 1000 条记录，其中性别字段只有两个值（男、女），那么性别字段的区分度只有 0.002，就不适合建立索引。\n\n可以通过 `COUNT(DISTINCT column_name)` 和 `COUNT(*)` 的比值来计算字段的区分度。例如：\n\n\n```sql\nSELECT \n COUNT(DISTINCT gender) / COUNT(*) AS gender_selectivity\nFROM \n users;\n```\n\n\n#### [什么样的字段适合加索引？](#什么样的字段适合加索引)\n\n一句话回答：\n\n一般来说，主键、唯一键、以及经常作为查询条件的字段最适合加索引。除此之外，字段的区分度要高，这样索引才能起到过滤作用；如果字段经常用于表连接、排序或分组，也建议加索引。同时如果多个字段经常一起出现在查询条件中，也可以建立联合索引来提升性能。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n查询条件中的高频字段，比如说WHERE子句中频繁用于等值查询、范围查询或者 IN 列表的字段。\n\n\n```sql\nSELECT * FROM orders WHERE status = 'PAID' AND create_time > '2023-01-01';\n-- 若`status`和`create_time`常组合查询，建联合索引`(status, create_time)`\n```\n\n\n多表连接时的关联字段，比如说 user.id 和 order.user\\_id。\n\n\n```sql\nSELECT * FROM user u JOIN order o ON u.id = o.user_id; -- `user_id`需索引\n```\n\n\n参与排序或者分组的字段，可以直接利用索引的有序性，避免文件排序。\n\n\n```sql\nSELECT * FROM product ORDER BY price DESC; -- 单字段排序\nSELECT category, COUNT(*) FROM product GROUP BY category; -- 分组统计\n```\n\n\n需要利用覆盖索引的字段，可以避免回表操作。\n\n\n```sql\n-- 创建联合索引`(user_id, create_time)`\nSELECT user_id, create_time FROM orders WHERE user_id = 100; -- 覆盖索引生效\n```\n\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----"
+ },
+ {
+ "id": 375,
+ "question": "索引是不是建的越多越好？",
+ "answer": "索引不是越多越好。虽然索引可以加快查询，但也会带来写入变慢、占用更多存储空间、甚至让优化器选错索引的风险。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n每次数据写入（INSERT/UPDATE/DELETE）时，MySQL 都需同步更新所有相关索引，索引越多，维护成本越高。\n\n假如某表有 10 个索引，插入一行数据需更新 10 个 B+树结构，导致写入延迟增加 5~10 倍。\n\n假如某表数据量 100GB，若建 5 个索引，总存储可能达到 200GB+。\n\n索引过多时，优化器需评估更多可能的执行路径，可能导致选择困难症，优化器也会选错索引。\n\n再比如说，已有联合索引 (A, B, C)，再单独建 (A) 或 (A, B) 索引即为冗余。\n\n单表索引数量建议不超过 5 个，MySQL 官方建议单表索引总字段数 ≤ 表字段数的 30%。\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----\n\n#### [说说索引优化的思路？](#说说索引优化的思路)\n\n一句话回答：\n\n先通过慢查询日志找出性能瓶颈，然后用 EXPLAIN 分析执行计划，判断是否走了索引、是否回表、是否排序。接着根据字段特性设计合适的索引，如选择区分度高的字段，使用联合索引和覆盖索引，避免索引失效的写法，最后通过实测来验证优化效果。"
+ },
+ {
+ "id": 376,
+ "question": "为什么 InnoDB 要使用 B+树作为索引？",
+ "answer": "一句话总结：\n\n因为 B+ 树是一种高度平衡的多路查找树，能有效降低磁盘的 IO 次数，并且支持有序遍历和范围查询。\n\n\n\n查询性能非常高，其结构也适合 MySQL 按照页为单位在磁盘上存储。\n\n像其他选项，比如说哈希表不支持范围查询，二叉树层级太深，B 树又不方便范围扫描，所以最终选择了 B+ 树。\n\n再换一种回答：\n\n* 相比哈希表：B+ 树支持范围查询和排序\n* 相比二叉树和红黑树：B+ 树更“矮胖”，层级更少，磁盘 IO 次数更少\n* 相比 B 树：B+ 树的非叶子节点只存储键值，叶子节点存储数据并通过链表连接，支持范围查询\n\n另外一种回答版本：\n\nB+树是一种自平衡的多路查找树，和红黑树、二叉平衡树不同，B+树的每个节点可以有 m 个子节点，而红黑树和二叉平衡树都只有 2 个。\n\n\n\n另外，和 B 树不同，B+树的非叶子节点只存储键值，不存储数据，而叶子节点存储了所有的数据，并且构成了一个有序链表。\n\n这样做的好处是，非叶子节点上由于没有存储数据，就可以存储更多的键值对，再加上叶子节点构成了一个有序链表，范围查询时就可以直接通过叶子节点间的指针顺序访问整个查询范围内的所有记录，而无需对树进行多次遍历。查询的效率比 B 树更高。\n\n\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n先说说 B 树。\n\nB 树是一种自平衡的多路查找树，和红黑树、二叉平衡树不同，B 树的每个节点可以有 m 个子节点，而红黑树和二叉平衡树都只有 2 个。\n\n换句话说，红黑树、二叉平衡树是细高个，而 B 树是矮胖子。\n\n\n\n再来说说内存和磁盘的 IO 读写。\n\n\n\n为了提高读写效率，从磁盘往内存中读数据的时候，一次会读取至少一页的数据，如果不满一页，会再多读点。\n\n比如说查询只需要读取 2KB 的数据，但 MySQL 实际上会读取 4KB 的数据，以装满整页。页是 MySQL 进行内存和磁盘交互的最小逻辑单元。\n\n再比如说需要读取 5KB 的数据，实际上 MySQL 会读取 8KB 的数据，刚好两页。\n\n因为读的次数越多，效率就越低。就好比我们在工地上搬砖，一次搬 10 块砖肯定比一次搬 1 块砖的效率要高，反正我每次都搬 10 块（😁）。\n\n对于红黑树、二叉平衡树这种细高个来说，每次搬的砖少，因为力气不够嘛，那来回跑的次数就越多。\n\n> 通常 B+ 树高度为 3-4 层即可支持 TB 级数据，而每次查询只需 2-4 次磁盘 I/O，远低于二叉树或红黑树的 O(log2N) 复杂度\n\n树越高，意味着查找数据时就需要更多的磁盘 IO，因为每一层都可能需要从磁盘加载新的节点。\n\n\n\nB 树的节点通常与页的大小对齐，这样每次从磁盘加载一个节点时，正好就是一页的大小。\n\n\n\nB 树的一个节点通常包括三个部分：\n\n* 键值：即表中的主键\n* 指针：存储子节点的信息\n* 数据：除主键外的行数据\n\n正所谓“祸兮福所倚，福兮祸所伏”，因为 B 树的每个节点上都存储了数据，就导致每个节点能存储的键值和指针变少了，因为每一个节点的大小是固定的，对吧？\n\n于是 B+树就来了，B+树的非叶子节点只存储键值，不存储数据，而叶子节点会存储所有的行数据，并且构成一个有序链表。\n\n\n\n这样做的好处是，非叶子节点由于没有存储数据，就可以存储更多的键值对，树就变得更加矮胖了，于是就更有劲了，每次搬的砖也就更多了（😂）。\n\n> 相比 B 树，B+ 树的非叶子节点可容纳的键值更多，一个 16KB 的节点可存储约 1200 个键值，大幅降低树的高度。\n\n由此一来，查找数据进行的磁盘 IO 就更少了，查询的效率也就更高了。\n\n再加上叶子节点构成了一个有序链表，范围查询时就可以直接通过叶子节点间的指针顺序访问整个查询范围内的所有记录，而无需对树进行多次遍历。\n\nB 树就做不到这一点。\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----\n\n#### [B+树的叶子节点是单向链表还是双向链表？如果从大值向小值检索，如何操作？](#b-树的叶子节点是单向链表还是双向链表-如果从大值向小值检索-如何操作)\n\nB+树的叶子节点是通过双向链表连接的，这样可以方便范围查询和反向遍历。\n\n* 当执行范围查询时，可以从范围的开始点或结束点开始，向前或向后遍历。\n* 在需要对数据进行逆序处理时，双向链表非常有用。\n\n如果需要在 B+树中从大值向小值进行检索，可以先定位到最右侧节点，找到包含最大值的叶子节点。从根节点开始向右遍历树的方式实现。\n\n\n\n定位到最右侧的叶子节点后，再利用叶节点间的双向链表向左遍历就好了。\n\n#### [为什么 MongoDB 的索引用 B树，而 MySQL 用 B+ 树？](#为什么-mongodb-的索引用-b树-而-mysql-用-b-树)\n\nMongoDB 通常以 JSON 格式存储文档，查询以单键查询（如 `find({_id: 123})`）为主。B 树的“节点既存键又存数据”的特性允许查询在非叶子节点提前终止，从而减少 I/O 次数。\n\n\n\nMySQL 的查询通常涉及范围（`WHERE id > 100`）、排序（`ORDER BY`）、连接（`JOIN`）等操作。B+ 树的叶子节点是链表结构，天然支持顺序遍历，无需回溯至根节点或中序遍历，效率远高于 B 树。\n\n\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n| 特性 | MongoDB (B树) | MySQL InnoDB (B+树) |\n| --- | --- | --- |\n| 数据模型 | 文档型数据库 | 关系型数据库 |\n| 存储方式 | 数据文件+索引文件分离 | 聚簇索引数据与主键绑定存储 |\n| 查询模式 | 侧重单文档查询 | 侧重范围查询和复杂连接 |\n| 数据访问模式 | 随机访问为主 | 顺序访问更频繁 |\n| 索引存储内容 | 非叶节点存储数据指针 | 只有叶节点存储数据 |\n| 范围查询效率 | 需要多次树遍历 | 通过叶节点链表高效遍历 |\n| 内存利用率 | 单个查询路径缓存更有效 | 适合批量扫描缓存 |\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----"
+ },
+ {
+ "id": 377,
+ "question": "一棵B+树能存储多少条数据呢？",
+ "answer": "一句话回复：\n\n一棵 B+ 树能存多少数据，取决于它的分支因子和高度。在 InnoDB 中，页的默认大小为 16KB，当主键为 bigint 时，3 层 B+ 树通常可以存储约 2000 万条数据。\n\n\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n先来看一下计算公式：\n\n\n```text\n最大记录数 = (分支因子)^(树高度-1) × 叶子节点容量\n```\n\n\n再来看一下关键参数：\n\n①、页大小，默认 16KB\n\n②、主键大小，假设是 bigint 类型，那么它的大小就是 8 个字节。\n\n③、页指针大小，InnoDB 源码中设置为 6 字节，4 字节页号 + 2 字节页内偏移。\n\n\n\n所以非叶子节点可以存储 16384/14(键值+指针)=1170 个这样的单元。\n\n当层高为 2 时，根节点可以存储 1170 个指针，指向 1170 个叶子节点，所以总数据量为 1170×16 =18720 条。\n\n当层高为 3 时，根节点指向 1170 个非叶子节点，每个非叶子节点再指向 1170 个叶子节点，所以总数据量为 1170×1170×16≈21,902,400 条（约2,190万条）记录。\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----\n\n#### [现在有一张表 2kw 数据，我这个 b+树的高度有几层？](#现在有一张表-2kw-数据-我这个-b-树的高度有几层)\n\n对于 2KW 条数据来说，B+树的高度为 3 层就够了。\n\n\n\n#### [每个叶子节点能存放多少条数据？](#每个叶子节点能存放多少条数据)\n\n如果单行数据大小为 1KB，那么每页可存储约 16 行（16KB/1KB）数据。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n假设有这样一个表结构：\n\n\n```sql\nCREATE TABLE `user` (\n `id` BIGINT PRIMARY KEY, -- 8字节\n `name` VARCHAR(255) NOT NULL, -- 实际长度50字节（UTF8MB4，每个字符最多4字节）\n `age` TINYINT, -- 1字节\n `email` VARCHAR(255) -- 实际长度30字节，可为NULL\n) ROW_FORMAT=COMPACT;\n```\n\n\n那么一行数据的大小为：`8 + 50 + 1 + 30 = 89` 字节。\n\n行格式的开销为：行头 5 字节+指针 6 字节+可变长度字段开销 2 字节（name 和 email 各占 1 字节）+ NULL 位图 1 字节 = 14 字节。\n\n所以每行数据的实际大小为：`89 + 14 = 103` 字节。\n\n每页大小默认为 16KB，那么每页最多可以存储 `16384 / 103 ≈ 158` 行数据。\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----"
+ },
+ {
+ "id": 378,
+ "question": "索引为什么用 B+树不用普通二叉树？",
+ "answer": "普通二叉树的每个节点最多有两个子节点。当数据按顺序递增插入时，二叉树会退化成链表，导致树的高度等于数据量。\n\n\n\n此时查找 id=7 就需要 7 次 I/O 操作，相当于全表扫描。而 B+ 树作为多叉平衡树，能将数亿级的数据量控制在 3-4 层的树高，能极大减少磁盘的 I/O 次数。\n\n#### [为什么不用平衡二叉树呢？](#为什么不用平衡二叉树呢)\n\n平衡二叉树虽然解决了普通二叉树的退化问题，但每个节点最多只有两个子节点的问题依然存在。\n\n"
+ },
+ {
+ "id": 379,
+ "question": "为什么用 B+ 树而不用 B 树呢？",
+ "answer": "B+ 树相比 B 树有 3 个显著优势：\n\n第一，B 树的每个节点既存储键值，又存储数据和指针，导致单节点存储的键值数量较少。\n\n\n\n一个 16KB 的 InnoDB 页，如果数据较大，B 树的非叶子节点只能容纳几十个键值，而 B+ 树的非叶子节点可以容纳上千个键值。\n\n第二，B 树的范围查询需要通过中序遍历逐层回溯；而 B+ 树的叶子节点通过双向链表顺序连接，范围查询只需定位起始点后顺序遍历链表即可，没有回溯开销。\n\n\n\n第三，B 树的数据可能存储在任意节点，假如目标数据恰好位于根节点或上层节点，查询仅需 1-2 次 I/O；但如果数据位于底层节点，则需多次 I/O，导致查询时间波动较大。\n\n而 B+ 树的所有数据都存储在叶子节点，查询路径的长度是固定的，时间稳定为 O(logN)，对 MySQL 在高并发场景下的稳定性至关重要。\n\n* [GitHub：B 树和 B+树详解](https://github.com/wardseptember/notes/blob/master/docs/B%E6%A0%91%E5%92%8CB+%E6%A0%91%E8%AF%A6%E8%A7%A3.md)\n* [思否：面试官问你 B 树和 B+树，就把这篇文章丢给他](https://segmentfault.com/a/1190000020416577)\n* [极客时间：为什么用 B+树来做索引？](https://time.geekbang.org/column/article/112298)\n* [一颗剽悍的种子：用 16 张图就给你讲明白 MySQL 为什么要用 B+树做索引](https://mp.weixin.qq.com/s/muOwXKNTvPjXjrLsFRveIw)\n\n#### [B+树的时间复杂度是多少？](#b-树的时间复杂度是多少)\n\nO(logN)。\n\n树的高度 h 为：\n\nh=⌈logmN⌉\n\n其中 N 是数据总量，m 是阶数。每层需要做一次二分查找，复杂度为 O(logm)。\n\n总复杂度为：\n\nO(logmN⋅logm)=O(logN)\n\n#### [为什么用 B+树不用跳表呢？](#为什么用-b-树不用跳表呢)\n\n跳表本质上还是链表结构，只不过把某些节点抽到上层做了索引。\n\n\n\n一条数据一个节点，如果需要存放 2000 万条数据，且每次查询都要能达到二分查找的效果，那么跳表的高度大约为 24 层（2 的 24 次方）。\n\n在最坏的情况下，这 24 层数据分散在不同的数据页，查找一次数据就需要 24 次磁盘 I/O。\n\n而 2000 万条数据在 B+树中只需要 3 层就可以了。\n\n#### [B+树的范围查找怎么做的？](#b-树的范围查找怎么做的)\n\n一句话回答：\n\n先通过索引路径定位到第一个满足条件的叶子节点，然后顺着叶子节点之间的链表向右/向左扫描，直到超过范围。\n\n详细版：\n\nB+ 树索引的范围查找主要依赖叶子节点之间的双向链表来完成。\n\n第一步，从 B+ 树的根节点开始，通过索引键值逐层向下，找到第一个满足条件的叶子节点。\n\n第二步，利用叶子节点之间的双向链表，从起始节点开始，依次向后遍历每个节点。当索引值超过查询范围，或者遍历到链表末尾时，终止查询。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n比如说在下面这棵 B+ 树上查找 45。\n\n\n\n第一步，从根节点开始，因为比 25 大，所以从右子树开始。因为 45 比 35大，所以和右边的索引比较，右侧的索引也是 45，所以继续往右子树查找。\n\n\n\n第二步，从叶子节点 45 开始，依次遍历，找到 45。\n\n\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----\n\n#### [了解快排吗？](#了解快排吗)\n\n快速排序使用分治法将一个序列分为较小和较大的 2 个子序列，然后递归排序两个子序列，由[东尼·霍尔](https://zh.wikipedia.org/wiki/%E6%9D%B1%E5%B0%BC%C2%B7%E9%9C%8D%E7%88%BE)在 1960 年提出。\n\n\n\n其核心思想是：\n\n1. 选择一个基准值。\n2. 将数组分为两部分，左边小于基准值，右边大于或等于基准值。\n3. 对左右两部分递归排序，最终合并。\n\n\n```java\npublic static void quickSort(int[] arr, int low, int high) {\n if (low < high) {\n int pivotIndex = partition(arr, low, high);\n quickSort(arr, low, pivotIndex - 1);\n quickSort(arr, pivotIndex + 1, high);\n }\n}\nprivate static int partition(int[] arr, int low, int high) {\n int pivot = arr[high];\n int i = low - 1;\n for (int j = low; j < high; j++) {\n if (arr[j] <= pivot) {\n i++;\n swap(arr, i, j);\n }\n }\n swap(arr, i + 1, high);\n return i + 1;\n}\nprivate static void swap(int[] arr, int i, int j) {\n int temp = arr[i];\n arr[i] = arr[j];\n arr[j] = temp;\n}\n```\n\n\n推荐链接：[快速排序](https://oi-wiki.org/basic/quick-sort/)"
+ },
+ {
+ "id": 380,
+ "question": "B+树索引和 Hash 索引有什么区别？",
+ "answer": "简版回答：\n\nB+ 树索引支持范围查询、有序扫描，是 InnoDB 的默认索引结构。\n\n\n\nHash 索引只支持等值查找，速度快但功能弱，常见于 Memory 引擎。\n\n\n\n稍微详细一点的回答：\n\nB+ 树索引是一种平衡多路搜索树，所有数据存储在叶子节点上，非叶子节点仅存储索引键。叶子节点通过指针连接形成有序链表，天然支持排序。\n\n并且支持范围查询、模糊查询，是 InnoDB 默认的索引结构。\n\nHash 索引基于哈希函数将键值映射到固定长度的哈希值，通过哈希值定位数据存储的位置。\n\n完全无序，只支持等值查询，常见于 Memory 引擎。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n因为 B+ 树是 InnoDB 的默认索引类型，所以创建 B+ 树的时候不需要指定索引类型。\n\n\n```sql\nCREATE TABLE example_btree (\n id INT AUTO_INCREMENT PRIMARY KEY,\n name VARCHAR(255),\n INDEX name_index (name)\n) ENGINE=InnoDB;\n```\n\n\n可以通过 `UNIQUE HASH` 创建哈希索引：\n\n\n```sql\nCREATE TABLE example_hash (\n id INT AUTO_INCREMENT PRIMARY KEY,\n name VARCHAR(255),\n UNIQUE HASH (name)\n) ENGINE=MEMORY;\n```\n\n\nInnoDB 并不提供直接创建哈希索引的选项，因为 B+ 树索引能够很好地支持范围查询和等值查询，满足了大多数数据库操作的需要。\n\n不过，InnoDB 内部使用了一种名为“自适应哈希索引”（Adaptive Hash Index, AHI）的技术，当某些索引值频繁访问时，InnoDB 会在 B+ 树基础上自动创建哈希索引，兼具两者的优点。\n\n可通过 `SHOW VARIABLES LIKE 'innodb_adaptive_hash_index';` 查看自适应哈希索引的状态。\n\n\n\n如果返回的值是 ON，说明自适应哈希索引是开启的。\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----"
+ },
+ {
+ "id": 381,
+ "question": "聚族索引和非聚族索引有什么区别？",
+ "answer": "聚簇索引的叶子节点存储了完整的数据行，数据和索引是在一起的。InnoDB 的主键索引就是聚簇索引，叶子节点不仅存储了主键值，还存储了其他列的值，因此按照主键进行查询的速度会非常快。\n\n\n\n每个表只能有一个聚簇索引，通常由主键定义。如果没有显式指定主键，InnoDB 会隐式创建一个隐藏的主键索引 row\\_id。\n\n非聚簇索引的叶子节点只包含了主键值，需要通过回表按照主键去聚簇索引查找其他列的值，唯一索引、普通索引等非主键索引都是非聚簇索引。\n\n\n\n每个表都可以创建多个非聚簇索引，如果不想回表的话，可以通过覆盖索引把要查询的字段也放到索引中。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n一张表只能有一个聚簇索引。\n\n\n```sql\nCREATE TABLE user (\n id INT PRIMARY KEY,\n name VARCHAR(100),\n age INT\n);\n```\n\n\n主键 id 是聚簇索引，B+ 树的叶子节点直接存储了 (id, name, age)。\n\n一张表可以有多个非聚簇索引。\n\n\n```sql\nCREATE INDEX idx_name ON user(name);\nCREATE INDEX idx_age ON user(age);\n```\n\n\nidx\\_name 是非聚簇索引，叶子节点存的是 name -> id，查整行数据要回表。\n\nidx\\_age 也是非聚簇索引，叶子节点存的是 age -> id，查整行数据也要回表。\n\n* [磊哥：聚簇索引和非聚簇索引有什么区别？](https://www.cnblogs.com/vipstone/p/16370305.html)\n* [浅谈聚簇索引与非聚簇索引](https://learnku.com/articles/50096)\n* [聚簇索引、非聚簇索引、联合索引、唯一索引](https://blog.csdn.net/m0_52226803/article/details/135494499)\n* [松哥：再聊 MySQL 聚簇索引](https://mp.weixin.qq.com/s/F0cEzIqecF4sWg7ZRmHKRQ)\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----"
+ },
+ {
+ "id": 382,
+ "question": "回表了解吗？",
+ "answer": "当使用非聚簇索引进行查询时，MySQL 需要先通过非聚簇索引找到主键值，然后再根据主键值回到聚簇索引中查找完整数据行，这个过程称为回表。\n\n\n\n假设现在有一张用户表 users：\n\n\n```sql\nCREATE TABLE users (\n id INT PRIMARY KEY,\n name VARCHAR(50),\n age INT,\n email VARCHAR(50),\n INDEX (name)\n);\n```\n\n\n执行查询：\n\n\n```sql\nSELECT * FROM users WHERE name = '练习伴侣二';\n```\n\n\n查询过程如下：\n\n* 第一步，MySQL 使用 name 列上的非聚簇索引查找所有 `name = '练习伴侣二'` 的主键 id。\n* 第二步，使用主键 id 到聚簇索引中查找完整记录。\n\n#### [回表的代价是什么？](#回表的代价是什么)\n\n回表通常需要访问额外的数据页，如果数据不在内存中，还需要从磁盘读取，增加 I/O 开销。\n\n\n\n可通过覆盖索引或者联合索引来避免回表。\n\n\n```sql\n-- 原表结构\nCREATE TABLE users (\n id INT PRIMARY KEY,\n name VARCHAR(50),\n age INT,\n INDEX idx_name (name)\n);\n\n-- 需要查询name和age\nSELECT name, age FROM users WHERE name = '张三';\n-- 这会回表，因为age不在idx_name索引中\n\n-- 优化方案1：创建包含age的联合索引\nALTER TABLE users ADD INDEX idx_name_age (name, age);\n-- 现在同样的查询不需要回表\n```\n\n\n#### [什么情况下会触发回表？](#什么情况下会触发回表)\n\n第一，当查询字段不在非聚簇索引中时，必须回表到主键索引获取数据。\n\n第二，查询字段包含非索引列（如 SELECT \\*），必然触发回表。\n\n#### [回表记录越多好吗？](#回表记录越多好吗)\n\n回表记录越多，通常代表性能越差，因为每条记录都需要通过主键再查询一次完整数据。这个过程涉及内存访问或磁盘 IO，尤其当缓存命中率不高时，回表会严重影响查询效率。\n\n#### [了解 MRR 吗？](#了解-mrr-吗)\n\nMRR 是 InnoDB 为了解决回表带来的大量随机 IO 问题而引入的一种优化策略。\n\n\n\n它会先把非聚簇索引查到的主键值列表进行排序，再按顺序去主键索引中批量回表，将随机 I/O 转换为顺序 I/O，以减少磁盘寻道时间。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n可通过 `SHOW VARIABLES LIKE 'optimizer_switch';` 查看 MRR 是否启用。\n\n\n\n其中 `mrr=on` 表示启用 MRR，`mrr_cost_based=on` 表示基于成本决定使用 MRR。\n\n另外可以通过 `show variables like 'read_rnd_buffer_size';` 查看 MRR 的缓冲区大小，默认是 256KB。\n\n\n\n我们来创建一个表，插入一些数据，然后执行一个查询来演示 MRR 的效果。\n\n\n```sql\nCREATE DATABASE IF NOT EXISTS mrr_test; \nUSE mrr_test; \nCREATE TABLE IF NOT EXISTS orders (id INT AUTO_INCREMENT PRIMARY KEY, user_id INT, order_date DATE, amount DECIMAL(10,2), status VARCHAR(20), INDEX idx_user_date(user_id, order_date));\n\nDELIMITER //\nCREATE PROCEDURE generate_test_data()\nBEGIN\n DECLARE i INT DEFAULT 1;\n WHILE i <= 100000 DO\n INSERT INTO orders (user_id, order_date, amount, status)\n VALUES (\n FLOOR(1 + RAND() * 1000), -- Random user_id between 1 and 1000\n DATE_ADD('2023-01-01', INTERVAL FLOOR(RAND() * 365) DAY), -- Random date in 2023\n ROUND(10 + RAND() * 990, 2), -- Random amount between 10 and 1000\n ELT(1 + FLOOR(RAND() * 3), 'completed', 'pending', 'cancelled') -- Random status\n );\n SET i = i + 1;\n END WHILE;\nEND //\nDELIMITER ;\n\nCALL generate_test_data();\nDROP PROCEDURE generate_test_data;\"\n```\n\n\n查看 MRR 开启和关闭时的性能数据：\n\n\n```sql\n-- 确保MRR开启并设置足够大的缓冲区\nSET SESSION optimizer_switch='mrr=on,mrr_cost_based=off';\nSET SESSION read_rnd_buffer_size = 16*1024*1024;\n\n-- 清理缓存和状态\nFLUSH STATUS;\nFLUSH TABLES;\n\n-- 强制使用二级索引并回表查询（通过选择未被索引的列）\nSELECT 'Raw data access pattern with MRR ON' as test_case;\nSELECT /*+ MRR(orders_mrr_test) */ id, shipping_address, customer_name\nFROM orders_mrr_test FORCE INDEX(idx_user_date)\nWHERE user_id IN (100,200,300,400,500,600,700,800,900,1000)\nAND order_date BETWEEN '2023-03-01' AND '2023-04-01'\nLIMIT 15;\n\n-- 显示处理器状态\nSHOW STATUS LIKE 'Handler_%';\nSHOW STATUS LIKE '%mrr%';\n\n-- 对比：关闭MRR\nSET SESSION optimizer_switch='mrr=off,mrr_cost_based=off';\nFLUSH STATUS;\nFLUSH TABLES;\n\nSELECT 'Raw data access pattern with MRR OFF' as test_case;\nSELECT id, shipping_address, customer_name\nFROM orders_mrr_test FORCE INDEX(idx_user_date)\nWHERE user_id IN (100,200,300,400,500,600,700,800,900,1000)\nAND order_date BETWEEN '2023-03-01' AND '2023-04-01'\nLIMIT 15;\n-- 显示处理器状态\nSHOW STATUS LIKE 'Handler_%';\nSHOW STATUS LIKE '%mrr%';\n\n-- 显示详细的执行计划\nEXPLAIN FORMAT=TREE\nSELECT /*+ MRR(orders_mrr_test) */ id, shipping_address, customer_name\nFROM orders_mrr_test FORCE INDEX(idx_user_date)\nWHERE user_id IN (100,200,300,400,500,600,700,800,900,1000)\nAND order_date BETWEEN '2023-03-01' AND '2023-04-01';\"\n```\n\n\n可以看到 MRR 开启时的结果对比：\n\n\n\n也给出了对应的结果说明：\n\n\n\n也可以在 explain 中确认 MRR 的使用情况。\n\n\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----"
+ },
+ {
+ "id": 383,
+ "question": "联合索引了解吗？（补充）",
+ "answer": "> 2024 年 11 月 22 日增补\n\n联合索引就是把多个字段放在一个索引里，但必须遵守“最左前缀”原则，只有从第一个字段开始连续使用，索引才会生效。\n\n\n\n联合索引会按字段顺序构建B+树。例如`（age, name）`索引会先按照 age 排序，age 相同则按照 name 排序，若两者都相同则按主键排序，确保叶子节点无重复索引项。\n\n创建`(A,B,C)`联合索引相当于同时创建了`(A)`、`(A,B)`和`(A,B,C)`三个索引。\n\n\n```sql\n-- 创建联合索引\nCREATE INDEX idx_order_user_product ON orders(user_id, product_id, create_time)\n\n-- 高效查询\nSELECT * FROM orders \nWHERE user_id=1001 AND product_id=2002\nORDER BY create_time DESC\n```\n\n\n#### [联合索引底层的存储结构是怎样的？](#联合索引底层的存储结构是怎样的)\n\n联合索引在底层采用 B+ 树结构进行存储，这一点与单列索引相同。\n\n\n\n与单列索引不同的是，联合索引的每个节点会存储所有索引列的值，而不仅仅是第一列的值。例如，对于联合索引`(a,b,c)`，每个节点都包含 a、b、c 三列的值。\n\n\n```sql\n非叶子节点示例： \n[(a=1, b=2, c=3) → 子节点1, (a=5, b=3, c=1) → 子节点2]\n\n叶子节点示例（InnoDB）： \n(a=1, b=2, c=3) → PK=100 | (a=1, b=2, c=4) → PK=101 \n（通过指针连接形成双向链表）\n```\n\n\n#### [联合索引的叶子节点存的什么内容?](#联合索引的叶子节点存的什么内容)\n\n联合索引属于非聚簇索引，叶子节点存储的是联合索引各列的值和对应行的主键值，而不是完整的数据行。查询非索引字段时，需要通过主键值回表到聚簇索引获取完整数据。\n\n\n\n例如索引`(a, b)`的叶子节点会完整存储`(a, b)`的值，并按字段顺序排序（如 a 优先，a 相同则按 b 排序）。如果主键是 id，叶子节点会存储 `(a, b, id)` 的组合。"
+ },
+ {
+ "id": 384,
+ "question": "覆盖索引了解吗？",
+ "answer": "覆盖索引指的是：查询所需的字段全部都在索引中，不需要回表，从索引页就能直接返回结果。\n\n\n> empname 和 job 两个字段是一个联合索引，而查询也恰好是这两个字段，这时候单次查询就可以达到目的，不需要回表。\n\n可以将高频查询的字段（如 WHERE 条件和 SELECT 列）组合为联合索引，实现覆盖索引。 例如：\n\n\n```sql\nCREATE INDEX idx_empname_job ON employee(empname, job);\n```\n\n\n这样查询的时候就可以走索引：\n\n\n```sql\nSELECT empname, job FROM employee WHERE empname = '练习伴侣二' AND job = '程序员';\n```\n\n\n普通索引只用于加速查询条件的匹配，而覆盖索引还能直接提供查询结果。\n\n#### [一个表（name, sex,age,id），select age,id,name from tblname where name='paicoding';怎么建索引](#一个表-name-sex-age-id-select-age-id-name-from-tblname-where-name-paicoding-怎么建索引)\n\n由于查询条件有 `name` 字段，所以最少应该为 name 字段添加一个索引。、\n\n\n```sql\nCREATE INDEX idx_name ON tblname(name);\n```\n\n\n查询结果中还需要 `age`、`id` 字段，可以为这三个字段创建一个联合索引，利用覆盖索引，直接从索引中获取数据，减少回表。\n\n\n```sql\nCREATE INDEX idx_name_age_id ON tblname (name, age, id);\n```"
+ },
+ {
+ "id": 385,
+ "question": "什么是最左前缀原则？",
+ "answer": "最左前缀原则指的是：MySQL 使用联合索引时，必须从最左边的字段开始匹配，才能命中索引。\n\n假设有一个联合索引 `(A, B, C)`，其生效条件如下：\n\n| 查询条件 | 是否触发索引？ | 说明 |\n| --- | --- | --- |\n| WHERE A = 1 | ✅ 是 | 使用索引的第一列 |\n| WHERE A = 1 AND B = 2 | ✅ 是 | 使用索引的前两列 |\n| WHERE A = 1 AND B = 2 AND C = 3 | ✅ 是 | 使用索引的全部列 |\n| WHERE B = 2 | ❌ 否 | 跳过左侧列 A，索引失效 |\n| WHERE B = 2 AND C = 3 | ❌ 否 | 无左侧列，索引失效 |\n| WHERE A = 1 AND C = 3 | ⚠️ 部分生效 | 仅用 A 列，C 列无法利用索引优化 |\n| WHERE A = 1 | ✅ 是 | 使用索引的第一列 |\n| WHERE A = 1 AND B = 2 | ✅ 是 | 使用索引的前两列 |\n| WHERE A = 1 AND B = 2 AND C = 3 | ✅ 是 | 使用索引全部列（最理想情况） |\n| WHERE B = 2 | ❌ 否 | 跳过左侧列 A，索引失效 |\n| WHERE B = 2 AND C = 3 | ❌ 否 | 无左侧列，索引失效 |\n| WHERE A = 1 AND C = 3 | ⚠️ 部分生效 | 仅用 A 列，C 列无法利用索引优化 |\n\n如果排序或分组的列是最左前缀的一部分，索引还可以加速操作。\n\n\n```sql\nSQL\n-- 索引(a,b)\nSELECT * FROM table WHERE a = 1 ORDER BY b; -- 可以利用索引排序\n```\n\n\n#### [范围查询后的列还能用索引吗？](#范围查询后的列还能用索引吗)\n\n范围查询只能应用于最左前缀的最后一列。范围查询之后的列无法使用索引。\n\n\n```sql\nSQL\n-- 索引(a,b,c)\nSELECT * FROM table WHERE a = 1 AND b > 2 AND c = 3; \n-- 只能使用a和b，c无法使用索引\n```\n\n\n#### [为什么不从最左开始查，就无法匹配呢？](#为什么不从最左开始查-就无法匹配呢)\n\n一句话回答：\n\n因为联合索引在 B+ 树中是按照最左字段优先排序构建的，如果跳过最左字段，MySQL 无法判断查找范围从哪里开始，自然也就无法使用索引。\n\n\n\n比如有一个 user 表，我们给 name 和 age 建立了一个联合索引 `(name, age)`。\n\n\n```sql\nALTER TABLE user add INDEX comidx_name_phone (name,age);\n```\n\n\n联合索引在 B+ 树中按照从左到右的顺序依次建立搜索树，name 在左，age 在右。\n\n当我们使用 `where name= '练习伴侣二' and age = '20'` 去查询的时候， B+ 树会优先比较 name 来确定下一步应该搜索的方向，往左还是往右。\n\n如果 name 相同的时候再比较 age。\n\n但如果查询条件没有 name，就不知道应该怎么查了，因为 name 是 B+树中的前置条件，没有 name，索引就派不上用场了。\n\n#### [联合索引 (a, b)，where a = 1 和 where b = 1，效果是一样的吗](#联合索引-a-b-where-a-1-和-where-b-1-效果是一样的吗)\n\n不一样。\n\n`WHERE a = 1` 能命中联合索引，因为 a 是联合索引的第一个字段，符合最左前缀匹配原则。而 `WHERE b = 1` 无法命中联合索引，因为缺少 a 的匹配条件，MySQL 会全表扫描。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n我们来验证一下，假设有一个 ab 表，建立了联合索引 `(a, b)`：\n\n\n```sql\nCREATE TABLE ab (\n a INT,\n b INT,\n INDEX ab_index (a, b)\n);\n```\n\n\n插入数据：\n\n\n```sql\nINSERT INTO ab (a, b) VALUES (1, 2), (1, 3), (2, 1), (3, 3), (2, 2);\n```\n\n\n执行查询：\n\n\n\n通过 explain 可以看到，`WHERE a = 1` 使用了联合索引，而 `WHERE b = 1` 需要全表扫描，依次检查每一行。\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----\n\n#### [假如有联合索引 abc，下面的 sql 怎么走的联合索引？](#假如有联合索引-abc-下面的-sql-怎么走的联合索引)\n\n\n```sql\nselect * from t where a = 2 and b = 2;\nselect * from t where b = 2 and c = 2;\nselect * from t where a > 2 and b = 2;\n```\n\n\n第一条 SQL 语句包含条件 a = 2 和 b = 2，刚好符合联合索引的前两列。\n\n\n\n第二条 SQL 语句由于未使用最左前缀中的 a，会触发全表扫描。\n\n\n\n第三条 SQL 语句在范围条件 `a > 2` 之后，索引后会停止匹配，b = 2 的条件需要额外过滤。\n\n\n\n#### [(A,B,C) 联合索引 `select * from tbn where a=? and b in (?,?) and c>?` 会走索引吗？](#a-b-c-联合索引-select-from-tbn-where-a-and-b-in-and-c-会走索引吗)\n\n> 2024 年 03 月 15 日增补。\n\n这个查询会命中联合索引，因为 a 是等值匹配，b 是 IN 等值多匹配，c 是 b 之后的范围条件，符合最左前缀原则。\n\n1. 对于 `a=?`：这是一个精确匹配，并且是联合索引的第一个字段，所以一定会命中索引。\n2. 对于 `b IN (?, ?)`：等价于 b=? OR b=?，属于多值匹配，并且是联合索引的第二个字段，所以也会命中索引。\n3. 对于 `c>?`：这是一个范围条件，属于联合索引的第三个字段，也会命中索引。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n来验证一下。\n\n第一步，建表。\n\n\n```sql\nCREATE TABLE tbn (A INT, B INT, C INT, D TEXT);\n```\n\n\n第二步，创建索引。\n\n\n```sql\nCREATE INDEX idx_abc ON tbn (A, B, C);\n```\n\n\n第三步，插入数据。\n\n\n```sql\nINSERT INTO tbn VALUES (1, 2, 3, 'First');\nINSERT INTO tbn VALUES (1, 2, 4, 'Second');\nINSERT INTO tbn VALUES (1, 3, 5, 'Third');\nINSERT INTO tbn VALUES (2, 2, 3, 'Fourth');\nINSERT INTO tbn VALUES (2, 3, 4, 'Fifth');\n```\n\n\n第四步，执行查询。\n\n\n```sql\nEXPLAIN SELECT * FROM tbn WHERE A=1 AND B IN (2, 3) AND C>3\\G\n```\n\n\n从 `EXPLAIN` 输出结果来看，我们可以得到 MySQL 是如何执行查询的一些关键信息：\n\n* **type**: 查询类型，这里是 `range`，表示 MySQL 使用了范围查找，这是因为查询条件包含了 `>` 操作符。\n* **possible\\_keys**: 可能被用来执行查询的索引，这里是 `idx_abc`，表示 MySQL 认为 `idx_abc` 索引会用于查询优化。\n* **key**: 实际用来执行查询的索引，也是 `idx_abc`，这确定这条查询命中了联合索引。\n* **Extra**: 提供了关于查询执行的额外信息。`Using index condition` 表示 MySQL 使用了索引下推（Index Condition Pushdown，ICP），这是 MySQL 的一个优化方式，它允许在索引层面过滤数据。\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----\n\n#### [联合索引的一个场景题：(a,b,c)联合索引，(b,c)是否会走索引吗？](#联合索引的一个场景题-a-b-c-联合索引-b-c-是否会走索引吗)\n\n> 2024 年 04 月 06 日增补\n\n根据最左前缀原则，(b,c) 查询不会走索引。\n\n因为联合索引 (a,b,c) 中，a 是最左边的列，联合索引在创建索引树的时候需要先有 a，然后才会有 b 和 c。而查询条件中没有包含 a，所以 MySQL 无法利用这个索引。\n\n\n```sql\nEXPLAIN SELECT * FROM tbn WHERE B=1 AND C=1\\G\n```\n\n\n#### [建立联合索引(a,b,c)，where c = 5 是否会用到索引？为什么？](#建立联合索引-a-b-c-where-c-5-是否会用到索引-为什么)\n\n> 2024 年 04 月 08 日增补\n\n不会。只有索引的第三列 c 被用作查询条件，而前两列 a 和 b 都没有被使用。这不符合最左前缀原则。\n\n\n```sql\nEXPLAIN SELECT * FROM tbn WHERE C=5\\G\n```\n\n\n#### [sql中使用like，如果遵循最左前缀匹配，查询是不是一定会用到索引？](#sql中使用like-如果遵循最左前缀匹配-查询是不是一定会用到索引)\n\n> 2024 年 11 月 04 日增补\n\n如果查询模式是后缀通配符 `LIKE 'prefix%'`，且该字段有索引，优化器通常会使用索引。否则即便是遵循最左前缀匹配，LIKE 字段也无法命中索引。\n\n如 `age = 18 and name LIKE '%xxx'`，MySQL 会先使用联合索引 age\\_name 找到 age 符合条件的所有行，然后再全表扫描进行 name 字段的过滤。\n\n\n\n`type: ref` 表示使用索引查找匹配某个值的所有行。\n\n\n\n如果是后缀通配符，如 `age = 18 and name LIKE 'xxx%'`，MySQL 会直接使用联合索引 age\\_name 找到所有符合条件的行。\n\n\n\ntype 为 range，表示 MySQL 使用了索引范围扫描，`filtered 为 100.00%`，表示在扫描的行中，所有的行都满足 WHERE 条件。"
+ },
+ {
+ "id": 386,
+ "question": "什么是索引下推？",
+ "answer": "索引下推是指：MySQL 把 WHERE 条件尽可能“下推”到索引扫描阶段，在存储引擎层提前过滤掉不符合条件的记录。\n\n\n\n当查询条件包含索引列但未完全匹配时，ICP 会在存储引擎层过滤非索引列条件，以减少回表次数。\n\n传统的查询流程是，储引擎通过联合索引定位到符合最左前缀条件的主键 ID；回表读取完整数据行并返回给 Server 层；Server 层对所有返回的行进行 WHERE 条件过滤。\n\n有了 ICP 后，存储引擎在索引层直接过滤可下推的条件，仅对符合索引条件的记录回表读取数据，再返回给 Server 层进行剩余条件过滤。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n例如有一张 user 表，建了一个联合索引（name, age），查询语句：`select * from user where name like '张%' and age=10;`，没有索引下推优化的情况下：\n\nMySQL 会使用索引 name 找到所有 `name like '张%'` 的主键，根据这些主键，一条条回表查询整行数据，并在 Server 层过滤掉不符合 `age=10` 的数据行。\n\n\n\n启用 ICP 后，InnoDB 会通过联合索引直接筛选出符合条件的主键 ID（`name like '张%' and age=10`），然后再回表查询整行数据。\n\n\n\n换句话说，假设 `name like '张%'` 找到 10000 行数据，`age=10` 只有其中 10 行，没有索引下推的情况下，MySQL 会回表 10000 次，读取 10000 行数据，然后在 Server 层过滤掉 9990 行。\n\n而有了索引下推后，MySQL 只会回表 10 次，读取 10 行数据。\n\n我们来验证一下。\n\n\n\n从结果中我们可以清楚地看到 ICP 的效果。ICP 开启时，Extra 列显示\"Using index condition\"，表明过滤条件被下推到存储引擎层。\n\nICP关闭时，Extra 列仅显示\"Using where\"，表明过滤条件在服务器层执行。\n\n\n```sql\n-- 开启ICP\nSET optimizer_switch='index_condition_pushdown=on';\n\n-- 清理状态\nFLUSH STATUS;\n\nSELECT 'Performance test with ICP ON' as test_case;\n-- 执行查询并分析性能\nEXPLAIN ANALYZE\nSELECT /*+ ICP_ON */ *\nFROM orders_mrr_test\nWHERE user_id BETWEEN 100 AND 200\n AND order_date >= '2023-01-01'\n AND order_date < '2023-02-01'\n AND order_date NOT LIKE '2023-01-15%';\n\n-- 显示处理器状态\nSHOW STATUS LIKE 'Handler_read%';\n\n-- 关闭ICP\nSET optimizer_switch='index_condition_pushdown=off';\n\n-- 清理状态\nFLUSH STATUS;\n\nSELECT 'Performance test with ICP OFF' as test_case;\n-- 执行相同的查询\nEXPLAIN ANALYZE\nSELECT *\nFROM orders_mrr_test\nWHERE user_id BETWEEN 100 AND 200\n AND order_date >= '2023-01-01'\n AND order_date < '2023-02-01'\n AND order_date NOT LIKE '2023-01-15%';\n\n-- 显示处理器状态\nSHOW STATUS LIKE 'Handler_read%';\"\n```\n\n\n实际的性能差距也很大。ICP 开启时，实际扫描行数：1,649 行，执行时间：约12.3 毫秒。关闭时，实际扫描行数：19,959 行，执行时间：约 32.1 毫秒。\n\n\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----"
+ },
+ {
+ "id": 387,
+ "question": "如何查看是否用到了索引？（补充）",
+ "answer": "> 2024 年 03 月 15 日增补。\n\n可以通过 `EXPLAIN` 关键字来查看是否使用了索引。\n\n\n```sql\nEXPLAIN SELECT * FROM table WHERE column = 'value';\n```\n\n\n如果使用了索引，结果中的 `key` 值会显示索引的名称。\n\n\n\n#### [联合索引 abc，a=1,c=1/b=1,c=1/a=1,c=1,b=1 走不走索引？](#联合索引-abc-a-1-c-1-b-1-c-1-a-1-c-1-b-1-走不走索引)\n\n> 2024 年 03 月 19 日增补\n\nac 能用上索引，条件 a=1 符合最左前缀原则，触发索引的第一列 a；由于跳过了中间列 b，c=1 无法直接利用索引的有序性优化，但可通过索引下推在存储引擎层过滤 c 的条件，减少回表次数。\n\nbc 无法使用索引，只能全表扫描，因为不符合最左前缀原则；acb 虽然顺序是乱的，但 MySQL 优化器会自动重排为 abc，所以能命中索引。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n我们通过实际的 SQL 来验证一下。\n\n示例 1（a=1,c=1）：\n\n\n```sql\nEXPLAIN SELECT * FROM tbn WHERE A=1 AND C=1\\G\n```\n\n\nkey 是 idx\\_abc，表明 a=1,c=1 会使用联合索引。`Extra: Using index condition` 表示 ICP 生效。\n\n示例 2（b=1,c=1）：\n\n\n```sql\nEXPLAIN SELECT * FROM tbn WHERE B=1 AND C=1\\G\n```\n\n\nkey 是 NULL，表明 b=1,c=1 不会使用联合索引。这是因为查询条件没有遵循最左前缀原则。\n\n示例 3（a=1,c=1,b=1）：\n\n\n```sql\nEXPLAIN SELECT * FROM tbn WHERE A=1 AND C=1 AND B=1\\G\n```\n\n\n优化器会自动调整条件顺序为 a=1 AND b=1 AND c=1。\n\n\n\nkey 是 idx\\_abc，表明 a=1,c=1,b=1 会使用联合索引。\n\n并且 rows=1，因为 MySQL 优化器会自动重排查询条件，以满足最左前缀原则，直接使用联合索引找出 `a=1 AND b=1 AND c=1` 的行。"
+ }
+ ]
+ },
+ {
+ "id": 57,
+ "categoryName": "锁",
+ "questions": [
+ {
+ "id": 388,
+ "question": "MySQL 中有哪几种锁？",
+ "answer": "MySQL 中有多种类型的锁，可以从不同维度来分类，按锁粒度划分的话，有表锁、行锁。\n\n按照加锁机制划分的话，有乐观锁和悲观锁。按照兼容性划分的话，有共享锁和排他锁。\n\n\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n表锁：锁定整个表，资源开销小，加锁快，但并发度低，不会出现死锁；适合查询为主、少量更新的场景（如 MyISAM 引擎）。\n\n\n\n再细分的话，有表共享读锁（S锁）：允许多个事务同时读，但阻塞写操作；表独占写锁（X锁）：独占表，阻塞其他事务的读写。\n\n\n\n行锁：锁定单行或多行，开销大、加锁慢，可能出现死锁，但并发度高（InnoDB 默认支持）。\n\n再细分的话，有记录锁（Record Lock）：锁定索引中的具体记录；间隙锁（Gap Lock）：锁定索引记录之间的间隙，防止幻读；临键锁（Next-Key Lock）：结合记录锁和间隙锁，锁定一个左开右闭的区间（如 `(5, 10]`）。\n\n共享锁（S锁/读锁），允许多个事务同时读取数据，但阻塞写操作。语法：`SELECT ... LOCK IN SHARE MODE`\n\n排他锁（X锁/写锁），独占数据，阻塞其他事务的读写。语法：`SELECT ... FOR UPDATE`。\n\n乐观锁假设冲突少，通过版本号或 CAS 机制检测冲突（如 `UPDATE SET version=version+1 WHERE version=old_version`）。\n\n悲观锁假设并发冲突频繁，先加锁再操作`SELECT FOR UPDATE`。\n\n---- 这部分是帮助大家理解 end，面试中可不背"
+ },
+ {
+ "id": 389,
+ "question": "全局锁了解吗？（补充）",
+ "answer": "> 2024 年 07 月 15 日增补。\n\n全局锁就是对整个数据库实例进行加锁，当执行全局锁定操作时，整个数据库将会处于只读状态，所有写操作都会被阻塞，直到全局锁被释放。\n\n在进行全库备份，或者数据迁移时，可以使用全局锁来保证数据的一致性。\n\n在 MySQL 中，可以使用 `FLUSH TABLES WITH READ LOCK` 命令来获取全局锁。\n\n执行该命令后，所有表将被锁定为只读状态。记得在完成备份或迁移后，使用 `UNLOCK TABLES` 命令释放全局锁。\n\n\n```sql\n-- 锁定整个数据库\nFLUSH TABLES WITH READ LOCK;\n\n-- 执行备份操作\n-- 例如使用 mysqldump 进行备份\n! mysqldump -u username -p database_name > backup.sql\n\n-- 释放全局锁定\nUNLOCK TABLES;\n```\n\n\n#### [表锁了解吗？](#表锁了解吗)\n\n了解。\n\n表锁常见于 MyISAM 引擎，InnoDB 也可以手动通过 `LOCK TABLES` 加锁。\n\n\n\n适合读多写少、全表扫描或者表结构变更的场景用。\n\n表锁又可以细分为共享锁和排他锁。共享锁允许多个事务同时读表，但不允许写操作。\n\n\n```sql\nLOCK TABLES table_name READ; -- 显式加读锁\nSELECT * FROM table_name; -- 其他会话可读，不可写\nUNLOCK TABLES; -- 释放锁\n```\n\n\n排他锁只允许一个事务进行写操作，其他事务不能读也不能写。\n\n\n```sql\nLOCK TABLES table_name WRITE; -- 显式加写锁\nINSERT/UPDATE/DELETE table_name; -- 其他会话读写均阻塞\nUNLOCK TABLES;\n```\n\n\nMyISAM 在执行 `SELECT` 时会自动加读锁，执行 `INSERT/UPDATE/DELETE` 时会加写锁。\n\n对于 InnoDB 引擎，无索引的 `UPDATE/DELETE` 可能会导致锁升级为表锁。\n\n\n```sql\nUPDATE innodb_table SET name='new' WHERE name='old'; -- 全表扫描，退化为表锁\n```\n\n\n执行 `ALTER TABLE` 时会自动加表锁，阻塞所有读写操作。"
+ },
+ {
+ "id": 390,
+ "question": "说说 MySQL 的行锁？",
+ "answer": "行锁是 InnoDB 存储引擎中最细粒度的锁，它锁定表中的一行记录，允许其他事务访问表中的其他行。\n\n底层是通过给索引加锁实现的，这就意味着只有通过索引条件检索数据时，InnoDB 才能使用行级锁，否则会退化为表锁。\n\n\n\n行锁又可以细分为记录锁、间隙锁和临键锁三种形式。通过 `SELECT ... FOR UPDATE` 可以加排他锁。\n\n\n```sql\nSTART TRANSACTION;\n\n-- 加排他锁，锁定某一行\nSELECT * FROM your_table WHERE id = 1 FOR UPDATE;\n-- 对该行进行操作\nUPDATE your_table SET column1 = 'new_value' WHERE id = 1;\n\nCOMMIT;\n```\n\n\n通过 `SELECT ...LOCK IN SHARE MODE` 可以加共享锁。\n\n\n```sql\nSTART TRANSACTION;\n\n-- 加共享锁，锁定某一行\nSELECT * FROM your_table WHERE id = 1 LOCK IN SHARE MODE;\n-- 只能读取该行，不能修改\n\nCOMMIT;\n```\n\n\n#### [select for update 有什么需要注意的？](#select-for-update-有什么需要注意的)\n\n第一，必须在事务中使用，否则锁会立即释放。\n\n\n```sql\nSTART TRANSACTION;\nSELECT * FROM your_table WHERE id = 1 FOR UPDATE;\n-- 对该行进行操作\nCOMMIT;\n```\n\n\n第二，使用时必须注意是否命中索引，否则可能锁全表。\n\n\n```sql\n-- name 没有索引，会退化为表锁\nSELECT * FROM user WHERE name = '练习伴侣二' FOR UPDATE;\n```\n\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n假设有一张名为 orders 的表，包含以下数据：\n\n\n```sql\nCREATE TABLE orders (\n id INT PRIMARY KEY,\n order_no VARCHAR(255),\n amount DECIMAL(10,2),\n status VARCHAR(50),\n INDEX (order_no) -- order_no 上有索引\n);\n```\n\n\n表中的数据是这样的：\n\n| id | order\\_no | amount | status |\n| --- | --- | --- | --- |\n| 1 | 10001 | 50.00 | pending |\n| 2 | 10002 | 75.00 | pending |\n| 3 | 10003 | 100.00 | pending |\n| 4 | 10004 | 150.00 | completed |\n| 5 | 10005 | 200.00 | pending |\n\n如果我们通过主键索引执行 `SELECT FOR UPDATE`，确实只会锁定特定的行：\n\n\n```sql\nSTART TRANSACTION;\nSELECT * FROM orders WHERE id = 1 FOR UPDATE;\n-- 对 id=1 的行进行操作\nCOMMIT;\n```\n\n\n由于 id 是主键，所以只会锁定 `id=1` 这行，不会影响其他行的操作。其他事务依然可以对 id = 2, 3, 4, 5 等行执行更新操作，因为它们没有被锁定。\n\n如果使用 order\\_no 这个普通索引执行 `SELECT FOR UPDATE`，也只会锁定特定的行：\n\n\n```sql\nSTART TRANSACTION;\nSELECT * FROM orders WHERE order_no = '10001' FOR UPDATE;\n-- 对 order_no=10001 的行进行操作\nCOMMIT;\n```\n\n\n因为 order\\_no 是唯一索引，所以只会锁定 `order_no=10001` 这行，不会影响其他行的操作。\n\n但如果 WHERE 条件是 `status='pending'`，而 status 上没有索引：\n\n\n```sql\nSTART TRANSACTION;\nSELECT * FROM orders WHERE status = 'pending' FOR UPDATE;\n-- 对 status=pending 的行进行操作\nCOMMIT;\n```\n\n\n就会退化为表锁，因为在这种情况下，MySQL 需要全表扫描检查每一行的 status。\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----"
+ },
+ {
+ "id": 391,
+ "question": "临键锁了解吗？",
+ "answer": "临键锁是记录锁和间隙锁的结合体，锁住的是索引记录和索引记录之间的间隙。\n\n\n\n和间隙锁不同，临键锁的间隙是一个**左开右闭区间**。例如 `(1,3]` 表示锁定大于 1 且小于等于 3 的所有记录。\n\n当 InnoDB 执行一个范围查询时，会使用临键锁来锁定满足条件的行数据以及该范围内的间隙。\n\n\n\n比如说下面这条语句会锁定 id 在 5 到 10 之间的所有记录，以及这些记录之间的间隙。\n\n\n```sql\nSELECT * FROM table WHERE id BETWEEN 5 AND 10 FOR UPDATE;\n```\n\n\nMySQL 默认的行锁类型就是临键锁。当使用唯一索引的等值查询匹配到一条记录时，临键锁会退化成记录锁；如果没有匹配到任何记录，会退化成间隙锁。"
+ },
+ {
+ "id": 392,
+ "question": "意向锁是什么知道吗？",
+ "answer": "意向锁是一种表级锁，表示事务打算对表中的某些行数据加锁，但不会直接锁定数据行本身。\n\n由 InnoDB 自动管理，当事务需要添加行锁时，会先在表上添加意向锁。这样当要添加表锁的时候，可以通过查看表上的意向锁，快速判断是否有冲突，而无需逐行检查，从而提高加锁效率。\n\n\n\n当执行 `SELECT ... LOCK IN SHARE MODE` 时，会自动加意向共享锁；当执行 `SELECT ... FOR UPDATE` 时，会自动加意向排他锁。\n\n意向锁之间互相兼容，也不会与行锁冲突。\n\n| 兼容关系 | 意向共享锁 | 意向排他锁 | 共享锁(表级) | 拍他锁(表级) |\n| --- | --- | --- | --- | --- |\n| 意向共享锁 | 兼容 | 兼容 | 兼容 | 冲突 |\n| 意向排他锁 | 兼容 | 兼容 | 冲突 | 冲突 |\n| S锁 | 兼容 | 冲突 | 兼容 | 冲突 |\n| X锁 | 冲突 | 冲突 | 冲突 | 冲突 |\n\n#### [意向锁的意义是什么？](#意向锁的意义是什么)\n\n在没有意向锁的情况下，当事务 A 持有某表的行锁时，如果事务 B 想添加表锁，InnoDB 必须检查表中每一行数据是否被加锁，这种全表扫描的方式效率极低。\n\n\n\n有了意向锁之后，事务在加行锁前，先在表上加对应的意向锁；其他事务加表锁时，只需检查表上的意向锁，无需逐行检查。\n\n\n```sql\n-- 事务A获取某行的排他锁\nBEGIN;\nSELECT * FROM users WHERE id = 6 FOR UPDATE; -- 自动加IX锁和行X锁\n\n-- 事务B尝试加表锁\nLOCK TABLES users READ; -- 发现表上有IX锁，与S锁冲突，直接阻塞而无需扫描全表\n```"
+ },
+ {
+ "id": 393,
+ "question": "MySQL 的乐观锁和悲观锁了解吗？",
+ "answer": "悲观锁是一种\"先上锁再操作\"的保守策略，它假设数据被外界访问时必然会产生冲突，因此在数据处理过程中全程加锁，保证同一时间只有一个线程可以访问数据。\n\n\n\nMySQL 中的行锁和表锁都是悲观锁。\n\n\n\n乐观锁会假设并发操作不会总发生冲突，属于小概率事件，因此不会在读取数据时加锁，而是在提交更新时才检查数据是否被其他事务修改过。\n\n\n\n乐观锁并不是 MySQL 内置的锁机制，而是通过程序逻辑实现的，常见的实现方式有版本号机制和时间戳机制。通过在表中增加 version 字段或者 timestamp 字段来实现。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n当事务 A 已经上锁后，事务 B 会一直等待事务 A 释放锁；如果事务 A 长时间不释放锁，事务 B 就会报错 `Lock wait timeout exceeded; try restarting transaction`。\n\n\n\n事务 A 和事务 B 同时读取同一个主键 ID 的数据，版本号为 0；事务 A 将版本号（version=1）作为条件进行数据更新，同时版本号 +1；事务 B 也将 version=1 作为更新条件，发现版本号不匹配，更新失败。\n\n\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----\n\n#### [如何通过悲观锁和乐观锁解决库存超卖问题？](#如何通过悲观锁和乐观锁解决库存超卖问题)\n\n悲观锁通过 `SELECT ... FOR UPDATE` 在查询时直接锁定记录，确保其他事务必须等待当前事务完成才能操作该行数据。\n\n\n```sql\nBEGIN;\n-- 对id=1的商品记录加排他锁\nSELECT stock FROM products WHERE id=1 FOR UPDATE;\n-- 生成订单\nINSERT INTO orders (user_id, product_id) VALUES (123, 1);\n-- 扣减库存\nUPDATE products SET stock=stock-1 WHERE id=1;\nCOMMIT;\n```\n\n\n乐观锁通过在表中增加 version 字段作为判断条件。\n\n\n```sql\n-- 查询商品信息，获取版本号\nSELECT stock, version FROM products WHERE id=1;\n\n-- 更新库存时检查版本号\nUPDATE products \nSET stock=stock-1, version=version+1 \nWHERE id=1 AND version=旧版本号;\n```\n\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n库存超卖是一个非常经典的问题：\n\n* 事务A查询商品库存，得到库存值为1\n* 事务B也查询同一商品库存，同样得到库存值为1\n* 事务A基于查询结果执行库存扣减，将库存更新为0\n* 事务B也执行库存扣减，将库存更新为-1\n\n悲观锁的关键点：\n\n* 必须在一个事务中执行；\n* 通过 `SELECT ... FOR UPDATE` 锁定行，确保其他事务必须等待当前事务完成才能操作该行数据；\n* 记得给查询条件加索引，避免全表扫描导致锁升级为表锁。\n\n乐观锁的关键点：\n\n* 在表中增加 version 字段；\n* 查询时获取当前版本号；\n* 更新时检查版本号是否发生了变化。\n\nJava 程序的完整代码示例：\n\n\n```java\n@Service\npublic class ProductService {\n @Autowired\n private ProductMapper productMapper;\n \n @Transactional\n public boolean purchaseWithOptimisticLock(Long productId, int quantity) {\n int retryCount = 0;\n while(retryCount < 3) { // 最大重试次数\n Product product = productMapper.selectById(productId);\n if(product.getStock() < quantity) {\n return false; // 库存不足\n }\n \n int updated = productMapper.reduceStockWithVersion(\n productId, quantity, product.getVersion());\n \n if(updated > 0) {\n return true; // 更新成功\n }\n retryCount++;\n }\n return false; // 更新失败\n }\n}\n```\n\n\n对应的 mapper：\n\n\n```java\n@Update(\"UPDATE products SET stock=stock-#{quantity}, version=version+1 \" +\n \"WHERE id=#{productId} AND version=#{version}\")\nint reduceStockWithVersion(@Param(\"productId\") Long productId, \n @Param(\"quantity\") int quantity,\n @Param(\"version\") int version);\n```\n\n\n时间戳机制实现的乐观锁：\n\n\n```sql\nUPDATE products SET stock=stock-1, update_time=NOW() \nWHERE id=1 AND update_time=旧时间戳;\n```\n\n\n这两种方式都需要保证操作的原子性，需要将多个 SQL 放在同一个事务中执行。\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----"
+ },
+ {
+ "id": 394,
+ "question": "遇到过MySQL死锁问题吗，你是如何解决的？",
+ "answer": "遇到过。MySQL 的死锁是由于多个事务持有资源并相互等待引起的。我通过 `SHOW ENGINE INNODB STATUS` 查看死锁信息，定位到是加锁顺序不一致导致的，最后通过调整加锁顺序解决了这个问题。\n\n\n\n比如说项目中，两个事务分别更新两张表，但是更新顺序不一致。\n\n\n```sql\n-- 创建表/插入数据\nCREATE TABLE account (\n id INT AUTO_INCREMENT PRIMARY KEY,\n balance INT NOT NULL\n);\n\nINSERT INTO account (balance) VALUES (100), (200);\n\n-- 事务 1\nSTART TRANSACTION;\n-- 锁住 id=1 的行\nUPDATE account SET balance = balance - 10 WHERE id = 1;\n\n-- 等待锁住 id=2 的行（事务 2 已锁住）\nUPDATE account SET balance = balance + 10 WHERE id = 2;\n\n-- 事务 2\nSTART TRANSACTION;\n-- 锁住 id=2 的行\nUPDATE account SET balance = balance - 10 WHERE id = 2;\n\n-- 等待锁住 id=1 的行（事务 1 已锁住）\nUPDATE account SET balance = balance + 10 WHERE id = 1;\n```\n\n\n访问相同的资源，但顺序不同，就会导致死锁。\n\n\n\n解决办法也很简单，先使用 `SHOW ENGINE INNODB STATUS\\G;` 确认死锁的具体信息，然后调整资源的访问顺序。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 58,
+ "categoryName": "事务",
+ "questions": [
+ {
+ "id": 395,
+ "question": "MySQL事务的四大特性说一下？",
+ "answer": "事务是一条或多条 SQL 语句组成的执行单元。四个特性分别是原子性、一致性、隔离性和持久性。原子性保证事务中的操作要么全部执行、要么全部失败；一致性保证数据从事务开始前的一个一致状态转移到结束后的另外一个一致状态；隔离性保证并发事务之间互不干扰；持久性保证事务提交后数据不会丢失。\n\n\n\n#### [详细说一下原子性？](#详细说一下原子性)\n\n原子性意味着事务中的所有操作要么全部完成，要么全部不完成，它是不可分割的单位。如果事务中的任何一个操作失败了，整个事务都会回滚到事务开始之前的状态，如同这些操作从未被执行过一样。\n\n\n```sql\nSTART TRANSACTION;\nUPDATE accounts SET balance = balance - 100 WHERE user_id = 1;\nUPDATE accounts SET balance = balance + 100 WHERE user_id = 2;\n-- 如果第二条语句失败，第一条也会回滚\nCOMMIT;\n```\n\n\n简短回答：原子性要求事务的所有操作要么全部提交成功，要么全部失败回滚，对于一个事务中的操作不能只执行其中一部分。\n\n#### [详细说一下一致性？](#详细说一下一致性)\n\n一致性确保事务从一个一致的状态转换到另一个一致的状态。\n\n比如在银行转账事务中，无论发生什么，转账前后两个账户的总金额应保持不变。假如 A 账户（100 块）给 B 账户（10 块）转了 10 块钱，不管成功与否，A 和 B 的总金额都是 110 块。\n\n\n```sql\n-- 假设 A 账户余额为 100，B 账户余额为 10\n\n-- 转账前状态\nSELECT balance FROM accounts WHERE user_id = 'A'; -- 100\nSELECT balance FROM accounts WHERE user_id = 'B'; -- 10\n\n-- 转账操作\nSTART TRANSACTION;\nUPDATE accounts SET balance = balance - 10 WHERE user_id = 'A';\nUPDATE accounts SET balance = balance + 10 WHERE user_id = 'B';\nCOMMIT;\n\n-- 转账后状态\nSELECT balance FROM accounts WHERE user_id = 'A'; -- 90\nSELECT balance FROM accounts WHERE user_id = 'B'; -- 20`\n-- 总金额仍然是 110\n```\n\n\n简短回答：一致性确保数据的状态从一个一致状态转变为另一个一致状态。一致性与业务规则有关，比如银行转账，不论事务成功还是失败，转账双方的总金额应该是不变的。\n\n#### [详细说一下隔离性？](#详细说一下隔离性)\n\n隔离性意味着并发执行的事务是彼此隔离的，一个事务的执行不会被其他事务干扰。事务之间是井水不犯河水的。\n\n隔离性主要是为了解决事务并发执行时可能出现的脏读、不可重复读、幻读等问题。\n\n---- 这部分是帮助大家理解 start，面试中可不背 ----\n\n比如说在读未提交的隔离级别下，会出现脏读现象：一个事务C 读取了事务B 尚未提交的修改数据。如果事务B 最终回滚，事务C 读取的数据就是无效的“脏数据”。\n\n\n```sql\n-- 会话 A\n-- 创建模拟并发的测试表\nDROP TABLE IF EXISTS accounts;\nCREATE TABLE accounts (\n id INT PRIMARY KEY AUTO_INCREMENT,\n name VARCHAR(50),\n balance DECIMAL(10,2)\n);\n\n-- 插入测试数据\nINSERT INTO accounts (name, balance) VALUES\n('练习伴侣二', 1000.00),\n('张三', 2000.00),\n('李四', 3000.00);\n\n-- 会话B 中，设置隔离级别为读未提交\nSET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;\nSTART TRANSACTION;\n\n-- 在会话 B 中更新数据但不提交\nUPDATE accounts SET balance = balance - 500 WHERE name='练习伴侣二';\n\n-- 会话C 是读为提交级别，读取数据，得到 500\nSET SESSION TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;\nSELECT * FROM accounts WHERE name='练习伴侣二';\n-- 继续别的操作，基于 500\n\n-- 会话 B 的事务回滚，导致会话 A 读到的数据其实是脏数据\nROLLBACK;\n```\n\n\n通过升级隔离级别为读已提交可以解决脏读的问题。\n\n\n```sql\n-- 会话 B 修改为读已提交\nSET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;\n\n-- 执行第一次查询 1000\nSELECT * FROM accounts WHERE name='练习伴侣二';\n\n-- 会话 C 中，设置隔离级别为读已提交\nSET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;\n-- 在会话 C 中更新数据但不提交\nSTART TRANSACTION;\nUPDATE accounts SET balance = balance + 200 WHERE name='练习伴侣二';\n\n-- 会话 B 中再次读取数据，结果仍然为 1000\nSELECT * FROM accounts WHERE name='练习伴侣二';\n\n-- 会话 C 中回滚事务\nROLLBACK;\n-- 会话 B 中再次读取数据，结果仍然为 1000\nSELECT * FROM accounts WHERE name='练习伴侣二';\n```\n\n\n但会出现不可重复读的问题：事务B 第一次读取某行数据值为X，期间事务C修改该数据为Y并提交，事务B 再次读取时发现值变为Y，导致两次读取结果不一致。\n\n\n```sql\n-- 会话 B 修改为读已提交\nSET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;\n\n-- 执行第一次查询 1000\nSTART TRANSACTION;\nSELECT * FROM accounts WHERE name='练习伴侣二';\n\n-- 会话 C 中，设置隔离级别为读已提交\nSET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;\n-- 在会话 C 中更新数据并提交\nSTART TRANSACTION;\nUPDATE accounts SET balance = balance + 200 WHERE name='练习伴侣二';\n-- 会话 C 提交事务\nCOMMIT;\n\n-- 会话 B 中再次读取数据，结果仍然为 1200\nSELECT * FROM accounts WHERE name='练习伴侣二';\n```\n\n\n可以通过升级隔离级别为可重复读来解决不可重复读的问题。\n\n\n```sql\n-- 会话 B 修改为可重复读\nSET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;\n\n-- 开始事务并执行第一次查询 1000\nSTART TRANSACTION;\nSELECT * FROM accounts WHERE name='练习伴侣二';\n\n-- 会话 C 中，设置隔离级别为可重复读\nSET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;\n-- 在会话 C 中更新数据并提交\nSTART TRANSACTION;\nUPDATE accounts SET balance = balance + 200 WHERE name='练习伴侣二';\n-- 会话 C 提交事务\nCOMMIT;\n\n-- 会话 B 中再次读取数据，结果仍然为 1000\nSELECT * FROM accounts WHERE name='练习伴侣二';\n```\n\n\n但可重复读级别下仍然会出现幻读的问题：事务B 第一次查询获得 2条数据，事务C 新增 1条数据并提交后，事务B 再次查询时仍然为 2 条数据，但可以更新新增的数据，再次查询时就发现有 3 条数据了。\n\n\n```sql\n-- 会话 B 修改为可重复读\nSET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;\n-- 执行第一次查询，查到 2 条记录\nSTART TRANSACTION;\nSELECT * FROM accounts WHERE balance > 1000;\n\n-- 会话 C 中，设置隔离级别为可重复读\nSET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;\n-- 在会话 C 中新增数据并提交\nSTART TRANSACTION;\nINSERT INTO accounts (name, balance) VALUES ('练习伴侣五', 4000);\n-- 会话 C 提交事务\nCOMMIT;\n\n-- 会话 B 中再次读取数据，结果仍然为 2 条\nSELECT * FROM accounts WHERE balance > 1000;\n-- 会话 B 中尝试更新练习伴侣五的余额为 5000，竟然成功了\nUPDATE accounts SET balance = 5000 WHERE name='练习伴侣五';\n-- 会话 B 中再次读取数据，发现 3 条记录\nSELECT * FROM accounts WHERE balance > 1000;\n```\n\n\n可以通过升级隔离级别为串行化来解决幻读的问题。\n\n\n```sql\n-- 会话 B 修改为可串行化\nSET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;\n-- 执行第一次查询，查到 2 条记录\nSTART TRANSACTION;\nSELECT * FROM accounts WHERE balance > 1000;\n\n-- 会话 C 中，设置隔离级别为可串行化\nSET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;\n-- 在会话 C 中新增数据，会卡住\nSTART TRANSACTION;\nINSERT INTO accounts (name, balance) VALUES ('练习伴侣五', 4000);\n-- 只有等会话 B 提交事务后会话 C 才会继续执行并提交事务\nCOMMIT;\n```\n\n\n| 隔离级别 | 是否会脏读 | 是否会不可重复读 | 是否会幻读 |\n| --- | --- | --- | --- |\n| Read Uncommitted（读未提交） | ✅ 可能 | ✅ 可能 | ✅ 可能 |\n| Read Committed（读已提交） | ❌ 不会 | ✅ 可能 | ✅ 可能 |\n| Repeatable Read（可重复读） | ❌ 不会 | ❌ 不会 | ✅ 可能（但 InnoDB 已解决） |\n| Serializable（可串行化） | ❌ 不会 | ❌ 不会 | ❌ 不会 |\n\n---- 这部分是帮助大家理解 end，面试中可不背 ----\n\n简短回答：多个并发事务之间需要相互隔离，即一个事务的执行不能被其他事务干扰。\n\n#### [详细说一下持久性？](#详细说一下持久性)\n\n持久性确保事务一旦提交，它对数据所做的更改就是永久性的，即使系统发生崩溃，数据也能恢复到最近一次提交的状态。\n\nMySQL 的持久性是通过 InnoDB 引擎的 redo log 实现的。在事务提交时，InnoDB 会先将修改操作写入 redo log，并刷盘持久化。崩溃后，InnoDB 会通过 redo log 恢复数据，从而保证事务提交成功的数据不会丢失。\n\n\n\n简短回答：一旦事务提交，则其所做的修改将永久保存到 MySQL 中。即使发生系统崩溃，修改的数据也不会丢失。"
+ },
+ {
+ "id": 396,
+ "question": "ACID 靠什么保证的呢？",
+ "answer": "一句话总结：\n\nACID 中的原子性主要通过 Undo Log 来实现，持久性通过 Redo Log 来实现，隔离性由 MVCC 和锁机制来实现，一致性则由其他三大特性共同保证。\n\n\n\n#### [详细说说如何保证原子性？](#详细说说如何保证原子性)\n\n事务对数据进行修改前，会记录一份快照到 Undo Log，如果事务中有任何一步执行失败，系统会读取 Undo Log 将所有操作回滚，恢复到事务开始前的状态，从而保证事务要么全部成功，要么全部失败。\n\n\n```sql\n1）BEGIN;\n\n2）UPDATE user SET balance = balance - 100 WHERE id = 1;\n => 写入 Undo Log：记录 id=1 的原始余额 500\n\n3）UPDATE user SET balance = balance + 100 WHERE id = 2;\n => 写入 Undo Log：记录 id=2 的原始余额 300\n\n4）COMMIT;\n => 清空 Undo Log，事务成功\n\n❗如果失败：\n => 执行 ROLLBACK：根据 Undo Log 把数据还原！\n```\n\n\n#### [详细说说如何保证持久性？](#详细说说如何保证持久性)\n\nMySQL 的持久性主要由预写 Redo Log、双写机制、两阶段提交以及 Checkpoint 刷盘机制共同保证。\n\n当事务提交时，MySQL 会先将事务的修改操作写入 Redo Log，并强制刷盘，然后再将内存中的数据页刷入磁盘。这样即使系统崩溃，重启后也能通过 Redo Log 重放恢复数据。\n\n\n\n在将数据页写入到磁盘时，如果发生崩溃，可能会导致数据页不完整。InnoDB 的数据页大小为16KB，通常大于操作系统的 4KB页大小。\n\n为了解决只写入部分的问题，MySQL 采用了双写机制，脏盘刷页时，先将数据页写入到一个双写缓冲区中，2M 的连续空间，然后再将其写入到磁盘的实际位置。\n\n\n\n崩溃恢复时，如果发现数据页不完整，会从双写缓冲区中恢复副本，确保数据页的完整性。\n\n在涉及主从复制时，MySQL 通过两阶段提交保证 Redo Log 和 Binlog 的一致性：第一阶段，写入 Redo Log 并标记为 prepare 状态；第二阶段，写入 Binlog 再提交 Redo Log 为 commit 状态。\n\n\n\n崩溃恢复时，如果发现 Redo Log 是 prepare 但 Binlog 完整，则会提交事务；反之会回滚，避免主从不一致。\n\n另外，由于 Redo Log 的容量有限，Checkpoint 机制会定期将内存中的脏页刷到磁盘，这样能减少崩溃恢复时需要处理的 Redo Log 数量。\n\n\n\n#### [详细说说如何保证隔离性？](#详细说说如何保证隔离性)\n\n隔离性主要通过锁机制和 MVCC 来实现。\n\n比如说一个事务正在修改某条数据时，MySQL 会通过临键锁来防止其他事务同时进行修改，避免数据冲突。\n\n\n\n同时，临键锁可以防止幻读现象的发生。比如事务 A 查询 `id > 10` 的记录，那么临键锁不仅会锁住 id=10 的行，还会锁住 10 后面的“间隙”，防止其他事务插入 id=15 的数据。\n\n假如表中的主键有 `id: 5, 10, 15, 20, 25`，那么 InnoDB 会对以下区间和记录加锁：\n\n| 加锁对象 | 类型 | 锁定含义 |\n| --- | --- | --- |\n| `(10, 15]` | 临键锁 | 锁住 id=15 和前间隙，防止插入11~14 |\n| `(15, 20]` | 临键锁 | 锁住了 id=20 和前间隙 |\n| `(20, 25]` | 临键锁 | 锁住了 id=25 和前间隙 |\n| `(25, +∞)` | 间隙锁 | 锁住尾部防止插入30等 |\n\nMVCC 主要用来优化读操作，通过保存数据的历史版本，让读操作不需要加锁就能直接读取快照，提高读的并发性能。\n\n\n\n不同的隔离级别对应不同的实现策略，比如说在可重复读隔离级别下，事务第一次查询时会生成一个 Read View，之后所有读操作都复用这个视图，保证多次读取的结果一致。\n\n#### [如何保证一致性呢？](#如何保证一致性呢)\n\nMySQL 的一致性并不是靠某一个机制单独保证的，而是原子性、隔离性和持久性协同作用的结果。\n\n#### [事务会不会自动提交？](#事务会不会自动提交)\n\n是的，MySQL 默认开启了事务自动提交模式。\n\n每条单独的 SQL 语句都会被视为一个独立的事务处理单元；SQL 语句执行成功后会自动执行 COMMIT；执行失败时会自动 ROLLBACK。\n\n可通过 `SELECT @@autocommit;` 查看当前会话的自动提交状态。\n\n\n\n如果需要执行多条 SQL 语句，可以将它们放在一个事务中，使用 `START TRANSACTION` 开启事务，执行完所有 SQL 语句后手动提交。\n\n\n```sql\nSTART TRANSACTION;\nUPDATE accounts SET balance = balance - 100 WHERE user_id = 1;\nUPDATE accounts SET balance = balance + 100 WHERE user_id = 2;\nCOMMIT;\n```"
+ },
+ {
+ "id": 397,
+ "question": "事务的隔离级别有哪些？",
+ "answer": "隔离级别定义了一个事务可能受其他事务影响的程度，MySQL 支持四种隔离级别，分别是：读未提交、读已提交、可重复读和串行化。\n\n\n\n读未提交会出现脏读，读已提交会出现不可重复读，可重复读是 InnoDB 默认的隔离级别，可以避免脏读和不可重复读，但会出现幻读。不过通过 MVCC 和临键锁，能够防止大多数并发问题。\n\n串行化最安全，但性能较差，通常不推荐使用。\n\n#### [详细说说读未提交？](#详细说说读未提交)\n\n事务可以读取其他未提交事务修改的数据。也就是说，如果未提交的事务一旦回滚，读取到的数据就会变成了“脏数据”，通常不会使用。\n\n\n\n#### [什么是读已提交？](#什么是读已提交)\n\n读已提交避免了脏读，但可能会出现不可重复读，即同一事务内多次读取同一数据结果会不同，因为其他事务提交的修改，对当前事务是可见的。\n\n\n\n是 Oracle、SQL Server 等数据库的默认隔离级别。\n\n#### [什么是可重复读？](#什么是可重复读)\n\n可重复读能确保同一事务内多次读取相同数据的结果一致，即使其他事务已提交修改。\n\n\n\n是 MySQL 默认的隔离级别，避免了“脏读”和“不可重复读”，通过 MVCC 和临键锁也能在一定程度上避免幻读。\n\n\n```sql\n-- Session A:\nSTART TRANSACTION;\nSELECT balance FROM accounts WHERE id=1; --返回500\n\n-- Session B:\nUPDATE accounts SET balance = balance +100 WHERE id=1;\nCOMMIT;\n\n-- Session A再次查询:\nSELECT balance FROM accounts WHERE id=1; --仍返回500(可重复读)\n\n-- Session A更新后查询:\nUPDATE accounts SET balance = balance +50 WHERE id=1; --基于最新值550更新为600 \nSELECT balance FROM accounts WHERE id=1; --返回600\n```\n\n\n#### [什么是串行化？](#什么是串行化)\n\n串行化是最高的隔离级别，通过强制事务串行执行来解决“幻读”问题。\n\n\n\n但会导致大量的锁竞争问题，实际应用中很少用。\n\n#### [A 事务未提交，B 事务上查询到的是旧值还是新值？](#a-事务未提交-b-事务上查询到的是旧值还是新值)\n\n如果 B 是普通的 SELECT，也就是快照读，它读的是旧值，即事务 A 修改前的快照，并且不会阻塞；如果 B 是当前读，比如 `SELECT … FOR UPDATE`，它会被阻塞直到事务 A 提交或回滚。\n\n\n```sql\n-- 会话 A 中，更新练习伴侣二的余额\nSTART TRANSACTION;\nUPDATE accounts SET balance = 8000 WHERE name = '练习伴侣二';\n-- 此时并没有 COMMIT\n\n-- 会话 B 中查询练习伴侣二的余额\nSELECT * FROM accounts WHERE name = '练习伴侣二';\n-- 会话 B 会读取到 旧值 1000\n\n-- 会话 C 中使用当前读查询练习伴侣二的余额\nSELECT * FROM accounts WHERE name = '练习伴侣二' FOR UPDATE;\n-- 会话 C 会被阻塞，直到会话 A 提交或回滚\n```\n\n\n#### [怎么更改事务的隔离级别？](#怎么更改事务的隔离级别)\n\nMySQL 支持通过 SET 语句修改事务隔离级别，包括全局级别、当前会话，但一般不建议在生产环境中随意修改隔离级别。\n\n测试环境下可以使用 `SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;` 可以修改当前会话的隔离级别。\n\n使用 `SET GLOBAL TRANSACTION ISOLATION LEVEL READ COMMITTED;` 可以修改全局隔离级别，影响新的连接，但不会改变现有会话。"
+ },
+ {
+ "id": 398,
+ "question": "事务的隔离级别是如何实现的？",
+ "answer": "读未提交通过行锁共享锁确保一个事务在更新行数据但没有提交的情况下，其他事务不能更新该行数据，但不会阻止脏读，意味着事务2 可以在事务1 提交之前读取到事务1 修改的数据。\n\n\n\n读已提交会在更新数据前加行级排他锁，不允许其他事务写入或者读取未提交的数据，也就意味着事务2 不能在事务 1 提交之前读取到事务1 修改的数据，从而解决脏读的问题。\n\n\n\n另外，读已提交会在每次读取数据前都生成一个新的 ReadView，所以会出现不可重复读的问题。\n\n可重复读只在第一次读操作时生成 ReadView，后续读操作都会使用这个 ReadView，从而避免不可重复读的问题。\n\n另外，对于当前读操作，可重复读会通过临键锁来锁住当前行和前间隙，防止其他事务在这个范围内插入数据，从而避免幻读的问题。\n\n\n\n串行化级别下，事务在读操作时，会先加表级共享锁；在写操作时，会先加表级排他锁。\n\n直到事务结束后才释放锁，这样就能确保事务之间不会相互干扰。"
+ },
+ {
+ "id": 399,
+ "question": "请详细说说幻读呢？",
+ "answer": "幻读是指在同一个事务中，多次执行相同的范围查询，结果却不同。这种现象通常发生在其他事务在两次查询之间插入或删除了符合当前查询条件的数据。\n\n\n\n---- 这部分是帮助大家理解 start，面试中可以不背 ----\n\n比如说事务 A 在第一次查询某个条件范围的数据行后，事务 B 插入了一条新数据且符合条件范围，事务 A 再次查询时，发现多了一条数据。\n\n我们来验证一下，先创建测试表，插入测试数据。\n\n\n```sql\nCREATE TABLE `user_info` (\n `id` BIGINT(20) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '主键id',\n `name` VARCHAR(32) NOT NULL DEFAULT '' COMMENT '姓名',\n `gender` VARCHAR(32) NOT NULL DEFAULT '' COMMENT '性别',\n `email` VARCHAR(32) NOT NULL DEFAULT '' COMMENT '邮箱',\n PRIMARY KEY (`id`)\n) ENGINE=INNODB DEFAULT CHARSET=utf8mb4 COMMENT='用户信息表';\n\n-- 插入测试数据\nINSERT INTO `user_info` (`id`, `name`, `gender`, `email`) VALUES \n (1, 'Curry', '男', 'curry@163.com'),\n (2, 'Wade', '男', 'wade@163.com'),\n (3, 'James', '男', 'james@163.com');\n\nCOMMIT;\n```\n\n\n然后我们在事务 A 中执行查询 `SELECT * FROM user_info WHERE id > 1;`，在事务 B 中插入数据 `INSERT INTO user_info (name, gender, email) VALUES ('wanger', '女', 'wanger@163.com');`，再在事务 A 中修改刚刚插入的数据 `update user_info set gender='男' where id = 4;`，最后在事务 A 中再次查询 `SELECT * FROM user_info WHERE id > 1;`。\n\n\n\n---- 这部分是帮助大家理解 end，面试中可以不背 ----\n\n#### [如何避免幻读？](#如何避免幻读)\n\nMySQL 在可重复读隔离级别下，通过 MVCC 和临键锁可以在一定程度上避免幻读。\n\n比如说在查询时显示加锁，利用临键锁锁定查询范围，防止其他事务插入新的数据。\n\n\n```sql\nSTART TRANSACTION;\nSELECT * FROM user_info WHERE id > 1 FOR UPDATE; -- 加临键锁\nCOMMIT;\n```\n\n\n其他事务在插入数据时，会被阻塞，直到当前事务提交或回滚。\n\n\n\n---- 这部分是帮助大家理解 start，面试中可以不背 ----\n\n解释一下。\n\n如果查询语句中包含显式加锁（如 `FOR UPDATE`），InnoDB 会使用当前读，直接读取最新的数据，并加锁。\n\n在范围查询时，InnoDB 不仅会对符合条件的记录加行锁，还会对相邻的索引间隙加间隙锁，从而形成临键锁。\n\n\n\n临键锁可以防止其他事务在间隙中插入新数据，从而避免幻读。\n\n---- 这部分是帮助大家理解 end，面试中可以不背 ----\n\n比如说在执行查询的事务中，不要尝试去更新其他事务插入/删除的数据，利用快照读来避免幻读。\n\n\n\n---- 这部分是帮助大家理解 start，面试中可以不背 ----\n\n使用 SELECT 查询时，如果没有显式加锁，InnoDB 会使用 MVCC 提供一致性视图。\n\n每个事务在启动时都会生成一个 Read View，用来确定哪些数据对当前事务可见。\n\n\n\n其他事务在当前事务启动后插入的新数据不会被当前事务看到，因此不会出现幻读。\n\n---- 这部分是帮助大家理解 end，面试中可以不背 ----\n\n#### [什么是当前读呢？](#什么是当前读呢)\n\n当前读是指读取记录的最新已提交版本，并且在读取时对记录加锁，确保其他并发事务不能修改当前记录。\n\n比如 `SELECT ... LOCK IN SHARE MODE`、`SELECT ... FOR UPDATE`，以及 UPDATE、DELETE，都属于当前读。\n\n#### [为什么 UPDATE 和 DELETE 也属于当前读？](#为什么-update-和-delete-也属于当前读)\n\n因为更新、删除这些操作，本质上不仅是写操作，还需要在写之前读取数据，然后才能修改或删除。为了保证修改的是最新的数据，并防止并发冲突，InnoDB 必须读取最新版本的数据并加锁，因此 UPDATE 和 DELETE 也属于当前读。\n\n\n\n| SQL语句 | 是否当前读 | 是否加锁 |\n| --- | --- | --- |\n| `SELECT * FROM user WHERE id=1` | ❌ 否 | ❌ 否 |\n| `SELECT * FROM user WHERE id=1` FOR UPDATE | ✅ 是 | ✅ 加排他锁 |\n| `SELECT * FROM user WHERE id=1 LOCK IN SHARE MODE` | ✅ 是 | ✅ 加共享锁 |\n| `UPDATE user SET ... WHERE id=1` | ✅ 是 | ✅ 加排他锁 |\n| `DELETE FROM user WHERE id=1` | ✅ 是 | ✅ 加排他锁 |\n\n#### [什么是快照读呢？](#什么是快照读呢)\n\n快照读是 InnoDB 通过 MVCC 实现的一种非阻塞读方式。当事务执行 SELECT 查询时，InnoDB 并不会直接读当前最新的数据，而是根据事务开始时生成的 Read View 去判断每条记录的可见性，从而读取符合条件的历史版本。\n\n\n\n| SQL | 是否快照读？ | 说明 |\n| --- | --- | --- |\n| `SELECT * FROM t WHERE id=1` | ✅ 是 | 快照读 |\n| `SELECT * FROM t WHERE id=1 FOR UPDATE` | ❌ 否 | 当前读，读取最新版本并加锁 |\n| `UPDATE / DELETE` | ❌ 否 | 当前读，必须读取当前版本并加锁 |\n| `INSERT` | ❌ 否 | 写操作，不存在历史版本 |"
+ },
+ {
+ "id": 400,
+ "question": "MVCC 了解吗？",
+ "answer": "MVCC 指的是多版本并发控制，每次修改数据时，都会生成一个新的版本，而不是直接在原有数据上进行修改。并且每个事务只能看到在它开始之前已经提交的数据版本。\n\n\n\n这样的话，读操作就不会阻塞写操作，写操作也不会阻塞读操作，从而避免加锁带来的性能损耗。\n\n其底层实现主要依赖于 Undo Log 和 Read View。\n\n每次修改数据前，先将记录拷贝到Undo Log，并且每条记录会包含三个隐藏列，DB\\_TRX\\_ID 用来记录修改该行的事务 ID，DB\\_ROLL\\_PTR 用来指向 Undo Log 中的前一个版本，DB\\_ROW\\_ID 用来唯一标识该行数据（仅无主键时生成）。\n\n\n\n每次读取数据时，都会生成一个 ReadView，其中记录了当前活跃事务的 ID 集合、最小事务 ID、最大事务 ID 等信息，通过与 DB\\_TRX\\_ID 进行对比，判断当前事务是否可以看到该数据版本。\n\n\n\n#### [请详细说说什么是版本链？](#请详细说说什么是版本链)\n\n版本链是指 InnoDB 中同一条记录的多个历史版本，通过 DB\\_ROLL\\_PTR 字段将它们像链表一样串起来，用来支持 MVCC 的快照读。\n\n\n\n假设有一张`hero`表，表中有这样一行记录，name 为张三，city 为帝都，插入这行记录的事务 id 是 80。\n\n此时，`DB_TRX_ID`的值就是 80，`DB_ROLL_PTR`的值就是指向这条 insert undo 日志的指针。\n\n\n\n接下来，如果有两个`DB_TRX_ID`分别为`100`、`200`的事务对这条记录进行了`update`操作，那么这条记录的版本链就会变成下面这样：\n\n\n\n也就是说，当更新一行数据时，InnoDB 不会直接覆盖原有数据，而是创建一个新的数据版本，并更新 DB\\_TRX\\_ID 和 DB\\_ROLL\\_PTR，使它们指向前一个版本和相关的 undo 日志。\n\n这样，老版本的数据就不会丢失，可以通过版本链找到。\n\n由于 undo 日志会记录每一次的 update，并且新插入的行数据会记录上一条 undo 日志的指针，所以可以通过 DB\\_ROLL\\_PTR 这个指针找到上一条记录，这样就形成了一个版本链。\n\n\n\n#### [请详细说说什么是ReadView？](#请详细说说什么是readview)\n\nReadView 是 InnoDB 为每个事务创建的一份“可见性视图”，用于判断在执行快照读时，哪些数据版本是当前这个事务可以看到的，哪些不能看到。\n\n\n\n当事务开始执行时，InnoDB 会为该事务创建一个 ReadView，这个 ReadView 会记录 4 个重要的信息：\n\n* creator\\_trx\\_id：创建该 ReadView 的事务 ID。\n* m\\_ids：所有活跃事务的 ID 列表，活跃事务是指那些已经开始但尚未提交的事务。\n* min\\_trx\\_id：所有活跃事务中最小的事务 ID。它是 m\\_ids 数组中最小的事务 ID。\n* max\\_trx\\_id ：事务 ID 的最大值加一。换句话说，它是下一个将要生成的事务 ID。\n\n#### [ReadView 是如何判断记录的某个版本是否可见的？](#readview-是如何判断记录的某个版本是否可见的)\n\n会通过三个步骤来判断：\n\n\n\n①、如果某个数据版本的 DB\\_TRX\\_ID 小于 min\\_trx\\_id，则该数据版本在生成 ReadView 之前就已经提交，因此对当前事务是可见的。\n\n②、如果 DB\\_TRX\\_ID 大于 max\\_trx\\_id，则表示创建该数据版本的事务在生成 ReadView 之后开始，因此对当前事务不可见。\n\n③、如果 DB\\_TRX\\_ID 在 min\\_trx\\_id 和 max\\_trx\\_id 之间，需要判断 DB\\_TRX\\_ID 是否在 m\\_ids 列表中：\n\n* 不在，表示创建该数据版本的事务在生成 ReadView 之后已经提交，因此对当前事务也是可见的。\n* 在，表示事务仍然活跃，或者在当前事务生成 ReadView 之后才开始，因此是不可见的。\n\n\n\n举个实际的例子。\n\n读事务开启了一个 ReadView，这个 ReadView 里面记录了当前活跃事务的 ID 列表（444、555、665），以及最小事务 ID（444）和最大事务 ID（666）。当然还有自己的事务 ID 520，也就是 creator\\_trx\\_id。\n\n它要读的这行数据的写事务 ID 是 x，也就是 DB\\_TRX\\_ID。\n\n* 如果 x = 110，显然在 ReadView 生成之前就提交了，所以这行数据是可见的。\n* 如果 x = 667，显然是未知世界，所以这行数据对读操作是不可见的。\n* 如果 x = 519，虽然 519 大于 444 小于 666，但是 519 不在活跃事务列表里，所以这行数据是可见的。因为 519 是在 520 生成 ReadView 之前就提交了。\n* 如果 x = 555，虽然 555 大于 444 小于 666，但是 555 在活跃事务列表里，所以这行数据是不可见的。因为 555 不确定有没有提交。\n\n#### [可重复读和读已提交在 ReadView 上的区别是什么？](#可重复读和读已提交在-readview-上的区别是什么)\n\n可重复读：在第一次读取数据时生成一个 ReadView，这个 ReadView 会一直保持到事务结束，这样可以保证在事务中多次读取同一行数据时，读取到的数据是一致的。\n\n\n\n读已提交：每次读取数据前都生成一个 ReadView，这样就能保证每次读取的数据都是最新的。\n\n#### [如果两个 AB 事务并发修改一个变量，那么 A 读到的值是什么，怎么分析。](#如果两个-ab-事务并发修改一个变量-那么-a-读到的值是什么-怎么分析。)\n\n事务 A 在读取时是否能读到事务 B 的修改，取决于 A 是快照读还是当前读。如果是快照读，InnoDB 会使用 MVCC 的 ReadView 判断记录版本是否可见，若事务 B 尚未提交或在 A 的视图不可见，则 A 会读到旧值；如果是当前读，则需要加锁，若 B 已提交可直接读取，否则 A 会阻塞直到 B 结束。"
+ }
+ ]
+ },
+ {
+ "id": 59,
+ "categoryName": "高可用",
+ "questions": [
+ {
+ "id": 401,
+ "question": "MySQL数据库读写分离了解吗？",
+ "answer": "读写分离就是把“写操作”交给主库处理，“读操作”分给多个从库处理，从而提升系统并发性能。\n\n\n\n应用层通过中间件（如 MyCat、ShardingSphere）自动路由请求，将 INSERT / UPDATE / DELETE 等写操作发送给主库，将 SELECT 查询操作发送给从库。\n\n\n```sql\n// 示例：Java中通过不同数据源切换\n@Transactional\npublic void updateOrder(Order order) {\n masterDataSource.update(order); // 写操作走主库\n}\n\npublic Order getOrderById(Long id) {\n return slaveDataSource.query(id); // 读操作走从库\n}\n```\n\n\n主库将数据变更通过 binlog 同步到从库，从而保持数据一致性。\n\n\n\n主库 dump\\_thread 线程通过 TCP 将 binlog 推送给从库，从库 io\\_thread 线程，接收主库 binlog，写入 relay log，从库 sql\\_thread 线程读取 relay log，并顺序执行 SQL 语句，更新从库数据。"
+ },
+ {
+ "id": 402,
+ "question": "读写分离的实现方式有哪些？",
+ "answer": "实现读写分离有三种方式：最简单的是在应用层手动控制主从数据源，适用于小型项目；\n\n\n\n中等项目是通过 Spring + 多数据源插件、AOP 注解自动路由；\n\n大型系统通常使用中间件，如 ShardingSphere、MyCat，支持自动路由、负载均衡、故障转移等功能。\n\n\n\nMycat 的读写分离功能依赖于 MySQL 的主从复制架构：\n\n* writeHost: 表示主节点，负责处理所有的 DML SQL 语句，如 INSERT、UPDATE 和 DELETE。\n* readHost: 表示从节点，负责处理查询 SQL 语句（如 SELECT），以实现读写分离。\n\n正常情况下，Mycat 会将第一个配置的 writeHost 作为默认的写节点。所有的 DML SQL 语句会被发送到此默认写节点执行。\n\n\n\n写节点完成数据写入后，通过 MySQL 的主从复制机制，将数据同步到所有从节点，确保主从数据一致性。"
+ },
+ {
+ "id": 403,
+ "question": "主从复制原理了解吗？",
+ "answer": "MySQL 的主从复制是一种数据同步机制，用于将数据从主数据库复制到一个或多个从数据库。\n\n\n\n主库执行事务提交时，将数据变更以事件形式记录到 Binlog。从库通过 I/O 线程从主库的 Binlog 中读取变更事件，并将这些事件写入到本地的中继日志文件中，SQL 线程会实时监控中继日志的内容，按顺序读取并执行这些事件，从而保证从库与主库数据一致。"
+ },
+ {
+ "id": 404,
+ "question": "主从同步延迟怎么处理？",
+ "answer": "主从同步延迟是因为从库需要先接收 binlog，再执行 SQL 才能同步主库数据，在高并发写或网络抖动时容易出现延迟，导致读写不一致。\n\n第一种解决方案：对一致性要求高的查询（如支付结果查询）可以直接走主库。\n\n\n```java\n// 伪代码示例\npublic Object query(String sql) {\n if(isWriteQuery(sql) || needStrongConsistency(sql)) {\n return masterDataSource.query(sql);\n } else {\n return slaveDataSource.query(sql);\n }\n}\n```\n\n\n第二种解决方案：对于非关键业务允许短暂数据不一致，可以提示用户“数据同步中，请稍后刷新”，然后借助异步通知机制替代实时查询。\n\n\n```java\n// 伪代码示例\npublic Object query(String sql) {\n if(isWriteQuery(sql)) {\n return masterDataSource.query(sql);\n } else {\n // 异步通知用户数据已更新\n notifyUser(\"数据同步中，请稍后刷新\");\n return slaveDataSource.query(sql);\n }\n}\n```\n\n\n第三种解决方案：采用半同步复制，主库在事务提交时，要等至少一个从库确认收到 binlog（但不要求执行完成），才算提交成功。\n\n\n\n#### [请说说半同步复制的流程？](#请说说半同步复制的流程)\n\n第一步，主库安装半同步插件：\n\n\n```sql\nINSTALL PLUGIN rpl_semi_sync_master SONAME 'semisync_master.so';\n```\n\n\n第二步，主库启用半同步复制并设置超时时间：\n\n\n```sql\nSET GLOBAL rpl_semi_sync_master_enabled = 1;\nSET GLOBAL rpl_semi_sync_master_timeout = 10000;\n```\n\n\n主库 my.cnf 配置示例：\n\n\n```ini\n[mysqld]\nplugin-load = \"rpl_semi_sync_master=semisync_master.so\"\nrpl_semi_sync_master_enabled = 1\nrpl_semi_sync_master_timeout = 10000\n# MySQL 5.7+建议使用无损模式\nrpl_semi_sync_master_wait_point = AFTER_SYNC\n```\n\n\n第三步，从库安装半同步插件：\n\n\n```sql\nINSTALL PLUGIN rpl_semi_sync_slave SONAME 'semisync_slave.so';\n```\n\n\n第四步，从库启用半同步复制：\n\n\n```sql\nSET GLOBAL rpl_semi_sync_slave_enabled = 1;\n```\n\n\n从库 my.cnf 配置示例：\n\n\n```ini\n[mysqld]\nplugin-load = \"rpl_semi_sync_slave=semisync_slave.so\"\nrpl_semi_sync_slave_enabled = 1\n```"
+ },
+ {
+ "id": 405,
+ "question": "你们一般是怎么分库的呢？",
+ "answer": "分库的策略有两种，第一种是垂直分库：按照业务模块将不同的表拆分到不同的库中，比如说用户、登录、权限等表放在用户库中，商品、分类、库存放在商品库中，优惠券、满减、秒杀放在活动库中。\n\n\n\n第二种是水平分库：按照一定的策略将一个表中的数据拆分到多个库中，比如哈希分片和范围分片，对用户 id 进行取模运算或者范围划分，将数据分散到不同的库中。\n\n\n\n贴一段使用 ShardingSphere 的 inline 算法定义分片规则：\n\n\n```yaml\nrules:\n- !SHARDING\n tables:\n order:\n actualDataNodes: db_${0..3}.order_${0..15}\n databaseStrategy:\n standard:\n shardingColumn: user_id\n shardingAlgorithmName: db_hash_mod\n tableStrategy:\n standard:\n shardingColumn: order_time\n shardingAlgorithmName: table_interval_yearly\n shardingAlgorithms:\n db_hash_mod:\n type: HASH_MOD\n props:\n sharding-count: 4\n table_interval_yearly:\n type: INTERVAL\n props:\n datetime-pattern: 'yyyy-MM-dd HH:mm:ss'\n datetime-lower: '2024-01-01 00:00:00'\n datetime-upper: '2025-01-01 00:00:00'\n sharding-suffix-pattern: 'yyyy'\n datetime-interval-amount: 1\n datetime-interval-unit: 'Years'\n```"
+ },
+ {
+ "id": 406,
+ "question": "那你们是怎么分表的？",
+ "answer": "当单表超过 500 万条数据，就可以考虑水平分表了。比如说我们可以将文章表拆分成多个表，如 article\\_0、article\\_9999、article\\_19999 等。\n\n\n\n在中，我们将文章的基本信息和内容详情做了垂直分表处理，因为文章的内容会占用比较大的空间，在只需要查看文章基本信息时把文章详情也带出来的话，就会占用更多的网络 IO 和内存导致查询变慢；而文章的基本信息，如标题、作者、状态等信息占用的空间较小，很适合不需要查询文章详情的场景。\n\n"
+ },
+ {
+ "id": 407,
+ "question": "水平分库分表的分片策略有哪几种？",
+ "answer": "常见的分片策略有三种，范围分片、Hash 分片和路由分片。\n\n范围分片是根据某个字段的值范围进行水平拆分。适用于分片键具有连续性的场景。\n\n\n\n比如说将 user\\_id 作为分片键：\n\n* 1 ~ 10000 → db1.user\\_1\n* 10001 ~ 20000 → db2.user\\_2\n\nHash 分片是指通过对分片键的值进行哈希取模，将数据均匀分布到多个库表中，适用于分片键具有离散性的场景。\n\n\n\n比如说我们一开始规划好了 4 个表，那么就可以简单地通过取模来实现分表：\n\n\n```java\npublic String getTableNameByHash(long userId) {\n int tableIndex = (int) (userId % 4);\n return \"user_\" + tableIndex;\n}\n```\n\n\n路由分片是通过路由配置来确定数据应该存储在哪个库表，适用于分片键不规律的场景。\n\n\n\n比如说我们可以通过 order\\_router 表来确定订单数据存储在哪个表中：\n\n| order\\_id | table\\_id |\n| --- | --- |\n| xxxx | table\\_1 |\n| yyyy | table\\_2 |\n| zzzz | table\\_3 |"
+ },
+ {
+ "id": 408,
+ "question": "不停机扩容怎么实现？",
+ "answer": "第一个阶段：新旧库同时写入，确保数据实时同步；可以借助消息队列实现异步补偿，幂等避免重复写入。读操作仍然走旧库。\n\n\n\n代码参考：\n\n\n```java\n@Transactional\npublic void createOrder(Order order) {\n oldDB.insert(order); // 写入旧库\n newDB.insert(order); // 写入新扩容节点\n kafka.send(\"data_sync\", order); // 异步补偿通道\n}\n```\n\n\n第二个阶段，通过 Canal 或者自研脚本将旧库的历史数据同步到新库。关键业务在查询时同时查询新旧库，进行数据校验，确保一致性。\n\n\n```java\npublic List getOrders(Long userId) {\n List orders = newDB.getOrders(userId);\n List oldOrders = oldDB.getOrders(userId);\n if (!orders.equals(oldOrders)) {\n // 数据不一致，进行补偿\n kafka.send(\"data_sync\", oldOrders);\n }\n}\n```\n\n\n第三个阶段，在确认新库数据一致性后，逐步将读请求切换到新库，然后下线旧库。\n\n"
+ },
+ {
+ "id": 409,
+ "question": "常用的分库分表中间件有哪些？",
+ "answer": "常用的分库分表中间件有 ShardingSphere 和 Mycat。\n\n①、ShardingSphere 最初由当当开源，后来贡献给了 Apache，其子项目 Sharding-JDBC 主要在 Java 的 JDBC 层提供额外的服务。无需额外部署和依赖，可理解为增强版的 JDBC 驱动，完全兼容 JDBC 和各种 ORM 框架。\n\n\n\n②、Mycat 是由阿里巴巴的一款产品 Cobar 衍生而来，可以把它看作一个数据库代理。\n\n"
+ },
+ {
+ "id": 410,
+ "question": "你觉得分库分表会带来什么问题呢？",
+ "answer": "第一，跨库事务无法依赖单机 MySQL 的 ACID 特性，需要使用分布式事务解决方案，如 Seata 的 AT 模式、TCC 模式等。\n\n\n\n第二，跨库后无法使用 JOIN 联表查询。可以在业务层进行拼接，或者把需要联表查询的数据放到 ES 中。\n\n\n```java\n// Java 代码示例\nUser user = userService.getUserById(1);\nList orders = orderService.getOrdersByUserId(1);\n```\n\n\n第三，自增 ID 在分片场景下容易冲突，需要使用全局唯一方案。\n\n数据库表被切分后，不能再依赖数据库自身的主键生成机制，所以需要一些手段来保证全局主键唯一。比如说雪花算法、京东的 JD-hotkey。\n\n\n\n#### [你们项目中的分布式主键 id 是怎么生成的？](#你们项目中的分布式主键-id-是怎么生成的)\n\n在项目中，我们在雪花算法的基础上实现了一套自定义的 ID 生成方案，通过更改时间戳单位、ID 长度、workId 与 dataCenterId 的分配比例，ID 生成的延迟降低了 20%；满足了分布式环境下 ID 的唯一性。\n\n#### [雪花算法具体是怎么实现的？](#雪花算法具体是怎么实现的)\n\n雪花算法是 Twitter 开源的分布式 ID 生成算法，其核心思想是：使用一个 64 位的数字来作为全局唯一 ID。\n\n* 第 1 位是符号位，永远是 0，表示正数。\n* 接下来的 41 位是时间戳，记录的是当前时间戳减去一个固定的开始时间戳，可以使用 69 年。\n* 然后是 10 位的工作机器 ID。\n* 最后是 12 位的序列号，每毫秒最多可生成 4096 个 ID。\n\n大致的实现代码如下所示：\n\n\n```java\npublic class SnowflakeIdGenerator {\n private long datacenterId = 1L; // 数据中心ID\n private long machineId = 1L; // 机器ID\n private long sequence = 0L; // 序列号\n\n private long lastTimestamp = -1L;\n\n public synchronized long nextId() {\n long timestamp = System.currentTimeMillis();\n if (timestamp == lastTimestamp) {\n sequence = (sequence + 1) & 4095;\n if (sequence == 0) {\n while (timestamp == lastTimestamp) {\n timestamp = System.currentTimeMillis();\n }\n }\n } else {\n sequence = 0;\n }\n\n lastTimestamp = timestamp;\n\n return ((timestamp - 1609459200000L) << 22) | (datacenterId << 17) | (machineId << 12) | sequence;\n }\n}\n```"
+ }
+ ]
+ },
+ {
+ "id": 60,
+ "categoryName": "运维",
+ "questions": [
+ {
+ "id": 411,
+ "question": "百万级别以上的数据如何删除？",
+ "answer": "在处理百万级别的数据删除时，大范围的 DELETE 语句往往会造成锁表时间长、事务日志膨胀等问题。\n\n可以采用批量删除的方案，将删除操作分成多个小批次进行处理。\n\n\n```java\npublic void batchDelete(String tableName, String condition, int batchSize) {\n // 1. 创建线程池\n int threadCount = Runtime.getRuntime().availableProcessors();\n ExecutorService executor = Executors.newFixedThreadPool(threadCount);\n CountDownLatch latch = new CountDownLatch(threadCount);\n\n // 2. 获取总记录数\n long totalCount = getTotalCount(tableName, condition);\n \n // 3. 计算每个线程处理的数据量\n long perThreadCount = totalCount / threadCount;\n \n // 4. 分配任务给线程池\n for (int i = 0; i < threadCount; i++) {\n long startId = i * perThreadCount;\n long endId = (i == threadCount - 1) ? totalCount : (startId + perThreadCount);\n \n executor.execute(() -> {\n try {\n // 分批次删除数据\n for (long j = startId; j < endId; j += batchSize) {\n String deleteSql = String.format(\n \"DELETE FROM %s WHERE %s LIMIT %d\",\n tableName, condition, batchSize\n );\n // 执行删除\n jdbcTemplate.update(deleteSql);\n }\n } finally {\n latch.countDown();\n }\n });\n }\n \n // 5. 等待所有线程完成\n latch.await();\n executor.shutdown();\n}\n```\n\n\n也可以采用创建新表替换原表的方式，把需要保留的数据迁移到新表中，然后删除旧表。\n\n简单的方案：\n\n\n```sql\n-- 1. 创建新表结构(包含索引)\nCREATE TABLE new_table LIKE large_table;\n\n-- 2. 插入需要保留的数据\nINSERT INTO new_table \nSELECT * FROM large_table WHERE condition;\n\n-- 3. 重命名表\nRENAME TABLE large_table TO old_table, new_table TO large_table;\n\n-- 4. 删除旧表\nDROP TABLE old_table;\n```\n\n\n加入检查表空间、分批导入数据、验证数据一致性等步骤：\n\n\n```sql\n-- 1. 在执行之前先检查空间是否足够\nSELECT table_schema, \n table_name, \n round(((data_length + index_length) / 1024 / 1024), 2) \"Size in MB\"\nFROM information_schema.TABLES \nWHERE table_schema = DATABASE()\nAND table_name = 'large_table';\n\n-- 2. 创建新表\nCREATE TABLE new_table LIKE large_table;\n\n-- 3. 分批导入数据（避免一次性导入过多数据）\nSET @batch = 1;\nSET @batch_size = 10000;\nSET @total = (SELECT COUNT(*) FROM large_table WHERE condition);\n\nREPEAT\n INSERT INTO new_table \n SELECT * FROM large_table \n WHERE condition\n LIMIT @batch_size;\n \n SET @batch = @batch + 1;\nUNTIL @batch * @batch_size > @total END REPEAT;\n\n-- 4. 验证数据一致性\nSELECT COUNT(*) FROM new_table;\nSELECT COUNT(*) FROM large_table WHERE condition;\n\n-- 5. 在业务低峰期执行表切换\nRENAME TABLE large_table TO old_table, \n new_table TO large_table;\n\n-- 6. 确认无误后再删除旧表（建议不要立即删除）\n-- DROP TABLE old_table;\n```"
+ },
+ {
+ "id": 412,
+ "question": "千万级大表如何添加字段？",
+ "answer": "在低版本的 MySQL 中，千万级数据量的表中添加字段时，直接使用 `ALTER TABLE` 命令会导致长时间锁表、甚至数据库崩溃等。\n\n可以使用 Percona Toolkit 的 pt-online-schema-change 来完成，它通过创建临时表、逐步同步数据并使用触发器捕获变更来实现。\n\n\n```bash\npt-online-schema-change --alter \"ADD COLUMN new_column datatype\" D=database,t=your_table --execute\n```\n\n\n对于 MySQL 8.0+ 版本，可以直接通过 `ALTER TABLE` 来完成，因为加入了 INSTAN 算法，添加列并不会长时间锁表。\n\n\n```sql\nALTER TABLE your_table ADD COLUMN new_column datatype;\n```\n\n\n如果没有指定 `ALGORITHM=INSTANT` 算法，MySQL 会先尝试 INSTANT 算法；如果无法完成，会切换到 INPLACE 算法；如果仍然无法完成，会尝试 COPY 算法。\n\n"
+ },
+ {
+ "id": 413,
+ "question": "MySQL 导致 cpu 飙升的话，要怎么处理呢？",
+ "answer": "我通常先通过 top 命令确认是否是 mysqld 的进程占用。\n\n\n\n然后通过 `SHOW PROCESSLIST` 和慢查询日志定位是否存在耗时 SQL，再配合 explain 和 performance\\_schema 分析 SQL 是否命中索引，是否存在临时表和排序。\n\n\n```sql\n-- 使用 EXPLAIN 分析SQL执行计划\nEXPLAIN SELECT * FROM large_table WHERE condition;\n\n-- 查看表的索引使用情况\nSHOW INDEX FROM table_name;\n\n-- 查看InnoDB状态\nSHOW ENGINE INNODB STATUS;\n\n-- 查看表的统计信息\nANALYZE TABLE table_name;\n```\n\n\n最终通过 SQL 优化、加索引、分批操作等手段逐步优化。"
+ }
+ ]
+ },
+ {
+ "id": 61,
+ "categoryName": "SQL 题",
+ "questions": [
+ {
+ "id": 414,
+ "question": "一张表：id，name，age，sex，class，sql 语句：所有年龄为 18 的人的名字？找到每个班年龄大于 18 有多少人？找到每个班年龄排前两名的人？（补充）",
+ "answer": "> 建议大家在本地建表，实操一下。 2024 年 04 月 11 日增补。\n\n第一步，建表：\n\n\n```sql\nCREATE TABLE students (\n id INT AUTO_INCREMENT PRIMARY KEY,\n name VARCHAR(50),\n age INT,\n sex CHAR(1),\n class VARCHAR(50)\n);\n```\n\n\n第二步，插入数据：\n\n\n```sql\nINSERT INTO students (name, age, sex, class) VALUES\n('练习伴侣二', 18, '女', '三年二班'),\n('练习伴侣一', 20, '男', '三年二班'),\n('练习伴侣三', 19, '男', '三年三班'),\n('练习伴侣四', 17, '男', '三年三班'),\n('练习伴侣五', 20, '女', '三年四班'),\n('练习伴侣六', 21, '男', '三年四班'),\n('练习伴侣七', 18, '女', '三年四班');\n```\n\n\n#### [所有年龄为 18 的人的名字？](#所有年龄为-18-的人的名字)\n\n\n```sql\nSELECT name FROM students WHERE age = 18;\n```\n\n\n这条 SQL 语句从表中选择`age`等于 18 的所有记录，并返回这些记录的`name`字段。\n\n\n\n如果可以的话，可以给 age 字段加上索引。\n\n\n```sql\nALTER TABLE students ADD INDEX age_index (age);\n```\n\n\n#### [找到每个班年龄大于 18 有多少人?](#找到每个班年龄大于-18-有多少人)\n\n\n```sql\nSELECT class, COUNT(*) AS number_of_students\nFROM students\nWHERE age > 18\nGROUP BY class;\n```\n\n\n这条 SQL 语句先筛选出年龄大于 18 的记录，然后按`class`分组，并通过 `count` 统计每个班的学生数。\n\n\n\n#### [找到每个班年龄排前两名的人？](#找到每个班年龄排前两名的人)\n\n这个查询稍微复杂一些，需要使用子查询和去重 `DISTINCT`。\n\n\n```sql\nSELECT a.class, a.name, a.age\nFROM students a\nWHERE (\n SELECT COUNT(DISTINCT b.age)\n FROM students b\n WHERE b.class = a.class AND b.age > a.age\n) < 2\nORDER BY a.class, a.age DESC;\n```\n\n\n这条 SQL 语句首先从`students`表中选择`class`、`name`和`age`字段，然后使用子查询计算每个班级中年龄排前两名的学生。\n\n"
+ },
+ {
+ "id": 415,
+ "question": "有一个查询需求，MySQL 中有两个表，一个表 1000W 数据，另一个表只有几千数据，要做一个关联查询，如何优化",
+ "answer": "第一步，为关联字段建立索引，确保 on 连接的字段都有索引。\n\n\n```sql\nALTER TABLE big_table ADD INDEX idx_small_id(small_id);\n```\n\n\n第二步，小表驱动大表，将小表放在 JOIN 的左边（驱动表），大表放在右边。\n\n\n```sql\nSELECT ... FROM small_table s \nJOIN big_table b ON s.id = b.small_id\n```"
+ },
+ {
+ "id": 416,
+ "question": "新建一个表结构，创建索引，将百万或千万级的数据使用 insert 导入该表，新建一个表结构，将百万或千万级的数据使用 isnert 导入该表，再创建索引，这两种效率哪个高呢？或者说用时短呢？",
+ "answer": "先说结论：\n\n在大数据量导入场景下，先导入数据，后建索引的效率显著高于先建索引，后导入数据的效率。\n\n来，实操。\n\n先创建一个表，然后创建索引，执行插入语句，来看看执行时间（100 万数据在我本机上执行时间比较长，我们就用 10 万条数据来测试）。\n\n\n```sql\nCREATE TABLE test_table (\n id BIGINT AUTO_INCREMENT PRIMARY KEY,\n name VARCHAR(255) NOT NULL,\n email VARCHAR(255) NOT NULL,\n created_at DATETIME NOT NULL\n);\nCREATE INDEX idx_name ON test_table(name);\nDELIMITER //\n\nCREATE PROCEDURE insert_data()\nBEGIN\n DECLARE i INT DEFAULT 0;\n\n WHILE i < 1000000 DO\n INSERT INTO test_table(name, email, created_at)\n VALUES (CONCAT('wanger',i), CONCAT('email', i, '@example.com'), NOW());\n SET i = i + 1;\n END WHILE;\nEND //\n\nDELIMITER ;\nCALL insert_data();\n```\n\n\n总的时间 13.93+0.01+0.01+0.01=13.96 秒。\n\n\n\n接下来，我们再创建一个表，执行插入操作，然后创建索引。\n\n\n```sql\nCREATE TABLE test_table_no_index (\n id BIGINT AUTO_INCREMENT PRIMARY KEY,\n name VARCHAR(255) NOT NULL,\n email VARCHAR(255) NOT NULL,\n created_at DATETIME NOT NULL\n);\nDELIMITER //\n\nCREATE PROCEDURE insert_data_no_index()\nBEGIN\n DECLARE i INT DEFAULT 0;\n\n WHILE i < 1000000 DO\n INSERT INTO test_table_no_index(name, email, created_at)\n VALUES (CONCAT('wanger', i), CONCAT('email', i, '@example.com'), NOW());\n SET i = i + 1;\n END WHILE;\nEND //\n\nDELIMITER ;\nCALL insert_data_no_index();\nCREATE INDEX idx_name_no_index ON test_table_no_index(name);\n```\n\n\n来看一下总的时间，0.01+0.00+13.08+0.18=13.27 秒。\n\n\n\n先插入数据再创建索引的方式比先创建索引再插入数据要快一点。\n\n然后时间差距很微小，主要是因为我们插入的数据少。说一下差别。\n\n* **先插入数据再创建索引**：在没有索引的情况下插入数据，数据库不需要在每次插入时更新索引。\n* **先创建索引再插入数据**：数据库需要在每次插入新记录时维护索引结构，随着数据量的增加，索引的维护会导致额外的性能开销。\n\n#### [MySQL是先建立索引好还是先插入数据好？](#mysql是先建立索引好还是先插入数据好)\n\n如果是小批量插入，可以先建索引；但在大数据量数据导入场景下，推荐先插入数据再建索引。\n\n因为索引是基于 B+ 树的，大量插入时如果提前建索引，会频繁触发页分裂和索引结构调整，影响性能。\n\n插入完成后统一构建索引，MySQL 会按顺序批量生成索引结构，速度更快、资源消耗更低。"
+ },
+ {
+ "id": 417,
+ "question": "什么是深分页，select * from tbn limit 1000000000 这个有什么问题，如果表大或者表小分别什么问题",
+ "answer": "深分页是指在 MySQL 中获取比较靠后的数据页，比如第 1000 页、第 10000 页等。特别是使用 `LIMIT offset,count` 这种方式，当 offset 特别大，就会带来严重的性能问题。\n\n对于 `SELECT * FROM tbn LIMIT 1000000,10`，这样的查询语句来说，MySQL 会：\n\n* 从表中读取第一条记录，判断是否满足 where 条件；如果满足，计数器+1；否则直到 计数器累计到 1000000 时才开始真正取数据\n* 再继续获取 10 条数据，返回\n\n性能会非常差，因为需要从头扫描，无法利用索引优化，并且需要抛弃大量不需要的数据，占用大量的内存和 CPU 资源。\n\n可以借助主键索引分页进行优化：\n\n\n```sql\nSELECT * FROM tbn\nWHERE id > (SELECT id FROM tbn ORDER BY id LIMIT 1000000, 1)\nLIMIT 10\n```\n\n\n或者记住上次分页的最大 ID，然后再查询：\n\n\n```sql\nSELECT * FROM tbn\nWHERE id > last_page_max_id\nLIMIT 10\n```"
+ },
+ {
+ "id": 418,
+ "question": "SQL 题：一个学生成绩表，字段有学生姓名、班级、成绩，求各班前十名",
+ "answer": "第一步，建表：\n\n\n```sql\nCREATE TABLE student_scores (\n student_name VARCHAR(100),\n class VARCHAR(50),\n score INT\n);\n```\n\n\n第二步，插入数据：\n\n\n```sql\nINSERT INTO student_scores (student_name, class, score) VALUES\n('练习伴侣二', '三年二班', 88),\n('练习伴侣三', '三年二班', 92),\n('练习伴侣四', '三年二班', 87),\n('练习伴侣五', '三年二班', 85),\n('练习伴侣六', '三年二班', 90),\n('练习伴侣七', '三年二班', 95),\n('练习伴侣八', '三年二班', 82),\n('练习伴侣九', '三年二班', 78),\n('练习伴侣十', '三年二班', 91),\n('练习伴侣十一', '三年二班', 79),\n('练习伴侣十二', '三年三班', 84),\n('练习伴侣十三', '三年三班', 81),\n('练习伴侣十四', '三年三班', 90),\n('练习伴侣十五', '三年三班', 88),\n('练习伴侣十六', '三年三班', 87),\n('练习伴侣十七', '三年三班', 93),\n('练习伴侣十八', '三年三班', 89),\n('练习伴侣十九', '三年三班', 85),\n('练习伴侣二十', '三年三班', 92),\n('练习伴侣二十一', '三年三班', 84);\n```\n\n\n第三步，查询各班前十名。如果 MySQL 是 8.0 以下版本，不支持窗口函数，可以通过在查询中维护班级当前处理状态和排名，实现分组内按成绩排序并打标号，再取前十名。\n\n\n```sql\nSET @cur_class = NULL, @cur_rank = 0;\n\nSELECT student_name, class, score\nFROM (\n SELECT\n student_name,\n class,\n score,\n @cur_rank := IF(@cur_class = class, @cur_rank + 1, 1) AS rank,\n @cur_class := class\n FROM student_scores\n ORDER BY class, score DESC\n) AS ranked\nWHERE ranked.rank <= 10;\n```\n\n\n| 步骤 | 解释 |\n| --- | --- |\n| @cur\\_class 变量 | 记录当前正在处理的班级 |\n| @cur\\_rank 变量 | 记录当前班级的排名，默认 0 |\n| `IF(@cur_class = class, @cur_rank + 1, 1)` | 如果班级没变，就排名 +1；如果换了新班级，排名从 1 重新开始 |\n| `@cur_class := class` | 更新当前班级变量，保持班级变化跟踪 |\n| `ORDER BY class, score DESC` | 必须先按班级升序、成绩降序排好，才能保证变量正确打排名 |\n| 外层 `WHERE rank <= 10` | 只取每班前十名 ✅ |\n\n\n\n如果是 MySQL 8.0+ 版本，可以使用窗口函数来完成：\n\n\n```sql\nSELECT student_name, class, score\nFROM (\n SELECT \n student_name, \n class, \n score,\n ROW_NUMBER() OVER (PARTITION BY class ORDER BY score DESC) AS rn\n FROM student_scores\n) AS tmp\nWHERE rn <= 10;\n```\n\n\n| SQL 用到的技术 | 说明 |\n| --- | --- |\n| `ROW_NUMBER() OVER (PARTITION BY class ORDER BY score DESC)` | 给每个班独立打排名，从 1 开始 |\n| 子查询 tmp | 用来临时生成带有 rn（排名）的数据集 |\n| 外层 `WHERE rn <= 10` | 选出每个班排名前 10 的学生 |\n| `ORDER BY score DESC` | 成绩高排前面，符合常规排名逻辑 |\n\n"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 9,
+ "topicName": "操作系统",
+ "categories": [
+ {
+ "id": 62,
+ "categoryName": "引论",
+ "questions": [
+ {
+ "id": 419,
+ "question": "什么是操作系统？",
+ "answer": "操作系统（Operating System, OS）是计算机系统中管理硬件和软件资源的中间层系统，屏蔽了硬件的复杂性，并且为用户提供了便捷的交互方式，比如说 Windows、Linux、MacOS 等。\n\n"
+ },
+ {
+ "id": 420,
+ "question": "操作系统主要有哪些功能？",
+ "answer": "\n\n①、负责创建和终止进程。进程是正在运行的程序实例，每个进程都有自己的地址空间和资源。\n\n②、负责为进程分配资源，比如说内存，并在进程终止时回收内存。\n\n③、提供创建、删除、读写文件的功能，并组织文件的存储结构，比如说目录。\n\n④、通过设备驱动程序控制和管理计算机的硬件设备，如键盘、鼠标、打印机等。"
+ }
+ ]
+ },
+ {
+ "id": 63,
+ "categoryName": "操作系统结构",
+ "questions": [
+ {
+ "id": 421,
+ "question": "什么是内核？",
+ "answer": "可以这么说，内核是一个计算机程序，它是操作系统的核心，提供了操作系统最核心的能力，可以控制操作系统中所有的内容。"
+ },
+ {
+ "id": 422,
+ "question": "什么是用户态和内核态？",
+ "answer": "在计算机系统中，内存可以分为两大区域：内核空间（Kernel Space）和用户空间（User Space）。这种划分主要用于保护系统稳定性和安全性。\n\n* 内核空间，是操作系统内核代码及其运行时数据结构所在的内存区域，拥有对系统所有资源的完全访问权限，如进程管理、内存管理、文件系统、网络堆栈等。\n* ⽤户空间，是操作系统为应用程序（如用户运行的进程）分配的内存区域，用户空间中的进程不能直接访问硬件或内核数据结构，只能通过系统调用与内核通信。\n\n\n\n当程序使⽤⽤户空间时，我们常说该程序在 **⽤户态** 执⾏，⽽当程序使内核空间时，程序则在 **内核态** 执⾏。"
+ },
+ {
+ "id": 423,
+ "question": "用户态和内核态是如何切换的？",
+ "answer": "当应用程序执行系统调用时，CPU 将从用户态切换到内核态，进入内核空间执行相应的内核代码，然后再切换回用户态。\n\n\n\n系统调用是应用程序请求操作系统内核提供服务的接口，如文件操作（如 open、read、write）、进程控制（如 fork、exec）、内存管理（如 mmap）等。"
+ }
+ ]
+ },
+ {
+ "id": 64,
+ "categoryName": "进程和线程",
+ "questions": [
+ {
+ "id": 424,
+ "question": "并行和并发有什么区别？",
+ "answer": "并发就是在一段时间内，多个任务都会被处理；但在某一时刻，只有一个任务在执行。单核处理器做到的并发，其实是利用时间片的轮转，例如有两个进程 A 和 B，A 运行一个时间片之后，切换到 B，B 运行一个时间片之后又切换到 A。因为切换速度足够快，所以宏观上表现为在一段时间内能同时运行多个程序。\n\n并行就是在同一时刻，有多个任务在执行。这个需要多核处理器才能完成，在微观上就能同时执行多条指令，不同的程序被放到不同的处理器上运行，这个是物理上的多个进程同时进行。\n\n"
+ },
+ {
+ "id": 425,
+ "question": "什么是进程上下文切换？",
+ "answer": "\n\n上下文切换是操作系统在多任务处理环境中，将 CPU 从一个进程切换到另一个进程的过程。通过让多个进程共享 CPU 资源，使系统能够并发执行多个任务。\n\n进程上下文切换通畅包含以下几个步骤：\n\n* 保存当前进程的上下文：操作系统保存当前进程的 CPU 寄存器，程序状态等关键信息。\n* 选择下一个进程：调度程序选择下一个要执行的进程。\n* 恢复上一个进程的上下文。\n* 切换到下一个进程。"
+ },
+ {
+ "id": 426,
+ "question": "进程有哪些状态？",
+ "answer": "当一个进程开始运行时，它可能会经历下面这几种状态：\n\n上图中各个状态的意义：\n\n* 运⾏状态（*Runing*）：该时刻进程占⽤ CPU；\n* 就绪状态（*Ready*）：可运⾏，由于其他进程处于运⾏状态⽽暂时停⽌运⾏；\n* 阻塞状态（*Blocked*）：该进程正在等待某⼀事件发⽣（如等待输⼊/输出操作的完成）⽽暂时停⽌运⾏，这时，即使给它 CPU 控制权，它也⽆法运⾏；\n\n\n\n当然，进程还有另外两个基本状态：\n\n* 创建状态（*new*）：进程正在被创建时的状态；\n* 结束状态（*Exit*）：进程正在从系统中消失时的状态；\n\n"
+ },
+ {
+ "id": 427,
+ "question": "什么是僵尸进程？",
+ "answer": "僵尸进程是已完成且处于终止状态，但在进程表中却仍然存在的进程。\n\n僵尸进程一般发生有父子关系的进程中，一个子进程的进程描述符在子进程退出时不会释放，只有当父进程通过 wait() 或 waitpid() 获取了子进程信息后才会释放。如果子进程退出，而父进程并没有调用 wait() 或 waitpid()，那么子进程的进程描述符仍然保存在系统中。"
+ },
+ {
+ "id": 428,
+ "question": "什么是孤儿进程？",
+ "answer": "一个父进程退出，而它的一个或多个子进程还在运行，那么这些子进程将成为孤儿进程。孤儿进程将被 init 进程 (进程 ID 为 1 的进程) 所收养，并由 init 进程对它们完成状态收集工作。因为孤儿进程会被 init 进程收养，所以孤儿进程不会对系统造成危害。"
+ },
+ {
+ "id": 429,
+ "question": "进程有哪些调度算法？",
+ "answer": "进程调度是操作系统中的核心功能之一，它负责决定哪些进程在何时使用 CPU。这一决定基于系统中的进程调度算法。\n\n\n\n①、**先来先服务**\n\n这是最简单的调度算法，也称为先进先出（FIFO）。进程按照请求 CPU 的顺序进行调度。这种方式易于实现，但可能会导致较短的进程等待较长进程执行完成，从而产生“饥饿”现象。\n\n\n\n②、**短作业优先**\n\n选择预计运行时间最短的进程优先执行。这种方式可以减少平均等待时间和响应时间，但缺点是很难准确预知进程的执行时间，并且可能因为短作业一直在执行，导致长作业持续被推迟执行。\n\n\n\n③、**优先级调度**\n\n在这种调度方式中，每个进程都被分配一个优先级。CPU 首先分配给优先级最高的进程。优先级调度可以是非抢占式的或抢占式的。在非抢占式优先级调度中，进程一旦开始执行将一直运行直到完成；在抢占式优先级调度中，更高优先级的进程可以中断正在执行的低优先级进程。\n\n\n\n④、**时间片轮转**\n\n时间片轮转调度为每个进程分配一个固定的时间段，称为时间片，进程可以在这个时间片内运行。如果进程在时间片结束时还没有完成，它将被放回队列的末尾。时间片轮转是公平的调度方式，可以保证所有进程得到公平的 CPU 时间，适用于共享系统。\n\n\n\n⑤、**最短剩余时间优先**\n\n这是短作业优先的一种改进形式，它是抢占式的。即如果一个新进程的预计执行时间比当前运行进程的剩余时间短，调度器将暂停当前的进程，并切换到新进程。这种方法也可以最小化平均等待时间，但同样面临预测执行时间的困难。\n\n⑥ **多级反馈队列**\n\n一个进程需要执行100 哥时间片，如果采用时间片轮转调度算法，那么需要交互 100 次。\n\n多级队列就是为这种需要连续执行多个时间片的进程考虑，它设置了多个队列，每个队列的时间片大小不同，比如 2,4,6,8······。进程在第一个队列没执行完，就会被移到下一个队列。\n\n这种方式下，之前的进程只需要交换 7 次就可以了。每个队列优先权不一样，最上面的队列优先权最高。因此只有上一个队列没有进程在排队，才能调度当前队列上的进程。\n\n可以将这种调度算法看成是时间片轮转调度算法与优先级调度算法的结合。\n\n"
+ },
+ {
+ "id": 430,
+ "question": "进程间通信有哪些方式？",
+ "answer": "进程间通信的方式有 6 种，管道、信号、消息队列、共享内存、信号量和套接字。\n\n\n\n#### [简单说说管道：](#简单说说管道)\n\n管道可以理解成不同进程之间的传话筒，一方发声，一方接收，声音的介质可以是空气或者电缆。\n\n**进程间的管道就是内核中的一串缓存**，从管道的一端写入数据，另一端读取。数据只能单向流动，遵循先进先出（FIFO）的原则。\n\n\n\n①、**匿名管道**：允许具有亲缘关系的进程（如父子进程）进行通信。\n\n\n\n使用 C 语言在 Unix/Linux 环境下通过匿名管道实现两个进程（通常是父子进程）之间通信的示例：\n\n\n```c\n#include \n#include \n#include \n#include \n\nint main() {\n int pipefd[2];\n pid_t cpid;\n char buf;\n\n // 创建管道\n if (pipe(pipefd) == -1) {\n perror(\"pipe\");\n exit(EXIT_FAILURE);\n }\n\n // 创建子进程\n cpid = fork();\n if (cpid == -1) {\n perror(\"fork\");\n exit(EXIT_FAILURE);\n }\n\n if (cpid == 0) { /* 子进程 */\n close(pipefd[1]); // 关闭写端\n\n // 从管道读取数据\n while (read(pipefd[0], &buf, 1) > 0)\n write(STDOUT_FILENO, &buf, 1);\n\n write(STDOUT_FILENO, \"\\n\", 1);\n close(pipefd[0]);\n exit(EXIT_SUCCESS);\n } else { /* 父进程 */\n close(pipefd[0]); // 关闭读端\n\n // 向管道写入数据\n write(pipefd[1], \"Hello, Child!\", 13);\n close(pipefd[1]); // 关闭写端，触发EOF\n wait(NULL); // 等待子进程退出\n exit(EXIT_SUCCESS);\n }\n}\n```\n\n\n②、**命名管道**：允许无亲缘关系的进程通信，通过在文件系统中创建一个特殊类型的文件来实现。\n\n缺点：管道的效率低，不适合进程间频繁地交换数据。\n\n#### [简单说说信号：](#简单说说信号)\n\n信号可以理解成以前的 BB 机，用于通知接收进程某件事情发生了，是一种较为简单的通信方式，主要用于处理异步事件。\n\n比如`kill -9 1050`就表示给 PID 为 1050 的进程发送`SIGKIL`信号。\n\n这里顺带普及一下 Linux 中常用的信号：\n\n* SIGHUP：当我们退出终端（Terminal）时，由该终端启动的所有进程都会接收到这个信号，默认动作为终止进程。\n* SIGINT：程序终止（interrupt）信号。按 `Ctrl+C` 时发出，大家应该在操作终端时有过这种操作。\n* SIGQUIT：和 SIGINT 类似，按 `Ctrl+\\` 键将发出该信号。它会产生核心转储文件，将内存映像和程序运行时的状态记录下来。\n* SIGKILL：强制杀死进程，本信号不能被阻塞和忽略。\n* SIGTERM：与 SIGKILL 不同的是该信号可以被阻塞和处理。通常用来要求程序自己正常退出。\n\n#### [简单说说消息队列：](#简单说说消息队列)\n\n消息队列是保存在内核中的消息链表，按照消息的类型进行消息传递，具有较高的可靠性和稳定性。\n\n\n\n缺点：消息体有一个最大长度的限制，不适合比较大的数据传输；存在用户态与内核态之间的数据拷贝开销。\n\n\n\n#### [简单说说共享内存：](#简单说说共享内存)\n\n允许两个或多个进程共享一个给定的内存区，一个进程写⼊的东西，其他进程⻢上就能看到。\n\n共享内存是最快的进程间通信方式，它是针对其他进程间通信方式运行效率低而专门设计的。\n\n\n\n缺点：当多进程竞争同一个共享资源时，会造成数据错乱的问题。\n\n#### [简单说说信号量：](#简单说说信号量)\n\n信号量可以理解成红绿灯，红灯停（信号量为零），绿灯行（信号量非零）。**它本质上是一个计数器**，用来控制对共享资源的访问数量。\n\n\n\n它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。Java 中的 就实现了类似的功能。\n\n控制信号量的⽅式有两种原⼦操作：\n\n* ⼀个是 **P 操作**（wait，减操作），当进程希望获取资源时，它会执行 P 操作。如果信号量的值大于 0，表示有资源可用，信号量的值减 1，进程继续执行。如果信号量的值为 0，表示没有可用资源，进程进入等待状态，直到信号量的值变为大于 0。\n* 另⼀个是 **V 操作**（signal，加操作），当进程释放资源时，它会执行 V 操作，信号量的值加 1。如果有其他进程因为等待该资源而被阻塞，这时会唤醒其中一个进程。\n\n\n\n#### [简单说说套接字 Socket：](#简单说说套接字-socket)\n\n这个和 Java 中的 Socket 很相似，提供网络通信的端点，可以让不同机器上运行的进程之间进行双向通信。\n\n"
+ },
+ {
+ "id": 431,
+ "question": "进程和线程的联系和区别？",
+ "answer": "进程是一个正在执行的程序实例。每个进程都有自己独立的地址空间、全局变量、堆栈、和文件描述符等资源。\n\n线程是进程中的一个执行单元。一个进程可以包含多个线程，它们共享进程的地址空间和资源。\n\n\n\n每个进程在独立的地址空间中运行，不会直接影响其他进程。线程共享同一个进程的内存空间、全局变量和文件描述符。\n\n进程切换需要保存和恢复大量的上下文信息，代价较高。线程切换相对较轻量，因为线程共享进程的地址空间，只需要保存和恢复线程私有的数据。\n\n线程的生命周期由进程控制，进程终止时，其所有线程也会终止。\n\n| 特性 | 进程 | 线程 |\n| --- | --- | --- |\n| 地址空间 | 独立 | 共享 |\n| 内存开销 | 高 | 低 |\n| 上下文切换 | 慢，开销大 | 快，开销小 |\n| 通信 | 需要 IPC 机制，开销较大 | 共享内存，直接通信 |\n| 创建销毁 | 开销大，较慢 | 开销小，较快 |\n| 并发性 | 低 | 高 |\n| 崩溃影响 | 一个进程崩溃不会影响其他进程 | 一个线程崩溃可能导致整个进程崩溃 |"
+ },
+ {
+ "id": 432,
+ "question": "线程上下文切换了解吗？",
+ "answer": "这还得看线程是不是属于同⼀个进程：\n\n* 当两个线程不是属于同⼀个进程，则切换的过程就跟进程上下⽂切换⼀样；\n* **当两个线程是属于同⼀个进程，因为虚拟内存是共享的，所以在切换时，虚拟内存这些资源就保持不动，只需要切换线程的私有数据、寄存器等不共享的数据**；\n\n所以，线程的上下⽂切换相⽐进程，开销要⼩很多。"
+ },
+ {
+ "id": 433,
+ "question": "线程有哪些实现方式？",
+ "answer": "主要有三种线程的实现⽅式：\n\n* **内核态线程实现**：在内核空间实现的线程，由内核直接管理直接管理线程。\n\n\n\n* **⽤户态线程实现**：在⽤户空间实现线程，不需要内核的参与，内核对线程无感知。\n\n\n\n* **混合线程实现**：现代操作系统基本都是将两种方式结合起来使用。用户态的执行系统负责进程内部线程在非阻塞时的切换；内核态的操作系统负责阻塞线程的切换。即我们同时实现内核态和用户态线程管理。其中内核态线程数量较少，而用户态线程数量较多。每个内核态线程可以服务一个或多个用户态线程。\n\n"
+ },
+ {
+ "id": 434,
+ "question": "线程间如何同步？",
+ "answer": "同步解决的是多线程操作共享资源的问题，不管线程之间是如何穿插执行的，最后的结果都是正确的。\n\n在操作系统层面，保证线程同步的方式有很多，比如锁、信号量等。那在此之前，需要先了解什么是临界区。\n\n\n\n临界区：对共享资源访问的程序片段，我们希望这段代码是`互斥`的，可以保证在某个时刻只能被一个线程执行，也就是说一个线程在临界区执行时，其它线程应该被阻止进入临界区。\n\n临界区不仅针对线程，同样针对进程。同步的实现方式有：\n\n①、**互斥锁**\n\n使⽤加锁操作和解锁操作可以解决并发线程/进程的互斥问题。\n\n任何想进⼊临界区的线程，必须先执⾏加锁操作。若加锁操作顺利通过，则线程可进⼊临界区；在完成对临界资源的访问后再执⾏解锁操作，以释放该临界资源。\n\n加锁和解锁锁住的是什么呢？可以是`临界区对象`，也可以只是一个简单的`互斥量`，例如互斥量是`0`无锁，`1`表示加锁。\n\n根据锁的实现不同，可以分为`忙等待锁`和`⽆忙等待锁`。\n\n* 忙等待锁（也称为自旋锁，Spinlock）是指当一个线程试图获取锁时，如果该锁已经被其他线程持有，当前线程不会立即进入休眠或阻塞，而是不断地检查锁的状态，直到该锁可用为止。这个过程被称为忙等待（busy waiting），因为线程在等待锁时仍然占用 CPU 资源，处于活跃状态。优点是避免了线程的上下文切换。\n* 无忙等待锁是指当一个线程尝试获取锁时，如果锁已经被其他线程持有，当前线程不会忙等待，而是主动让出 CPU，进入阻塞状态或休眠状态，等待锁释放。当锁被释放时，线程被唤醒并重新尝试获取锁。这类锁的主要目的是避免忙等待带来的 CPU 资源浪费。\n\n②、**信号量**\n\n信号量是操作系统提供的⼀种协调共享资源访问的⽅法。**通常表示资源的数量**，对应的变量是⼀个整型（sem）变量。\n\n另外，还有**两个原⼦操作的系统调⽤函数来控制信号量**，分别是：\n\n* *P* 操作：当线程想要进入临界区时，会尝试执行 P 操作。如果信号量的值大于 0，信号量值减 1，线程可以进入临界区；否则，线程会被阻塞，直到信号量大于 0。\n* *V* 操作：当线程退出临界区时，执行 V 操作，信号量的值加 1，释放一个被阻塞的线程。"
+ },
+ {
+ "id": 435,
+ "question": "什么是死锁？",
+ "answer": "在两个或者多个并发线程中，如果每个线程持有某种资源，而又等待其它线程释放它或它们现在保持着的资源，在未改变这种状态之前都不能向前推进，称这一组线程产生了死锁。通俗的讲就是两个或多个线程无限期的阻塞、相互等待的一种状态。\n\n"
+ },
+ {
+ "id": 436,
+ "question": "死锁产生有哪些条件？",
+ "answer": "产生死锁需要同时满足四个必要条件：\n\n* **互斥条件**（Mutual Exclusion）：资源不能被多个进程共享，即资源一次只能被一个进程使用。如果一个资源已经被分配给了一个进程，其他进程必须等待，直到该资源被释放。\n* **持有并等待条件**（Hold and Wait）：一个进程已经持有了至少一个资源，同时还在等待获取其他被占用的资源。在此期间，该进程不会释放已经持有的资源。\n* **不可剥夺条件**（No Preemption）：已分配给进程的资源不能被强制剥夺，只有持有该资源的进程可以主动释放资源。\n* **循环等待条件**（Circular Wait）：存在一个进程集合 P1,P2,...,Pn，其中 P1 等待 P2 持有的资源，P2 等待 P3 持有的资源，依此类推，直到 Pn 等待 P1 持有的资源，形成一个进程等待环。\n\n假设有两个进程 P1 和 P2，以及两个资源 R1 和 R2，一个简单的死锁场景是这样的：\n\n1. P1 持有资源 R1，并请求资源 R2。\n2. P2 持有资源 R2，并请求资源 R1。\n\n在这种情况下，发生死锁的步骤如下：\n\n1. **互斥条件**：R1 和 R2 都只能被一个进程占用。\n2. **持有并等待条件**：P1 持有 R1 并等待 R2，同时 P2 持有 R2 并等待 R1。\n3. **不可剥夺条件**：R1 和 R2 都不能被强制从 P1 和 P2 中剥夺。\n4. **循环等待条件**：P1 等待 P2 持有的 R2，而 P2 等待 P1 持有的 R1，形成一个循环。"
+ },
+ {
+ "id": 437,
+ "question": "如何避免死锁呢？",
+ "answer": "产⽣死锁的有四个必要条件：互斥条件、持有并等待条件、不可剥夺条件、环路等待条件。\n\n避免死锁，破坏其中的一个就可以。\n\n**消除互斥条件**\n\n这个是没法实现，因为很多资源就是只能被一个线程占用，例如锁。\n\n**消除请求并持有条件**\n\n消除这个条件的办法很简单，就是一个线程一次请求其所需要的所有资源。\n\n**消除不可剥夺条件**\n\n占用部分资源的线程进一步申请其他资源时，如果申请不到，可以主动释放它占有的资源，这样不可剥夺这个条件就破坏掉了。\n\n**消除环路等待条件**\n\n可以靠按序申请资源来预防。所谓按序申请，是指资源是有线性顺序的，申请的时候可以先申请资源序号小的，再申请资源序号大的，这样线性化后就不存在环路了。"
+ },
+ {
+ "id": 438,
+ "question": "活锁和饥饿锁了解吗？",
+ "answer": "**饥饿锁：**\n\n饥饿锁，这个饥饿指的是资源饥饿，某个线程一直等不到它所需要的资源，从而无法向前推进，就像一个人因为饥饿无法成长。\n\n**活锁：**\n\n在活锁状态下，处于活锁线程组里的线程状态可以改变，但是整个活锁组的线程无法推进。\n\n活锁可以用两个人过一条很窄的小桥来比喻：为了让对方先过，两个人都往旁边让，但两个人总是让到同一边。这样，虽然两个人的状态一直在变化，但却都无法往前推进。"
+ }
+ ]
+ },
+ {
+ "id": 65,
+ "categoryName": "内存管理",
+ "questions": [
+ {
+ "id": 439,
+ "question": "物理内存和虚拟内存有什么区别？",
+ "answer": "物理内存指的是计算机中实际存在的硬件内存。物理内存是计算机用于存储运行中程序和数据的实际内存资源，操作系统和应用程序最终都必须使用物理内存来执行。\n\n也就是我们常说的那个 8G、16G、64G 的内存条。\n\n虚拟内存是操作系统提供的一种内存管理技术，它使得应用程序认为自己有连续的、独立的内存空间，而实际上，这个虚拟内存可能部分存储在物理内存上，部分存储在 **磁盘（如硬盘的交换分区或页面文件）** 中。\n\n\n\n虚拟内存的核心思想是通过硬件和操作系统的配合，为每个进程提供一个独立的、完整的虚拟地址空间，解决物理内存不足的问题。\n\n①、每个进程都有自己的虚拟地址空间，虚拟内存使用的是逻辑地址，它与实际的物理内存地址不同，必须经过地址转换才能映射到物理内存。\n\n②、操作系统通过 **页表（Page Table）** 将虚拟地址映射到物理地址。当程序访问某个虚拟地址时，CPU 会通过页表找到对应的物理地址。\n\n③、操作系统将虚拟内存划分为若干个**页（Pages）**，每个页可以被映射到物理内存中的一个页面。如果物理内存不够，操作系统会将不常用的页暂时存储到磁盘的交换区（Swap）中，这个过程叫做页交换（Paging）。"
+ },
+ {
+ "id": 440,
+ "question": "什么是内存分段？",
+ "answer": "程序是由若⼲个逻辑分段组成的，如可由代码分段、数据分段、栈段、堆段组成。不同的段是有不同的属性的，所以就⽤分段（Segmentation）的形式把这些段分离出来。\n\n分段机制下的虚拟地址由两部分组成，**段号**和**段内偏移量**。\n\n虚拟地址和物理地址通过段表映射，段表主要包括**段号**、`段的界限`。\n\n\n\n我们来看一个映射，虚拟地址：段 3、段偏移量 500 ----> 段基地址 7000+段偏移量 500 ----> 物理地址：8700+。\n\n"
+ },
+ {
+ "id": 441,
+ "question": "什么是内存分页？",
+ "answer": "**分⻚是把整个虚拟和物理内存空间切成⼀段段固定尺⼨的⼤⼩**。这样⼀个连续并且尺⼨固定的内存空间，我们叫\\*\\*⻚\\*\\*（*Page*）。在 Linux 下，每⼀⻚的⼤⼩为 4KB 。\n\n访问分页系统中内存数据需要两次的内存访问 ：一次是从内存中访问页表，从中找到指定的物理页号，加上页内偏移得到实际物理地址，第二次就是根据第一次得到的物理地址访问内存取出数据。\n\n"
+ },
+ {
+ "id": 442,
+ "question": "多级页表知道吗？",
+ "answer": "多级页表（Multilevel Page Table）是一种内存管理技术，用于在虚拟内存系统中高效地管理和转换虚拟地址到物理地址。它通过分层结构减少页表所需的内存开销，以解决单级页表在大地址空间中的效率问题。\n\n\n\n在虚拟内存系统中，虚拟地址需要转换为物理地址。页表是实现这种转换的关键数据结构。对于 32 位系统，一个进程的地址空间可以达到 4 GB，如果使用单级页表，每个页表条目（PTE）占用 4 字节，则需要 4 MB 的内存来存储页表。然而，许多进程只使用其中的一小部分地址空间，导致单级页表的内存浪费。\n\n多级页表通过将单级页表拆分为多个层级，减少了内存浪费。以两级页表为例：\n\n* 一级页表（页目录）：存储二级页表的地址。每个页目录条目（PDE）指向一个二级页表。\n* 二级页表（页表）：存储实际的页框地址。每个页表条目（PTE）指向一个物理页框。\n\n虚拟地址分为多个部分，每一部分用于索引相应层级的页表。例如，对于一个 32 位地址和 4 KB 页大小的两级页表：\n\n* 高 10 位：一级页表索引（页目录索引）。\n* 中 10 位：二级页表索引（页表索引）。\n* 低 12 位：页内偏移。"
+ },
+ {
+ "id": 443,
+ "question": "什么是快表？",
+ "answer": "同样利用了`局部性原理`，即在⼀段时间内，整个程序的执⾏仅限于程序中的某⼀部分。相应地，执⾏所访问的存储空间也局限于某个内存区域。\n\n利⽤这⼀特性，把最常访问的⼏个⻚表项存储到访问速度更快的硬件，于是计算机科学家们，就在 CPU 芯⽚中，加⼊了⼀个专⻔存放程序最常访问的⻚表项的 Cache，这个 Cache 就是 TLB（*Translation Lookaside Buffer*） ，通常称为⻚表缓存、转址旁路缓存、快表等。\n\n![TLB示意图-来源参考[3]](https://cdn.paicoding.com/tobebetterjavaer/images/sidebar/sanfene/os-cdc02a2f-59bf-45dc-8531-83b46f77bd65.png)"
+ },
+ {
+ "id": 444,
+ "question": "分页和分段有什么区别？",
+ "answer": "* 段是信息的逻辑单位，它是根据用户的需要划分的，因此段对用户是可见的 ；页是信息的物理单位，是为了管理主存的方便而划分的，对用户是透明的。\n* 段的大小不固定，有它所完成的功能决定；页的大小固定，由系统决定\n* 段向用户提供二维地址空间；页向用户提供的是一维地址空间\n* 段是信息的逻辑单位，便于存储保护和信息的共享，页的保护和共享受到限制。"
+ },
+ {
+ "id": 445,
+ "question": "什么是交换空间？",
+ "answer": "操作系统把物理内存(Physical RAM)分成一块一块的小内存，每一块内存被称为页(page)。当内存资源不足时，Linux 把某些页的内容转移至磁盘上的一块空间上，以释放内存空间。磁盘上的那块空间叫做交换空间(swap space)，而这一过程被称为交换(swapping)。物理内存和交换空间的总容量就是虚拟内存的可用容量。\n\n用途：\n\n* 物理内存不足时一些不常用的页可以被交换出去，腾给系统。\n* 程序启动时很多内存页被用来初始化，之后便不再需要，可以交换出去。"
+ },
+ {
+ "id": 446,
+ "question": "什么是缺页中断？（补充）",
+ "answer": "> 2024 年 03 月 29 日增补\n\n缺页中断（Page Fault）是虚拟内存管理的一个重要概念。当一个程序访问的页（页面）不在物理内存中时，就会发生缺页中断。操作系统需要从磁盘上的交换区（或页面文件）中将缺失的页调入内存。\n\n举个例子，你正在一间图书馆（内存）里查找一本特定的书（数据/程序页），图书馆的书架（内存空间）能放的书是有限的。现在，如果你找的那本书正好在书架上，那太好了，直接拿来阅读（内存命中）。\n\n但如果书架上没有（缺页），你需要先去找图书管理员。\n\n图书管理员（操作系统）注意到书架上缺了这本书，然后去仓库里帮你找（缺页中断）。找到书之后，管理员发现书架已经满了，需要先从书架上拿掉一本书（页面置换算法决定哪本书被拿掉），然后把新找到的书放上去，最后把书递给你。\n\n这个过程中，“去仓库找书并换回来”的这一过程就像是发生了缺页中断，而决定哪本书被移出书架以腾出位置放新书的规则，就是页面置换算法在做的事情。\n\n这么做的目的是尽量确保你常读的书都能在书架（内存）上直接找到，避免每次都要去仓库（硬盘）搜寻，因为去仓库找书的过程比较耗时。"
+ },
+ {
+ "id": 447,
+ "question": "页面置换算法有哪些？",
+ "answer": "页面置换算法的目标是最小化缺页中断的次数，常见的页面置换算法有最佳⻚⾯置换算法（*OPT*）、先进先出置换算法（*FIFO*）、最近最久未使⽤的置换算法（*LRU*）和时钟页面置换算法等。\n\n\n\n①、**最佳⻚⾯置换算法**\n\n基本思路是，淘汰以后不会使用的页面。这是理论上的最佳算法，因为它可以保证最低的缺页率。但在实际应用中，由于无法预知未来的访问模式，OPT 通常无法实现。\n\n\n\n②、**先进先出置换算法**\n\n基本思路是，优先淘汰最早进入内存的页面。FIFO 算法维护一个队列，新来的页面加入队尾，当发生页面置换时，队头的页面（即最早进入内存的页面）被移出。\n\n\n\n③、**最近最久未使⽤的置换算法**\n\n基本思路是，淘汰最近没有使用的页面。LRU 算法根据页面的访问历史来进行置换，最长时间未被访问的页面将被置换出去。\n\n相对更接近最优算法的效果，因为最近未使用的页面可能在将来也不会被使用。但 LRU 算法的实现需要跟踪页面的访问历史，可能会增加系统的开销。\n\n\n\n④、**时钟页面置换算法**\n\n时钟算法是 LRU 的一种近似和实现简单的形式。它通过一个循环列表（类似时钟的指针）遍历页面，每个页面有一个使用位，当页面被访问时，使用位设置为 1。\n\n当需要页面置换时，时钟指针会顺时针移动，直到找到使用位为 0 的页面进行置换。这个过程类似于给每个页面一个二次机会。算法执行时，会先将使用位从 1 清零，如果该页面再次被访问，它的使用位再次被设置为 1。\n\n\n\n⑤、**最不常⽤置换算法**\n\n根据页面被访问的频率进行置换，访问次数最少的页面最先被置换。实现较为复杂，需要记录每个页面的访问频率。"
+ }
+ ]
+ },
+ {
+ "id": 66,
+ "categoryName": "文件",
+ "questions": [
+ {
+ "id": 448,
+ "question": "硬链接和软链接有什么区别？",
+ "answer": "* 硬链接就是在目录下创建一个条目，记录着文件名与 inode 编号，这个 inode 就是源文件的 inode。删除任意一个条目，文件还是存在，只要引用数量不为 0。但是硬链接有限制，它不能跨越文件系统，也不能对目录进行链接。\n\n![硬链接-来源参考[3]](https://cdn.paicoding.com/tobebetterjavaer/images/sidebar/sanfene/os-d3f778f9-506b-4b93-9fb7-40eb0a79874e.png)\n\n* 软链接相当于重新创建⼀个⽂件，这个⽂件有**独⽴的** **inode**，但是这个\\*\\*⽂件的内容是另外⼀个⽂件的路径\\*\\*，所以访问软链接的时候，实际上相当于访问到了另外⼀个⽂件，所以**软链接是可以跨⽂件系统的**，甚⾄**⽬标⽂件被删除了，链接⽂件还是在的，只不过打不开指向的文件了而已。**\n\n ![软链接-来源参考[3]](https://cdn.paicoding.com/tobebetterjavaer/images/sidebar/sanfene/os-81abf13c-5c60-4263-8fcb-c79c33d865e8.png)"
+ }
+ ]
+ },
+ {
+ "id": 67,
+ "categoryName": "IO",
+ "questions": [
+ {
+ "id": 449,
+ "question": "零拷贝了解吗？",
+ "answer": "假如需要文件传输，使用传统 I/O，数据读取和写入是用户空间到内核空间来回赋值，而内核空间的数据是通过操作系统的 I/O 接口从磁盘读取或者写入，这期间发生了多次用户态和内核态的上下文切换，以及多次数据拷贝。\n\n![传统文件传输示意图-来源参考[3]](https://cdn.paicoding.com/tobebetterjavaer/images/sidebar/sanfene/os-1e595664-6585-4d56-8939-08b7ce510218.png)\n\n为了提升 I/O 性能，就需要**减少用户态与内核态的上下文切换**和**内存拷贝的次数**。\n\n这就用到了我们零拷贝的技术，零拷贝技术实现主要有两种：\n\n* **mmap + write**\n\nmmap() 系统调⽤函数会直接把内核缓冲区⾥的数据「**映射**」到⽤户空间，这样，操作系统内核与⽤户空间就不需要再进⾏任何的数据拷⻉操作。\n\n![mmap示意图-来源参考[3]](https://cdn.paicoding.com/tobebetterjavaer/images/sidebar/sanfene/os-6dc49f9d-0bc3-4956-a650-7c7236f234a2.png)\n\n* **sendfile**\n\n在 Linux 内核版本 2.1 中，提供了⼀个专⻔发送⽂件的系统调⽤函数 sendfile() 。\n\n⾸先，它可以替代前⾯的 read() 和 write() 这两个系统调⽤，这样就可以减少⼀次系统调⽤，也就减少了 2 次上下⽂切换的开销。\n\n其次，该系统调⽤，可以直接把内核缓冲区⾥的数据拷⻉到 socket 缓冲区⾥，不再拷⻉到⽤户态，这样就只有 2 次上下⽂切换，和 3 次数据拷⻉。\n\n![sendfile示意图-来源参考[3]](https://cdn.paicoding.com/tobebetterjavaer/images/sidebar/sanfene/os-0b087b8a-8d51-4aad-898d-d99c38d36592.png)\n\n很多开源项目如 Kafka、RocketMQ 都采用了零拷贝技术来提升 IO 效率。"
+ },
+ {
+ "id": 450,
+ "question": "聊聊阻塞与⾮阻塞 IO、 同步与异步 IO？",
+ "answer": "* **阻塞 I/O**\n\n先来看看**阻塞** **I/O**，当⽤户程序执⾏ read ，线程会被阻塞，⼀直等到内核数据准备好，并把数据从内核缓冲区拷⻉到应⽤程序的缓冲区中，当拷⻉过程完成， read 才会返回。\n\n注意，**阻塞等待的是`内核数据准备好`和`数据从内核态拷⻉到⽤户态`这两个过程**。\n\n\n\n* **非阻塞 I/O**\n\n⾮阻塞的 read 请求在数据未准备好的情况下⽴即返回，可以继续往下执⾏，此时应⽤程序不断轮询内核，直到数据准备好，内核将数据拷⻉到应⽤程序缓冲区， read 调⽤才可以获取到结果。\n\n\n\n* **基于非阻塞的 I/O 多路复用**\n\n我们上面的非阻塞 I/O 有一个问题，什么问题呢？应用程序要一直轮询，这个过程没法干其它事情，所以引入了**I/O** \\*\\*多路复⽤\\*\\*技术。\n\n当内核数据准备好时，以事件通知应⽤程序进⾏操作。\n\n\n\n**注意：**⽆论是阻塞 I/O、还是⾮阻塞 I/O、非阻塞 I/O 多路复用，都是同步调⽤。因为它们在 read 调⽤时，内核将数据从内核空间拷⻉到应⽤程序空间，过程都是需要等待的，也就是说这个过程是**同步**的，如果内核实现的拷⻉效率不⾼，read 调⽤就会在这个同步过程中等待⽐较⻓的时间。\n\n* **异步 I/O**\n\n真正的**异步** **I/O** 是`内核数据准备好`和`数据从内核态拷⻉到⽤户态`这两个过程都不⽤等待。\n\n发起 aio\\_read 之后，就⽴即返回，内核⾃动将数据从内核空间拷⻉到应⽤程序空间，这个拷⻉过程同样是异步的，内核⾃动完成的，和前⾯的同步操作不⼀样，应⽤程序并不需要主动发起拷⻉动作。\n\n\n> 拿例子理解几种 I/O 模型\n\n老三关注了很多 UP 主，有些 UP 主是老鸽子，到了更新的时间：\n\n阻塞 I/O 就是，老三不干别的，就干等着，盯着 UP 的更新。\n\n非阻塞 I/O 就是，老三发现 UP 没更，就去喝个茶什么的，过一会儿来盯一次，一直等到 UP 更新。\n\n基于⾮阻塞的 I/O 多路复⽤好⽐，老三发现 UP 没更，就去干别的，过了一会儿 B 站推送消息了，老三一看，有很多条，就去翻动态，看看等的 UP 是不是更新了。\n\n异步 I/O 就是，老三说 UP 你该更了，UP 赶紧爆肝把视频做出来，然后把视频亲自呈到老三面前，这个过程不用等待。\n\n"
+ },
+ {
+ "id": 451,
+ "question": "详细讲一讲 I/O 多路复用？",
+ "answer": "> 我们先了解什么是 I/O 多路复用？\n\n我们在传统的 I/O 模型中，如果服务端需要支持多个客户端，我们可能要为每个客户端分配一个进程/线程。\n\n不管是基于重一点的进程模型，还是轻一点的线程模型，假如连接多了，操作系统是扛不住的。\n\n所以就引入了**I/O 多路复用** 技术。\n\n简单说，就是一个进程/线程维护多个 Socket，这个多路复用就是多个连接复用一个进程/线程。\n\n\n\n我们来看看 I/O 多路复用三种实现机制：\n\n* **select**\n\nselect 实现多路复⽤的⽅式是：\n\n将已连接的 Socket 都放到⼀个\\*\\*⽂件描述符集合\\*\\*fd\\_set，然后调⽤ select 函数将 fd\\_set 集合拷⻉到内核⾥，让内核来检查是否有⽹络事件产⽣，检查的⽅式很粗暴，就是通过遍历 fd\\_set 的⽅式，当检查到有事件产⽣后，将此 Socket 标记为可读或可写， 接着再把整个 fd\\_set 拷⻉回⽤户态⾥，然后⽤户态还需要再通过遍历的⽅法找到可读或可写的 Socket，再对其处理。\n\nselect 使⽤固定⻓度的 BitsMap，表示⽂件描述符集合，⽽且所⽀持的⽂件描述符的个数是有限制的，在 Linux 系统中，由内核中的 FD\\_SETSIZE 限制， 默认最⼤值为 1024 ，只能监听 0~1023 的⽂件描述符。\n\n> select 机制的缺点：\n\n（1）每次调用 select，都需要把 fd\\_set 集合从用户态拷贝到内核态，如果 fd\\_set 集合很大时，那这个开销也很大，比如百万连接却只有少数活跃连接时这样做就太没有效率。\n\n（2）每次调用 select 都需要在内核遍历传递进来的所有 fd\\_set，如果 fd\\_set 集合很大时，那这个开销也很大。\n\n（3）为了减少数据拷贝带来的性能损坏，内核对被监控的 fd\\_set 集合大小做了限制，一般为 1024，如果想要修改会比较麻烦，可能还需要编译内核。\n\n（4）每次调用 select 之前都需要遍历设置监听集合，重复工作。\n\n* **poll**\n\npoll 不再⽤ BitsMap 来存储所关注的⽂件描述符，取⽽代之⽤动态数组，以链表形式来组织，突破了 select 的⽂件描述符个数限制，当然还会受到系统⽂件描述符限制。\n\n但是 poll 和 select 并没有太⼤的本质区别，都是使⽤线性结构存储进程关注的 Socket 集合，因此都需要遍历⽂件描述符集合来找到可读或可写的 Socke，时间复杂度为 O(n)，⽽且也需要在⽤户态与内核态之间拷⻉⽂件描述符集合，这种⽅式随着并发数上来，性能的损耗会呈指数级增⻓。\n\n* **epoll**\n\nepoll 通过两个⽅⾯，很好解决了 select/poll 的问题。\n\n第⼀点，epoll 在内核⾥使⽤**红⿊树来跟踪进程所有待检测的⽂件描述字**，把需要监控的 socket 通过 epoll\\_ctl() 函数加⼊内核中的红⿊树⾥，红⿊树是个⾼效的数据结构，增删查⼀般时间复杂度是 O(logn) ，通过对这棵⿊红树进⾏操作，这样就不需要像 select/poll 每次操作时都传⼊整个 socket 集合，只需要传⼊⼀个待检测的 socket，**减少了内核和⽤户空间⼤量的数据拷⻉和内存分配**。\n\n第⼆点， epoll 使⽤事件驱动的机制，内核⾥**维护了⼀个链表来记录就绪事件**，当某个 socket 有事件发⽣时，通过回调函数，内核会将其加⼊到这个就绪事件列表中，当⽤户调⽤ epoll\\_wait() 函数时，只会返回有事件发⽣的⽂件描述符的个数，不需要像 select/poll 那样轮询扫描整个 socket 集合，⼤⼤提⾼了检测的效率。\n\n![epoll接口作用-来源参考[3]](https://cdn.paicoding.com/tobebetterjavaer/images/sidebar/sanfene/os-cca76ac4-cfb4-4374-8fc6-256cd4d3893f.png)\n\nepoll 的⽅式即使监听的 Socket 数量越多的时候，效率不会⼤幅度降低，能够同时监听的 Socket 的数⽬也⾮常的多了，上限就为系统定义的进程打开的最⼤⽂件描述符个数。因⽽，**epoll** **被称为解决** **C10K** **问题的利器**。"
+ },
+ {
+ "id": 452,
+ "question": "普通内存比一般的机械硬盘快多少？（补充）",
+ "answer": "> 2024 年 04 月 10 日增补\n\n机械硬盘，也叫 HDD（Hard Disk Drive），是一种通过磁盘旋转和磁头移动来存储数据的设备，读写速度比较慢，通常比内存的速度慢 10 万倍左右。\n\n* HDD 的访问时间大约在 5-10ms，数据传输速率约为 100 到 200 MB/s。\n* 内存，也就是 RAM（Random Access Memory），访问时间大约在 10-100ns，数据传输速率约为数十 GB/s。\n\n固态硬盘（Solid State Drive，SSD），SSD 的读写速度比 HDD 快 200 倍左右，价格也在逐渐下降，已经逐渐取代了 HDD。\n\n\n> 图文详解 34 道操作系统面试高频题，这次吊打面试官，我觉得稳了（手动 dog）。整理：练习伴侣二，戳[转载链接](https://mp.weixin.qq.com/s/CYsn0M5ddDuG--mALmhsuw)，作者：三分恶，戳[原文链接](https://mp.weixin.qq.com/s/KMGyn-FLkvzsMH06LV4OfQ)。\n\n---\n\n*没有什么使我停留——除了目的，纵然岸旁有玫瑰、有绿荫、有宁静的港湾，我是不系之舟*。\n\n**系列内容**：\n\n\n\n---"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 10,
+ "topicName": "计算机网络",
+ "categories": [
+ {
+ "id": 68,
+ "categoryName": "基础",
+ "questions": [
+ {
+ "id": 453,
+ "question": "说下计算机网络体系结构",
+ "answer": "计算机网络体系结构通过将复杂的网络通信分解成不同的层次，来标准化交互的过程。常见的模型包括 OSI 七层模型、TCP/IP 四层模型和五层体系结构。\n\n\n\nOSI 是理论上的网络通信模型，TCP/IP 是实际应用层面上的网络通信模型，五层结构是为了方便理解和记忆。\n\n#### [说说 OSI 七层模型？](#说说-osi-七层模型)\n\nOSI（Open System Interconnection）七层参考模型是一个网络架构模型，由国际标准化组织（ISO）提出，用于描述和标准化各种计算机网络的功能和过程。这七层从高到低分别是：\n\n* **应用层**：最靠近用户的层，负责处理特定的应用程序细节。这一层提供了网络服务与用户应用软件之间的接口。例如，Web 浏览器、FTP 客户端和服务器、电子邮件客户端等。\n* **表示层**：确保从一个系统发送的信息可以被另一个系统的应用层读取。它负责数据的转换、压缩和加密。例如，确保数据从一种编码格式转换为另一种，如 ASCII 到 EBCDIC。\n* **会话层**：管理用户的会话，控制网络上两节点间的对话和数据交换的管理。它负责建立、维护和终止会话。例如，建立一个会话令牌，以便在网络上的两个节点之间传递。\n* **传输层**：提供端到端的通信服务，保证数据的完整性和正确顺序。这一层包括 TCP 和 UDP 等。\n* **网络层**：负责在多个网络之间进行数据传输，确保数据能够在复杂的网络结构中找到从源到目的地的最佳路径。这层使用的是 IP（Internet Protocol）协议。\n* **数据链路层**：在物理连接中提供可靠的传输，负责建立和维护两个相邻节点间的链路。包括帧同步、MAC（媒体访问控制）。\n* **物理层**：负责在物理媒介上实现原始的数据传输，比如电缆、光纤和无线信号传输。涉及的内容包括电压、接口、针脚、电缆的规格和传输速率等。\n\n#### [说说 TCP/IP 四层模型？](#说说-tcp-ip-四层模型)\n\nTCP/IP 四层模型是互联网通信的核心，定义了一系列协议和标准，确保设备间可以可靠地进行数据传输。\n\n\n\n①、**应用层（Application Layer）**：直接面向用户和应用程序，提供各种网络服务。它包含了用于特定应用的协议和服务，如 HTTP（HyperText Transfer Protocol）、FTP（File Transfer Protocol）、SMTP（Simple Mail Transfer Protocol）等。\n\n示例：当在浏览器中输入一个 URL 并访问一个网页时，浏览器使用 HTTP 协议从 Web 服务器请求页面内容。\n\n②、**传输层（Transport Layer）**：提供端到端的通信服务，确保数据可靠传输。它负责分段数据、流量控制、错误检测和纠正。常见的传输层协议有 TCP 和 UDP。\n\n示例：当发送一封电子邮件时，TCP 协议确保邮件从你的客户端可靠地传输到邮件服务器。\n\n③、**网际层**：或者叫网络层（Internet Layer），负责在不同网络之间路由数据包，提供逻辑地址（IP 地址）和网络寻址功能。用于处理数据包的分组、转发和路由选择，确保数据可以从源端传输到目标端。\n\n常见协议：IPv4、IPv6、ICMP（Internet Control Message Protocol）。\n\n示例：当访问一个网站时，网络层协议（如 IPv4）将你的请求从你的计算机通过多个路由器传输到目标服务器。\n\n④、**网络接口层（Network Access Layer）**：或者叫链路层（Link Layer），负责将数字信号在物理通道（网线）中准确传输，定义了如何在单一网络链路上传输数据，如何处理数据帧的发送和接收，包括物理地址（MAC 地址）的解析。\n\n常见协议：以太网（Ethernet）、Wi-Fi。\n\n示例：在一个局域网（LAN）中，计算机通过以太网连接交换机，链路层协议负责数据帧在网络设备间的传输。\n\n#### [说说五层体系结构？](#说说五层体系结构)\n\n是对 OSI 和 TCP/IP 的折衷，它保留了 TCP/IP 的实用性，同时提供了比四层模型更细致的分层，便于教学和理解网络的各个方面。\n\n* 应用层：作为网络服务和最终用户之间的接口。它提供了一系列供应用程序使用的协议，如 HTTP（网页）、FTP（文件传输）、SMTP（邮件传输）等。使用户的应用程序可以访问网络服务。\n* 传输层：提供进程到进程的通信管理，这一层确保数据按顺序、无错误地传输。主要协议包括 TCP 和 UDP。\n* 网络层：负责数据包从源到目的地的传输和路由选择，包括跨越多个网络（即互联网）。它使用逻辑地址（如 IP 地址）来唯一标识设备。路由器是网络层设备。\n* 数据链路层：确保从一个节点到另一个节点的可靠、有效的数据传输。交换机、网桥是数据链路层设备。\n* 物理层：电缆、光纤、无线电频谱、网络适配器等。\n\n#### [TCP三次握手四次挥手工作在哪一层？](#tcp三次握手四次挥手工作在哪一层)\n\n三次握手和四次挥手都是工作在传输层。传输层（Transport Layer）是 OSI 模型的第四层，负责提供端到端的通信服务，包括数据传输的建立、维护和终止。\n\nTCP 作为一种面向连接的协议，通过三次握手建立连接，通过四次挥手终止连接，确保数据传输的可靠性和完整性。\n\n#### [讲一下计算机网络？](#讲一下计算机网络)\n\n计算机网络是指将多台计算机通过通信设备互联起来，实现资源共享和信息传递的系统。\n\n"
+ },
+ {
+ "id": 454,
+ "question": "说一下每一层对应的网络协议有哪些？",
+ "answer": "一张表格总结常见网络协议：\n\n"
+ },
+ {
+ "id": 455,
+ "question": "那么数据在各层之间是怎么传输的呢？",
+ "answer": "对于发送方而言，从上层到下层层层包装，对于接收方而言，从下层到上层，层层解开包装。\n\n* 发送方的应用进程向接收方的应用进程传送数据\n* AP 先将数据交给本主机的应用层，应用层加上本层的控制信息 H5 就变成了下一层的数据单元\n* 传输层收到这个数据单元后，加上本层的控制信息 H4，再交给网络层，成为网络层的数据单元\n* 到了数据链路层，控制信息被分成两部分，分别加到本层数据单元的首部（H2）和尾部（T2）\n* 最后的物理层，进行比特流的传输\n\n\n\n这个过程类似写信，写一封信，每到一层，就加一个信封，写一些地址的信息。到了目的地之后，又一层层解封，传向下一个目的地。"
+ }
+ ]
+ },
+ {
+ "id": 69,
+ "categoryName": "网络综合",
+ "questions": [
+ {
+ "id": 456,
+ "question": "从浏览器地址栏输入 url 到显示网页的过程了解吗？",
+ "answer": "这个过程包括多个步骤，涵盖了 DNS 解析、TCP 连接、发送 HTTP 请求、服务器处理请求并返回 HTTP 响应、浏览器处理响应并渲染页面等多个环节。\n\n1. **DNS 解析**：浏览器会发起一个 DNS 请求到 DNS 服务器，将域名解析为服务器的 IP 地址。\n2. **TCP 连接**：浏览器通过解析得到的 IP 地址与服务器建立 TCP 连接。这一步涉及到 TCP 的三次握手，用于确保双方都已经准备好进行数据传输了。\n3. **发送 HTTP 请求**：浏览器构建 HTTP 请求，包括请求行、请求头和请求体；然后将请求发送到服务器。\n4. **服务器处理请求**：服务器接收到 HTTP 请求后，根据请求的资源路径，经过后端处理，生成 HTTP 响应消息；响应消息包括状态行、响应头和响应体。\n5. **浏览器接收 HTTP 响应**：浏览器接收到服务器返回的 HTTP 响应数据后，开始解析响应体中的 HTML 内容；然后构建 DOM 树、解析 CSS 和 JavaScript 文件等，最终渲染页面。\n6. **断开连接**：TCP 四次挥手，连接结束。\n\n我们以输入 www.baidu.com 为例：\n\n\n\n#### [各个过程都使用了哪些协议？](#各个过程都使用了哪些协议)\n\n"
+ },
+ {
+ "id": 457,
+ "question": "说说 DNS 的解析过程？",
+ "answer": "DNS 的全称是 **Domain Name System**，也就是域名解析系统，它可以将域名映射到对应的 IP 地址上，比如说我们访问 www.javabetter.cn，实际上访问的是我在阿里云上一台丐版服务器，它的 IP 地址是 xxx.xxx.xxx.xxx。\n\n当然了，也可以通过 IP 地址直接访问服务器，但不方便记忆，所以就有了域名系统。一个好的域名可以卖好多好多钱，像 javabetter.cn 这个域名，一年需要 39 块钱。\n\n域名到 IP 之间的映射，就需要 DNS 来完成。\n\n\n\n我来说说 DNS 的解析过程吧：\n\n\n\n假设我们在浏览器地址栏里键入了 [paicoding.com](https://paicoding.com)：\n\n浏览器会首先检查自己的缓存中是否有这个域名对应的 IP 地址，如果有，直接返回；如果没有，进入下一步。\n\n\n\n检查本地 DNS 缓存是否有该域名的记录。如果没有，向**根域名服务器**发送请求，根域名服务器将请求指向更具体的服务，如 `com` 顶级域名服务器。\n\n顶级域名服务器再将请求指向权限域名服务器，通常由域名注册机构直接管理，`paicoding.com`是在阿里云上注册的，所以阿里云会提供对应的 DNS 解析服务，将域名和阿里云服务器绑定起来。\n\n最终，浏览器使用获得的 IP 地址发起一个 HTTP 请求到目标服务器，然后该服务器返回所请求的网页内容。"
+ },
+ {
+ "id": 458,
+ "question": "说说 WebSocket 与 Socket 的区别？",
+ "answer": "* Socket 其实就是等于 **IP 地址 + 端口 + 协议**。\n\n> 具体来说，Socket 是一套标准，它完成了对 TCP/IP 的高度封装，屏蔽网络细节，以方便开发者更好地进行网络编程。\n\n* WebSocket 是一个持久化的协议，它是伴随 H5 而出的协议，用来解决 **http 不支持持久化连接**的问题。\n* Socket 一个是**网编编程的标准接口**，而 WebSocket 则是应用层通信协议。"
+ },
+ {
+ "id": 459,
+ "question": "说一下你了解的端口及对应的服务？",
+ "answer": ""
+ },
+ {
+ "id": 460,
+ "question": "平常有抓包吗（补充）？",
+ "answer": "> 2024 年 12 月 25 日新增\n\n我平常使用最多的就是 chrome 浏览器自带的 network 面板了，可以看到请求的时间、请求的信息，以及响应信息。\n\n\n\n更专业的还有 fidder、wireshark 等工具。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 70,
+ "categoryName": "HTTP",
+ "questions": [
+ {
+ "id": 461,
+ "question": "说说 HTTP 常用的状态码及其含义？",
+ "answer": "HTTP 状态码用于表示服务器对请求的处理结果，可以分为 5 种：\n\n* 1xx 服务器收到请求，需要进一步操作，例如 100 Continue。\n* 2xx 请求成功处理，例如 200 OK。\n* 3xx 重定向：需要进一步操作以完成请求；例如 304 Not Modified 表示资源未修改，客户端可以使用缓存。\n* 4xx 客户端错误：请求有问题，例如 404 Not Found 表示资源不存在。\n* 5xx 服务器错误，例如500 Internal Server Error 表示服务器内部错误。\n\n\n\n#### [说一下 301 和 302 的区别？](#说一下-301-和-302-的区别)\n\n* 301：永久性移动，请求的资源已被永久移动到新位置。服务器返回此响应时，会返回新的资源地址。\n* 302：临时性性移动，服务器从另外的地址响应资源，但是客户端还应该使用这个地址。\n\n用一个比喻，301 就是嫁人的新垣结衣，302 就是有男朋友的长泽雅美。"
+ },
+ {
+ "id": 462,
+ "question": "HTTP 有哪些请求方式？",
+ "answer": "HTTP 协议定义了多种请求方式，用以指示请求的目的。常见的请求方式有 GET、POST、DELETE、PUT。\n\n\n\n* GET：请求检索指定的资源。应该只用于获取数据，并且是幂等的，即多次执行相同的 GET 请求应该返回相同的结果，并且不会改变资源的状态。\n* POST：向指定资源提交数据，请求服务器进行处理（如提交表单或上传文件）。数据被包含在请求体中。可能会创建新的资源或修改现有资源。\n* DELETE：删除指定的资源。\n* PUT：用于替换指定的资源。如果指定的资源不存在，创建一个新资源。\n* HEAD：类似于 GET 请求，只不过返回的响应中没有具体的内容，用于获取报头。可以用于检查资源是否存在，验证资源的更新时间等。\n* OPTIONS：用于获取服务器支持的 HTTP 请求方法。通常用于跨域请求中的预检请求（CORS）。\n* TRACE：回显服务器收到的请求，主要用于测试或诊断。但由于安全风险（可能暴露敏感信息），很多服务器会禁用 TRACE 请求。\n* CONNECT：建立一个到目标资源的隧道（通常用于 SSL/TLS 代理），用于在客户端和服务器之间进行加密的隧道传输。\n\n#### [HTTP 的 GET 方法可以实现写操作吗?](#http-的-get-方法可以实现写操作吗)\n\n可以是可以，但是不推荐。\n\n使用 GET 执行写操作可能导致严重的安全问题，如跨站请求伪造（CSRF）。\n\n实际开发中，也应该杜绝使用 GET 方法执行写操作。在中，我们会在接口上明确规定应该使用哪种请求方式。\n\n客户端一旦使用错误 ❎，将会收到一个 405 Method Not Allowed 的响应。\n\n#### [什么是幂等？幂等方法了解哪些？](#什么是幂等-幂等方法了解哪些)\n\n幂等（Idempotence）是一个数学概念，用于描述某些操作的特性，即无论操作执行多少次，结果都是相同的。换句话说，幂等操作可以重复执行而不会改变系统状态。\n\n如果一个操作是幂等的，那么对同一资源执行该操作一次和执行多次的效果相同。\n\n在正确实现的条件下，GET、HEAD、PUT 和 DELETE 等方法都是幂等的，而 POST 方法不是。\n\n例如，`GET /pageX HTTP/1.1` 幂等的。连续调用多次，客户端接收到的结果都是一样的：\n\n\n```text\nGET /pageX HTTP/1.1\nGET /pageX HTTP/1.1\nGET /pageX HTTP/1.1\nGET /pageX HTTP/1.1\n```\n\n\n`DELETE /idX/delete HTTP/1.1` 是幂等的，即便是不同请求之间接收到的状态码不一样：\n\n\n```text\nDELETE /idX/delete HTTP/1.1 -> Returns 200 if idX exists\nDELETE /idX/delete HTTP/1.1 -> Returns 404 as it just got deleted\nDELETE /idX/delete HTTP/1.1 -> Returns 404\n```"
+ },
+ {
+ "id": 463,
+ "question": "说⼀下 GET 和 POST 的区别？",
+ "answer": "\n\nGET 请求主要用于获取数据，参数附加在 URL 中，存在长度限制，且容易被浏览器缓存，有安全风险；而 POST 请求用于提交数据，参数放在请求体中，适合提交大量或敏感的数据。\n\n另外，GET 请求是幂等的，多次请求不会改变服务器状态；而 POST 请求不是幂等的，可能对服务器数据有影响。"
+ },
+ {
+ "id": 464,
+ "question": "GET 的长度限制是多少？",
+ "answer": "HTTP 中的 GET 方法是通过 URL 传递数据的，但是 URL 本身其实并没有对数据的长度进行限制，真正限制 GET 长度的是浏览器。\n\n例如 IE 浏览器对 URL 的最大限制是 2000 多个字符，大概 2kb 左右，像 Chrome、Firefox 等浏览器支持的 URL 字符数更多，其中 FireFox 中 URL 的最大长度限制是 65536 个字符，Chrome 则是 8182 个字符。\n\n这个长度限制也不是针对数据部分，而是针对整个 URL。"
+ },
+ {
+ "id": 465,
+ "question": "HTTP 请求的过程与原理？",
+ "answer": "HTTP 是基于 TCP/IP 协议的应用层协议，它使用 TCP 作为传输层协议，通过建立 TCP 连接来传输数据。\n\nHTTP 遵循标准的客户端-服务器模型，客户端打开连接发出请求，然后等待服务器返回的响应。\n\n\n\n* 在浏览器输入 URL 后，浏览器首先会通过 DNS 解析获取到服务器的 IP 地址，然后与服务器建立 TCP 连接。\n* TCP 连接建立后，浏览器会向服务器发送 HTTP 请求。\n* 服务器收到请求后，会根据请求的信息处理请求。\n* 处理完请求后，服务器会返回一个 HTTP 响应给浏览器。\n* 浏览器收到响应后，会根据响应的信息渲染页面。然后，浏览器和服务器断开 TCP 连接。\n\n客户端发送一个请求到服务器，服务器处理请求并返回一个响应。这个过程是同步的，也就是说，客户端在发送请求后必须等待服务器的响应。在等待响应的过程中，客户端不会发送其他请求。\n\n#### [怎么利用多线程来下载一个数据呢？](#怎么利用多线程来下载一个数据呢)\n\n可以采取分块下载的策略。首先，通过 HEAD 请求获取文件的总大小。然后根据文件大小和线程数，将文件进行切割。每个线程负责下载一个特定范围的数据。\n\n可以通过设置 HTTP 请求头的 Range 字段指定下载的字节区间。例如，`Range: bytes=0-1023` 表示下载文件的前 1024 字节。\n\n最后启动多线程下载。\n\n代码片段 1：获取文件大小\n\n\n```java\nURL url = new URL(\"https://javabetter.cn/file.zip\");\nHttpURLConnection connection = (HttpURLConnection) url.openConnection();\nconnection.setRequestMethod(\"HEAD\");\nint fileSize = connection.getContentLength(); // 获取文件大小\nconnection.disconnect();\n```\n\n\n代码片段 2：下载文件\n\n\n```java\npublic void downloadChunk(String url, int start, int end, String outputPath) {\n try {\n URL fileUrl = new URL(url);\n HttpURLConnection connection = (HttpURLConnection) fileUrl.openConnection();\n connection.setRequestProperty(\"Range\", \"bytes=\" + start + \"-\" + end);\n\n InputStream inputStream = connection.getInputStream();\n RandomAccessFile file = new RandomAccessFile(outputPath, \"rw\");\n file.seek(start); // 定位到文件的相应位置\n\n byte[] buffer = new byte[1024];\n int bytesRead;\n while ((bytesRead = inputStream.read(buffer)) != -1) {\n file.write(buffer, 0, bytesRead);\n }\n\n file.close();\n inputStream.close();\n connection.disconnect();\n } catch (IOException e) {\n e.printStackTrace();\n }\n}\n```\n\n\n代码片段 3：启动多线程下载\n\n\n```java\nint numThreads = 4;\nint fileSize = 100000000; // 假设文件大小为 100MB\nint chunkSize = fileSize / numThreads;\nString url = \"https://javabetter.cn/file.zip\";\nString outputPath = \"path/to/local/file.zip\";\n\nExecutorService executor = Executors.newFixedThreadPool(numThreads);\nfor (int i = 0; i < numThreads; i++) {\n int start = i * chunkSize;\n int end = (i == numThreads - 1) ? fileSize - 1 : (start + chunkSize - 1);\n executor.execute(() -> downloadChunk(url, start, end, outputPath));\n}\nexecutor.shutdown();\n```\n\n\nPS：大家可以在本地简单测试一下。\n\n\n\n#### [如果只要下载数据的前十个字节呢？](#如果只要下载数据的前十个字节呢)\n\n只需要设置 Range 字段为 `Range: bytes=0-9` 即可。"
+ },
+ {
+ "id": 466,
+ "question": "说一下 HTTP 的报文结构？",
+ "answer": "HTTP 的报文结构分为：请求报文和响应报文。两者在结构上很相似，都包含了**起始行**、**头部**和**消息正文**。\n\n\n\n#### [说下 HTTP 的请求报文结构？](#说下-http-的请求报文结构)\n\n请求报文由请求行、请求头部、空行和消息正文组成。如下所示：\n\n\n```text\nGET /index.html HTTP/1.1\nHost: www.javabetter.cn\nAccept: text/html\nUser-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3\n```\n\n\n①、请求行包括请求方法、请求 URL 和 HTTP 协议的版本。例如：`GET /index.html HTTP/1.1`。\n\n②、请求头部包含请求的附加信息，如客户端想要接收的内容类型、浏览器类型等。例如：\n\n* `Host: www.javabetter.cn`，表示请求的主机名（域名）\n* `Accept: text/html`，表示客户端可以接收的媒体类型\n* `User-Agent: Mozilla/5.0`，表示客户端的浏览器类型\n* Range：用于指定请求内容的范围，如断点续传时表示请求的字节范围。\n\n③、请求头部和消息正文之间有一个空行，表示请求头部结束。\n\n④、消息正文是可选的，如 POST 请求中的表单数据；GET 请求中没有消息正文。\n\n#### [说下 HTTP 响应报文结构？](#说下-http-响应报文结构)\n\n\n```http\nHTTP/1.0 200 OK\nContent-Type: text/plain\nContent-Length: 137582\nExpires: Thu, 05 Dec 1997 16:00:00 GMT\nLast-Modified: Wed, 5 August 1996 15:55:28 GMT\nServer: Apache 0.84\n\n 练习伴侣二很天真\n\n```\n\n\n①、状态行\n\n包括 HTTP 协议的版本、状态码（如 200、404）和状态消息（如 OK、NotFound）。例如：`HTTP/1.0 200 OK`。\n\n②、响应头部\n\n包含响应的附加信息，如服务器类型、内容类型、内容长度等。也是键值对，例如：\n\n* `Content-Type: text/plain`，表示响应的内容类型\n* `Content-Length: 137582`，表示响应的内容长度\n* `Expires: Thu, 05 Dec 1997 16:00:00 GMT`，表示资源的过期时间\n* `Last-Modified: Wed, 5 August 1996 15:55:28 GMT`，表示资源的最后修改时间\n* `Server: Apache 0.84`，表示服务器类型\n\n③、空行\n\n表示响应头部结束。\n\n④、消息正文（可选）\n\n响应的具体内容，如 HTML 页面。不是所有的响应都有消息正文，如 204 No Content 状态码的响应。"
+ },
+ {
+ "id": 467,
+ "question": "URI 和 URL 有什么区别?",
+ "answer": "\n\n* URI，统一资源标识符(Uniform Resource Identifier， URI)，标识的是 Web 上每一种可用的资源，如 HTML 文档、图像、视频片段、程序等都是由一个 URI 进行标识的。\n* URL，统一资源定位符（Uniform Resource Location），它是 URI 的一种子集，主要作用是提供资源的路径。\n\n它们的主要区别在于，URL 除了提供了资源的标识，还提供了资源访问的方式。这么比喻，URI 像是身份证，可以唯一标识一个人，而 URL 更像一个住址，可以通过 URL 找到这个人——人类住址协议://地球/中国/北京市/海淀区/xx 职业技术学院/14 号宿舍楼/525 号寝/张三.男。"
+ },
+ {
+ "id": 468,
+ "question": "说下 HTTP1.0，1.1，2.0 的区别？",
+ "answer": "**HTTP1.0** 默认是短连接，HTTP 1.1 默认是长连接，HTTP 2.0 采用的**多路复用**。\n\n\n\n#### [说下 HTTP1.0](#说下-http1-0)\n\n* **无状态协议**：HTTP 1.0 是无状态的，每个请求之间相互独立，服务器不保存任何请求的状态信息。\n* **非持久连接**：默认情况下，每个 HTTP 请求/响应对之后，连接会被关闭，属于短连接。这意味着对于同一个网站的每个资源请求，如 HTML 页面上的图片和脚本，都需要建立一个新的 TCP 连接。可以设置`Connection: keep-alive` 强制开启长连接。\n\n#### [说下 HTTP1.1](#说下-http1-1)\n\n* **持久连接**：HTTP 1.1 引入了持久连接（也称为 HTTP keep-alive），默认情况下不会立即关闭连接，可以在一个连接上发送多个请求和响应。极大减轻了 TCP 连接的开销。\n* **流水线处理**：HTTP 1.1 支持客户端在前一个请求的响应到达之前发送下一个请求，以提高传输效率。\n\n#### [说下 HTTP2.0](#说下-http2-0)\n\n* **二进制协议**：HTTP 2.0 使用二进制而不是文本格式来传输数据，解析更加高效。\n* **多路复用**：一个 TCP 连接上可以同时进行多个 HTTP 请求/响应，解决了 HTTP 1.x 的队头阻塞问题。\n* **头部压缩**：HTTP 协议不带状态，所以每次请求都必须附上所有信息。HTTP 2.0 引入了头部压缩机制，可以使用 gzip 或 compress 压缩后再发送，减少了冗余头部信息的带宽消耗。\n* **服务端推送**：服务器可以主动向客户端推送资源，而不需要客户端明确请求。"
+ },
+ {
+ "id": 469,
+ "question": "HTTP/3 了解吗？",
+ "answer": "HTTP/2.0 基于 TCP 协议，而 HTTP/3.0 则基于 QUIC 协议，Quick UDP Connections，直译为快速 UDP 网络连接。\n\n\n\n基于 TCP 的 HTTP/2.0，尽管从逻辑上来说，不同的流之间相互独立，不会相互影响，但在实际传输的过程中，数据还是要一帧一帧的发送和接收，一旦某一个流的数据有丢包，仍然会阻塞在它之后传输的流数据。\n\n而基于 UDP 的 QUIC 协议可以更彻底地解决这样的问题，让不同的流之间真正的实现相互独立传输，互不干扰。\n\n同时，QUIC 协议在传输的过程中就完成了 TLS 加密握手，更直接了。\n\n#### [目前使用最广泛的是哪个HTTP版本？](#目前使用最广泛的是哪个http版本)\n\n应该是 HTTP/2，在 2022 年 1 月达到峰值，占所有网站的 46.9%。\n\n统计网站：[w3techs](https://w3techs.com/technologies/history_overview/site_element/all)\n\n"
+ },
+ {
+ "id": 470,
+ "question": "HTTP 长连接了解吗？",
+ "answer": "在 HTTP 中，长连接是指客户端和服务器之间在一次 HTTP 通信完成后，不会立即断开，而是保留连接以供后续请求复用。\n\n这种机制可以减少了频繁建立和关闭连接的开销\n\n#### [如何设置长连接？](#如何设置长连接)\n\n可以通过 Connection: keep-alive 实现。在 HTTP/1.1 中，长连接是默认开启的。\n\n#### [在什么时候会超时呢？](#在什么时候会超时呢)\n\n* HTTP 一般会有 httpd 守护进程，里面可以设置 **keep-alive timeout**，当 tcp 连接闲置超过这个时间就会关闭，也可以在 HTTP 的 header 里面设置超时时间\n* TCP 的 **keep-alive** 包含三个参数，支持在系统内核的 net.ipv4 里面设置；当 TCP 连接之后，闲置了 **tcp\\_keepalive\\_time**，则会发生侦测包，如果没有收到对方的 ACK，那么会每隔 tcp\\_keepalive\\_intvl 再发一次，直到发送了 **tcp\\_keepalive\\_probes**，就会丢弃该连接。\n\n\n```text\n1. tcp_keepalive_intvl = 15\n2. tcp_keepalive_probes = 5\n3. tcp_keepalive_time = 1800\n```"
+ },
+ {
+ "id": 471,
+ "question": "说说 HTTP 与 HTTPS 有哪些区别？",
+ "answer": "HTTPS 是 HTTP 的增强版，在 HTTP 的基础上加入了 SSL/TLS 协议，确保数据在传输过程中是加密的。\n\n\n\nHTTP 的默认端⼝号是 80，URL 以`http://`开头；HTTPS 的默认端⼝号是 443，URL 以`https://`开头。"
+ },
+ {
+ "id": 472,
+ "question": "为什么要用 HTTPS？",
+ "answer": "HTTP 是明文传输的，存在数据窃听、数据篡改和身份伪造等问题。而 HTTPS 通过引入 SSL/TLS，解决了这些问题。\n\nSSL/TLS 在加密过程中涉及到了两种类型的加密方法：\n\n* 非对称加密：服务器向客户端发送公钥，然后客户端用公钥加密自己的随机密钥，也就是会话密钥，发送给服务器，服务器用私钥解密，得到会话密钥。\n* 对称加密：双方用会话密钥加密通信内容。\n\n\n\n客户端会通过数字证书来验证服务器的身份，数字证书由 CA 签发，包含了服务器的公钥、证书的颁发机构、证书的有效期等。"
+ },
+ {
+ "id": 473,
+ "question": "HTTPS是怎么建立连接的？",
+ "answer": "\n\nHTTPS 的连接建立在 SSL/TLS 握手之上，其过程可以分为两个阶段：握手阶段和数据传输阶段。\n\n①、客户端向服务器发起请求\n\n②、服务器接收到请求后，返回自己的数字证书，包含了公钥、颁发机构等信息。\n\n③、客户端收到服务器的证书后，验证证书的合法性，如果合法，会生成一个随机码，然后用服务器的公钥加密这个随机码，发送给服务器。\n\n④、服务器收到会话密钥后，用私钥解密，得到会话密钥。\n\n⑤、客户端和服务器通过会话密码对通信内容进行加密，然后传输。\n\n如果通信内容被截取，但由于没有会话密钥，所以无法解密。当通信结束后，连接会被关闭，会话密钥也会被销毁，下次通信会重新生成一个会话密钥。\n\n#### [HTTPS 会加密 URL 吗？](#https-会加密-url-吗)\n\nHTTPS 通过 SSL/TLS 协议确保了客户端与服务器之间交换的数据被加密，这包括 HTTP 头部和正文。\n\n而 URL 是 HTTP 头部的一部分，因此这部分信息也是加密的。\n\n\n\n但因为涉及到 SSL 握手的过程，所以域名信息会被暴露出来，需要注意。\n\n\n\n另外，完整的 URL 可能在 Web 服务器的日志中记录，这些日志可能是明文的。还有，URL 在浏览器历史记录中也是可见的。\n\n因此，敏感信息永远不应该通过 URL 传递，即使是在使用 HTTPS 的情况下。\n\n#### [什么是中间人攻击？](#什么是中间人攻击)\n\n中间人攻击（Man-in-the-Middle, MITM）是一种常见的网络安全威胁，攻击者可以在通信的两端插入自己，以窃取通信双方的信息。\n\n\n\n在很多电影中，都会存在这样的场景：主角通过某种方式，将自己伪装成中间人，然后窃取通信双方的信息，阿汤哥的碟中谍中就有很多类似的手笔。\n\n中间人攻击是一个缺乏相互认证的攻击，因此大多数加密协议都会专门加入一些特殊的认证方法，以防止中间人攻击。像 SSL 协议，就是通过验证服务器的数字证书，是否由 CA（权威的受信任的数字证书认证机构）签发，来防止中间人攻击的。\n\n#### [HTTPS怎么保证建立的信道是安全的？](#https怎么保证建立的信道是安全的)\n\n主要通过 SSL/TLS 协议的多层次安全机制，首先在握手阶段，客户端和服务器使用得是非对称加密，生成的会话密钥只有服务器的私钥才能解密，而私钥只有服务器持有。\n\n在数据传输阶段，即使攻击者拦截了通信数据，没有会话密钥也无法解密。\n\n#### [HTTPS 能抓包吗？](#https-能抓包吗)\n\n可以，HTTPS 可以抓包，但因为通信内容是加密的，需要解密后才能查看。\n\n\n\n其原理是通过一个中间人，伪造服务器证书，并取得客户端的信任，然后将客户端的请求转发给服务器，将服务器的响应转发给客户端，完成中间人攻击。\n\n常用的抓包工具有 Wireshark、Fiddler、Charles 等。"
+ },
+ {
+ "id": 474,
+ "question": "客户端怎么去校验证书的合法性？",
+ "answer": "首先，所有的证书都是由 CA 机构签发的，CA 机构是一个受信任的第三方机构，它会对证书的申请者进行身份验证，然后签发证书。\n\nCA 就像是网络世界的公安局，具有极高的可信度。\n\n\n\nCA 签发证书的过程是非常严格的：\n\n* 首先，CA 会把持有者的公钥、⽤途、颁发者、有效时间等信息打成⼀个包，然后对这些信息进⾏ Hash 计算，得到⼀个 Hash 值；\n* 然后 CA 会使⽤⾃⼰的私钥将该 Hash 值加密，⽣成 Certificate Signature；\n* 最后将 Certificate Signature 添加在⽂件证书上，形成数字证书。\n\n\n\n客户端（通常是浏览器，通常会集成 CA 的公钥信息）在校验证书的合法性时，主要通过以下步骤来校验证书的合法性。\n\n* 浏览器会读取证书的所有者、有效期、颁发者等信息，先校验网站域名是否一致，然后校验证书的有效期是否过期；\n* 浏览器开始查找内置的 CA，与服务器返回证书中的颁发者进行对比，确认是否为合法机构；\n* 如果是，从内部植入的 CA 公钥解密 Certificate 的 Signature 内容，得到⼀个 Hash 值 H2；\n* 使⽤同样的 Hash 算法获取证书的 Hash 值 H1，⽐较 H1 和 H2，如果值相同，则为可信赖的证书，否则告警。\n\n假如在 HTTPS 的通信过程中，中间人篡改了证书，但由于他没有 CA 机构的私钥，所以无法生成正确的 Signature，因此就无法通过校验。"
+ },
+ {
+ "id": 475,
+ "question": "如何理解 HTTP 协议是无状态的？",
+ "answer": "HTTP 协议是无状态的，这意味着每个 HTTP 请求都是独立的，服务器不会保留任何关于客户端请求的历史信息。\n\n换句话说，我家大门常打开，是人是神都欢迎，我不在乎，只要给钱，哦不，按规矩，一切好办。\n\n* 每个 HTTP 请求都包含了所必须的信息，服务器在处理当前请求时，不依赖于之前的任何请求信息。\n* 服务器不会记录任何客户端请求的状态，每次请求都像是第一次与服务器通信。\n\n由于 HTTP 是无状态的，像用户的购物车状态就必须通过其他方式来保持，如在每次请求中传递用户的 ID，或者使用 Cookie 在客户端保存购物车状态。\n\n#### [那有什么办法记录状态呢？](#那有什么办法记录状态呢)\n\n1. Cookies：服务器通过 Set-Cookie 响应头将状态信息存储在客户端，客户端在后续请求中发送该 Cookie 以维持状态。\n2. Session：服务器生成一个唯一的会话 ID，存储在 Cookie 中，并在服务器端维护与该会话 ID 关联的状态信息。\n3. Token：使用 JWT（JSON Web Token）等机制在客户端存储状态信息，客户端在每次请求中发送该 Token。"
+ },
+ {
+ "id": 476,
+ "question": "说说 Session 和 Cookie 有什么联系和区别?",
+ "answer": "先来看看什么是 Session 和 Cookie ：\n\n* Cookie 是保存在客户端的一小块文本串的数据。客户端向服务器发起请求时，服务端会向客户端发送一个 Cookie，客户端就把 Cookie 保存起来。在客户端下次向同一服务器再发起请求时，Cookie 被携带发送到服务器。服务端可以根据这个 Cookie 判断用户的身份和状态。\n* Session 指的就是服务器和客户端一次会话的过程。它是另一种记录客户状态的机制。不同的是 cookie 保存在客户端浏览器中，而 session 保存在服务器上。客户端浏览器访问服务器的时候，服务器把客户端信息以某种形式记录在服务器上，这就是 session。客户端浏览器再次访问时只需要从该 session 中查找用户的状态。\n\n\n> Session 和 Cookie 到底有什么不同呢？\n\n* 存储位置不一样，Cookie 保存在客户端，Session 保存在服务器端。\n* 存储数据类型不一样，Cookie 只能保存 ASCII，Session 可以存任意数据类型，一般情况下我们可以在 Session 中保持一些常用变量信息，比如说 UserId 等。\n* 有效期不同，Cookie 可设置为长时间保持，比如我们经常使用的默认登录功能，Session 一般有效时间较短，客户端关闭或者 Session 超时都会失效。\n* 隐私策略不同，Cookie 存储在客户端，比较容易遭到不法获取，早期有人将用户的登录名和密码存储在 Cookie 中导致信息被窃取；Session 存储在服务端，安全性相对 Cookie 要好一些。\n* 存储大小不同， 单个 Cookie 保存的数据不能超过 4K，Session 可存储数据远高于 Cookie。\n\n> Session 和 Cookie 有什么关联呢？\n\n可以使用 Cookie 记录 Session 的标识。\n\n\n\n* 用户第一次请求服务器时，服务器根据用户提交的信息，创建对应的 Session，请求返回时将此 Session 的唯一标识信息 SessionID 返回给浏览器，浏览器接收到服务器返回的 SessionID 信息后，会将此信息存入 Cookie 中，同时 Cookie 记录此 SessionID 是属于哪个域名。\n* 当用户第二次访问服务器时，请求会自动判断此域名下是否存在 Cookie 信息，如果存在，则自动将 Cookie 信息也发送给服务端，服务端会从 Cookie 中获取 SessionID，再根据 SessionID 查找对应的 Session 信息，如果没有找到，说明用户没有登录或者登录失效，如果找到 Session 证明用户已经登录可执行后面操作。\n\n> **分布式环境下 Session 怎么处理呢？**\n\n分布式环境下，客户端请求经过负载均衡，可能会分配到不同的服务器上，假如一个用户的请求两次没有落到同一台服务器上，那么在新的服务器上就没有记录用户状态的 Session。\n\n这时候怎么办呢？\n\n可以使用 Redis 等分布式缓存来存储 Session，在多台服务器之间共享。\n\n\n> **客户端无法使用 Cookie 怎么办？**\n\n有可能客户端无法使用 Cookie，比如浏览器禁用 Cookie，或者客户端是安卓、IOS 等等。\n\n这时候怎么办？SessionID 怎么存？怎么传给服务端呢？\n\n首先是 SessionID 的存储，可以使用客户端的本地存储，比如浏览器的 sessionStorage。\n\n接下来怎么传呢？\n\n* 拼接到 URL 里：直接把 SessionID 作为 URL 的请求参数\n* 放到请求头里：把 SessionID 放到请求的 Header 里，比较常用。"
+ }
+ ]
+ },
+ {
+ "id": 71,
+ "categoryName": "TCP",
+ "questions": [
+ {
+ "id": 477,
+ "question": "详细说一下 TCP 的三次握手机制",
+ "answer": "TCP（传输控制协议）的三次握手机制是一种用于在两个 TCP 主机之间建立一个可靠连接的过程。这个机制确保了两端的通信是同步的，并且在数据传输开始前，双方都准备好了进行通信。\n\n\n\n①、第一次握手：SYN（最开始都是 CLOSE，之后服务器进入 LISTEN）\n\n* **发起连接**：客户端发送一个 TCP 报文段到服务器。这个报文段的头部中，SYN 位被设置为 1，表明这是一个连接请求。同时，客户端会随机选择一个序列号（Sequence Number），假设为 x，发送给服务器。\n* **目的**：客户端通知服务器它希望建立连接，并告知服务器自己的初始序列号。\n* **状态**：客户端进入 SYN\\_SENT 状态。\n\n②、第二次握手：SYN + ACK\n\n* **确认并应答**：服务器收到客户端的连接请求后，如果同意建立连接，它会发送一个应答 TCP 报文段给客户端。在这个报文段中，SYN 位和 ACK 位都被设置为 1。服务器也会选择自己的一个随机序列号，假设为 y，并将客户端的序列号加 1（即 x+1）作为确认号（Acknowledgment Number），发送给客户端。\n* **目的**：服务器告诉客户端，它的连接请求被接受了，并通知客户端自己的初始序列号。\n* **状态**：服务器进入 SYN\\_RCVD 状态。\n\n③、第三次握手：ACK\n\n* **最终确认**：客户端收到服务器的应答后，还需要向服务器发送一个确认。这个 TCP 报文段的 ACK 位被设置为 1，确认号被设置为服务器序列号加 1（即 y+1），而自己的序列号是 x+1。\n* **目的**：客户端确认收到了服务器的同步应答，完成三次握手，建立连接。\n* **状态**：客户端进入 ESTABLISHED 状态，当服务器接收到这个包时，也进入 ESTABLISHED 状态\n\n用大白话讲 TCP 三次握手就是：\n\n三十年前的农村，电话还没有普及，所以，通信基本靠吼。\n\n老张和老练习伴侣是邻居，这天老张下地了，结果家里有事，热心的邻居老王赶紧跑到村口，开始叫唤老王。\n\n* 老练习伴侣：老张唉！我是老王，你能听得到吗？\n* 老张一听，是老练习伴侣的声音：老王老王，我是老张，我能听得到，你能听得到吗？\n* 老练习伴侣一听，嗯，没错，是老张：老张，我听到了，我有事要跟你说。\n\n\"你老婆要生了，赶紧回去吧！\"\n\n老张风风火火地赶回家，老婆顺利地生了个带把的大胖小子。握手的故事充满了幸福和美满。\n\n\n\n#### [可以再举一个例子说明 TCP 三次握手吗？](#可以再举一个例子说明-tcp-三次握手吗)\n\n当然可以，你（客户端）在一个拥挤的聚会上遇到了你想交谈的美女（服务器）。因为周围很吵，你们需要确认对方都准备好交流，并清楚地听到对方说的每一句话。\n\n**①、第一次握手：打招呼**\n\n\n\n**②、第二次握手：对方回应**\n\n\n\n**③、第三次握手：确认准备就绪**\n\n\n\n④、聊天开始\n\n这时候，你们两个就确认彼此都准备好深入交流了，可以开始你们的对话了。\n\n#### [说说 SYN 的概念？](#说说-syn-的概念)\n\nSYN 是 TCP 协议中用来建立连接的一个标志位，全称为 Synchronize Sequence Numbers，也就是同步序列编号。\n\n\n\nSYN 不仅确保了序列号的同步，使得后续的数据能够有序传输，还能防止旧的报文段被误认为是新连接。"
+ },
+ {
+ "id": 478,
+ "question": "TCP 握手为什么是三次，为什么不能是两次？不能是四次？",
+ "answer": "使用三次握手可以建立一个可靠的连接。这一过程的目的是确保双方都知道对方已准备好进行通信，并同步双方的序列号，从而保持数据包的顺序和完整性。\n\n#### [为什么 TCP 握手不能是两次？](#为什么-tcp-握手不能是两次)\n\n* 为了防止服务器一直等，等到黄花菜都凉了。\n* 为了防止客户端已经失效的连接请求突然又传送到了服务器。\n\n要知道，网络传输是有延时的（要通过网络光纤、WIFI、卫星信号传输等）。\n\n假如说客户端发起了 SYN=1 的第一次握手。服务器也及时回复了 SYN=2 和 ACK=1 的第二次握手，但是这个 ACK=1 的确认报文段因为某些原因在传输过程中丢失了。\n\n如果没有第三次握手告诉服务器，客户端收到了服务器的回应，那服务器是不知道客户端有没有接收到的。\n\n于是服务器就一直干巴巴地开着端口在等着客户端发消息呢，但其实客户端并没有收到服务器的回应，心灰意冷地跑了。\n\n\n\n这就好像你找美女要联系方式了，人家回你了，你却没听见，还以为人家看不上你，赌气地跑了；剩下的美女却一直在等你。。。\n\n还有一种情况是，一个旧的、延迟的连接请求（SYN=1）被服务器接受，导致服务器错误地开启一个不再需要的连接。\n\n\n\n举个例子：假设你（客户端）给你的朋友（服务器）发送了一个邮件（连接请求）。因为某些原因，这封邮件迟迟没有到达朋友那里，可能是因为邮局的延误。于是你决定再发一封新的邮件。朋友收到了第二封邮件，你们成功地建立了连接并开始通信。\n\n但是，过了很久，那封延误的旧邮件突然也到了你朋友那里。如果没有一种机制来识别和处理这种延误的邮件，你的朋友可能会以为这是一个新的连接请求，并尝试响应它，但其实你已经重新发了请求，原来的不需要了。这就导致了不必要的混乱和资源浪费。\n\n所以我们需要“三次握手”来确认这个过程：\n\n* 第一次握手：客户端发送 SYN 包（连接请求）给服务器，如果这个包延迟了，客户端不会一直等待，它可能会重试并发送一个新的连接请求。\n* 第二次握手：服务器收到 SYN 包后，发送一个 SYN-ACK 包（确认接收到连接请求）回客户端。\n* 第三次握手：客户端收到 SYN-ACK 包后，再发送一个 ACK 包给服务器，确认收到了服务器的响应。\n\n#### [为什么不是四次？](#为什么不是四次)\n\n三次握手已经足够创建可靠的连接了，没有必要再多一次握手。\n\n#### [什么是泛洪攻击？](#什么是泛洪攻击)\n\n泛洪攻击（SYN Flood Attack）是一种常见的 DoS（拒绝服务）攻击，攻击者会发送大量的伪造的 TCP 连接请求，导致服务器资源耗尽，无法处理正常的连接请求。\n\n半连接服务拒绝，也称为 SYN 洪泛攻击或 SYN Flood。\n\n所谓的半连接就是指在 TCP 的三次握手过程中，当服务器接收到来自客户端的第一个 SYN 包后，它会回复一个 SYN-ACK 包，此时连接处于“半开”状态，因为连接的建立还需要客户端发送最后一个 ACK 包。\n\n在收到最后的 ACK 包之前，服务器会为这个尚未完成的连接分配一定的资源，并在它的队列中保留这个连接的位置。\n\n#### [如果让你重新设计，怎么设计？](#如果让你重新设计-怎么设计)\n\n如果重新设计 TCP 的连接建立过程，可以考虑引入 SYN cookies，这种技术通过在 SYN-ACK 响应中编码连接信息，从而在不占用大量资源的情况下验证客户端。"
+ },
+ {
+ "id": 479,
+ "question": "三次握手中每一次没收到报文会发生什么情况？",
+ "answer": "* 第一次握手服务端未收到 SYN 报文\n\n服务端不会进行任何的动作，而客户端由于一段时间内没有收到服务端发来的确认报文，等待一段时间后会重新发送 SYN 报文，如果仍然没有回应，会重复这个过程，直到发送次数超过最大重传次数限制，就会返回连接建立失败。\n\n* 第二次握手客户端未收到服务端响应的 ACK 报文\n\n客户端会继续重传，直到次数限制；而服务端此时会阻塞在 accept()处，等待客户端发送 ACK 报文\n\n* 第三次握手服务端为收到客户端发送过来的 ACK 报文\n\n服务端同样会采用类似客户端的超时重传机制，如果重试次数超过限制，则 accept()调用返回-1，服务端建立连接失败；而此时客户端认为自己已经建立连接成功，因此开始向服务端发送数据，但是服务端的 accept()系统调用已经返回，此时不在监听状态，因此服务端接收到客户端发送来的数据时会发送 RST 报文给客户端，消除客户端单方面建立连接的状态。"
+ },
+ {
+ "id": 480,
+ "question": "第二次握手传回了 ACK，为什么还要传回 SYN？",
+ "answer": "ACK 是为了告诉客户端传来的数据已经接收无误。\n\n而传回 SYN 是为了告诉客户端，服务端响应的确实是客户端发送的报文。"
+ },
+ {
+ "id": 481,
+ "question": "第 3 次握手可以携带数据吗？",
+ "answer": "第 3 次握手是可以携带数据的。\n\n此时客户端已经处于 ESTABLISHED 状态。对于客户端来说，它已经建立连接成功，并且确认服务端的接收和发送能力是正常的。\n\n第一次握手不能携带数据是出于安全的考虑，因为如果允许携带数据，攻击者每次在 SYN 报文中携带大量数据，就会导致服务端消耗更多的时间和空间去处理这些报文，会造成 CPU 和内存的消耗。"
+ },
+ {
+ "id": 482,
+ "question": "了解 TCP 半连接状态吗？",
+ "answer": "TCP 半连接指的是在 TCP 三次握手过程中，服务器接收到了客户端的 SYN 包，但还没有完成第三次握手，此时的连接处于一种未完全建立的状态。\n\n\n\n如果服务器回复了 SYN-ACK，但客户端还没有回复 ACK，该连接将一直保留在半连接队列中，直到超时或被拒绝。\n\n#### [说说半连接队列？](#说说半连接队列)\n\nTCP 进入三次握手前，服务端会从 **CLOSED** 状态变为 **LISTEN** 状态, 同时在内部创建了两个队列：半连接队列（SYN 队列）和全连接队列（ACCEPT 队列）。\n\n\n\n顾名思义，半连接队列存放的是三次握手未完成的连接，全连接队列存放的是完成三次握手的连接。\n\n* TCP 三次握手时，客户端发送 SYN 到服务端，服务端收到之后，便回复 **ACK 和 SYN**，状态由 **LISTEN 变为 SYN\\_RCVD**，此时这个连接就被推入了 **SYN 队列**，即半连接队列。\n* 当客户端回复 ACK, 服务端接收后，三次握手就完成了。这时连接会等待被具体的应用取走，在被取走之前，它被推入 ACCEPT 队列，即全连接队列。\n\n#### [什么是 SYN Flood ？](#什么是-syn-flood)\n\nSYN Flood 是一种典型的 DDos 攻击，它在短时间内，伪造**不存在的 IP 地址**, 向服务器发送大量 SYN 报文。当服务器回复 SYN+ACK 报文后，不会收到 ACK 回应报文，那么 SYN 队列里的连接旧不会出对队，久⽽久之就会占满服务端的 **SYN** 接收队列（半连接队列），使得服务器不能为正常⽤户服务。\n\n\n\n#### [那有什么应对方案呢？](#那有什么应对方案呢)\n\n主要有 **syn cookie** 和 **SYN Proxy 防火墙**等。\n\n* **syn cookie**：在收到 SYN 包后，服务器根据一定的方法，以数据包的源地址、端口等信息为参数计算出一个 cookie 值作为自己的 SYNACK 包的序列号，回复 SYN+ACK 后，服务器并不立即分配资源进行处理，等收到发送方的 ACK 包后，重新根据数据包的源地址、端口计算该包中的确认序列号是否正确，如果正确则建立连接，否则丢弃该包。\n* **SYN Proxy 防火墙**：服务器防火墙会对收到的每一个 SYN 报文进行代理和回应，并保持半连接。等发送方将 ACK 包返回后，再重新构造 SYN 包发到服务器，建立真正的 TCP 连接。"
+ },
+ {
+ "id": 483,
+ "question": "说说 TCP 四次挥手的过程？",
+ "answer": "TCP 连接的断开过程被形象地概括为四次挥手。\n\n\n\n**第一次挥手**：客户端向服务器发送一个 FIN 结束报文，表示客户端没有数据要发送了，但仍然可以接收数据。客户端进入 FIN-WAIT-1 状态。\n\n**第二次挥手**：服务器接收到 FIN 报文后，向客户端发送一个 ACK 报文，确认已接收到客户端的 FIN 请求。服务器进入 CLOSE-WAIT 状态，客户端进入 FIN-WAIT-2 状态。\n\n**第三次挥手**：服务器向客户端发送一个 FIN 报文，表示服务器也没有数据要发送了。服务器进入 LAST-ACK 状态。\n\n**第四次挥手**：客户端接收到 FIN 报文后，向服务器发送一个 ACK 报文，确认已接收到服务器的 FIN 请求。客户端进入 TIME-WAIT 状态，等待一段时间以确保服务器接收到 ACK 报文。服务器接收到 ACK 报文后进入 CLOSED 状态。客户端在等待一段时间后也进入 CLOSED 状态。\n\n大白话说四次挥手：\n\n假如单身狗博主有一个女朋友—由于博主上班九九六，下班肝博客，导致没有时间陪女朋友，女朋友忍无可忍。\n\n* 女朋友：狗男人，最近你都不理我，你是不是不爱我了？你是不是外面有别的狗子了？我要和你分手？\n* 沙雕博主一愣，怒火攻心：分手就分手，不陪你闹了，等我把东西收拾收拾。\n\n沙雕博主小心翼翼地装起了自己的青轴机械键盘。\n\n* 哼，蠢女人，我已经收拾完了，我先滚为敬，再见！\n* 女朋友：滚，滚的远远的，越远越好，我一辈子都不想再见到你。\n\n挥手的故事总充满了悲伤和遗憾！\n\n"
+ },
+ {
+ "id": 484,
+ "question": "TCP 挥手为什么需要四次呢？",
+ "answer": "因为 TCP 是全双工通信协议，数据的发送和接收需要两次一来一回，也就是四次，来确保双方都能正确关闭连接。\n\n\n\n1. 第一次挥手：客户端表示数据发送完成了，准备关闭，你确认一下。\n2. 第二次挥手：服务端回话说 ok，我马上处理完数据，稍等。\n3. 第三次挥手：服务端表示处理完了，可以关闭了。\n4. 第四次挥手：客户端说好，进入 TIME\\_WAIT 状态，确保服务端关闭连接后，自己再关闭连接。"
+ },
+ {
+ "id": 485,
+ "question": "TCP 四次挥手过程中，为什么需要等待 2MSL, 才进入 CLOSED 关闭状态？",
+ "answer": "> **为什么需要等待？**\n\n**1. 为了保证客户端发送的最后一个 ACK 报文段能够到达服务端。** 这个 ACK 报文段有可能丢失，因而使处在 **LAST-ACK** 状态的服务端就收不到对已发送的 **FIN + ACK** 报文段的确认。服务端会超时重传这个 FIN+ACK 报文段，而客户端就能在 2MSL 时间内（**超时 + 1MSL 传输**）收到这个重传的 FIN+ACK 报文段。接着客户端重传一次确认，重新启动 2MSL 计时器。最后，客户端和服务器都正常进入到 **CLOSED** 状态。\n\n**2. 防止已失效的连接请求报文段出现在本连接中**。客户端在发送完最后一个 ACK 报文段后，再经过时间 2MSL，就可以使本连接持续的时间内所产生的所有报文段都从网络中消失。这样就可以使下一个连接中不会出现这种旧的连接请求报文段。\n\n> **为什么等待的时间是 2MSL？**\n\nMSL 是 Maximum Segment Lifetime，报⽂最⼤⽣存时间，它是任何报⽂在⽹络上存在的最⻓时间，超过这个时间报⽂将被丢弃。\n\nTIME\\_WAIT 等待 2 倍的 MSL，⽐较合理的解释是：⽹络中可能存在来⾃发送⽅的数据包，当这些发送⽅的数据包被接收⽅处理后⼜会向对⽅发送响应，所以⼀来⼀回需要等待 **2** 倍的时间。\n\n\n\n⽐如如果被动关闭⽅没有收到断开连接的最后的 ACK 报⽂，就会触发超时重发 Fin 报⽂，另⼀⽅接收到 FIN 后，会重发 ACK 给被动关闭⽅， ⼀来⼀去正好 2 个 MSL。"
+ },
+ {
+ "id": 486,
+ "question": "保活计时器有什么用？",
+ "answer": "除时间等待计时器外，TCP 还有一个保活计时器（keepalive timer）。\n\n设想这样的场景：客户已主动与服务器建立了 TCP 连接。但后来客户端的主机突然发生故障。显然，服务器以后就不能再收到客户端发来的数据。因此，应当有措施使服务器不要再白白等待下去。这就需要使用保活计时器了。\n\n服务器每收到一次客户端的数据，就重新设置保活计时器，时间的设置通常是两个小时。若两个小时都没有收到客户端的数据，服务端就发送一个探测报文段，以后则每隔 75 秒钟发送一次。若连续发送 10 个探测报文段后仍然无客户端的响应，服务端就认为客户端出了故障，接着就关闭这个连接。"
+ },
+ {
+ "id": 487,
+ "question": "CLOSE-WAIT 和 TIME-WAIT 的状态和意义？",
+ "answer": "#### [CLOSE-WAIT 状态有什么意义？](#close-wait-状态有什么意义)\n\n服务端收到客户端关闭连接的请求并确认之后，就会进入 CLOSE-WAIT 状态。此时服务端可能还有一些数据没有传输完成，因此不能立即关闭连接，而 CLOSE-WAIT 状态就是为了保证服务端在关闭连接之前将待发送的数据处理完。\n\n#### [TIME-WAIT 有什么意义？](#time-wait-有什么意义)\n\nTIME-WAIT 发生在第四次挥手，当客户端在发送 ACK 确认对方的 FIN 报文后，会进入 TIME\\_WAIT 状态。\n\n\n\n它存在的意义主要有两个：\n\n* 在 TIME\\_WAIT 状态中，客户端可以重新发送 ACK 确保对方正常关闭连接。\n* 在 TIME\\_WAIT 持续的 2MSL 时间后，确保旧数据包完全消失，避免它们干扰未来建立的新连接。\n\n> 补充：MSL（Maximum Segment Lifetime）：TCP 报文段在网络中的最大存活时间，通常为 30 秒到 2 分钟"
+ },
+ {
+ "id": 488,
+ "question": "TIME_WAIT 状态过多会导致什么问题？怎么解决？",
+ "answer": "> **TIME\\_WAIT 状态过多会导致什么问题?**\n\n如果服务器有处于 TIME-WAIT 状态的 TCP，则说明是由服务器⽅主动发起的断开请求。\n\n过多的 TIME-WAIT 状态主要的危害有两种：\n\n第⼀是内存资源占⽤；\n\n第⼆是对端⼝资源的占⽤，⼀个 TCP 连接⾄少消耗⼀个本地端⼝；\n\n> **怎么解决 TIME\\_WAIT 状态过多？**\n\n* 服务器可以设置 SO\\_REUSEADDR 套接字来通知内核，如果端口被占用，但是 TCP 连接位于 TIME\\_WAIT 状态时可以重用端口。\n* 还可以使用长连接的方式来减少 TCP 的连接和断开，在长连接的业务里往往不需要考虑 TIME\\_WAIT 状态。"
+ },
+ {
+ "id": 489,
+ "question": "说说 TCP 报文头部的格式？",
+ "answer": "一个 TCP 报文段主要由报文段头部（Header）和数据两部分组成。头部包含了确保数据可靠传输所需的各种控制信息，比如说序列号、确认号、窗口大小等。\n\n\n\n* **源端口号**（Source Port）：16 位（2 个字节），用于标识发送端的应用程序。\n* **目标端口号**（Destination Port）：也是 16 位，用于标识接收端的应用程序。\n* **序列号**（Sequence Number）：32 位，用于标识从 TCP 发送者发送的数据字节流中的第一个字节的顺序号。确保数据按顺序接收。\n* **确认号**（Acknowledgment Number）：32 位，如果 ACK 标志被设置，则该字段包含发送确认的序列号，即接收 TCP 希望收到的下一个序列号。\n* **数据偏移**（Data Offset）：4 位，表示 TCP 报文头部的长度，用于指示数据开始的位置。\n* **保留**（Reserved）：6 位，为将来使用预留，目前必须置为 0。\n* **控制位**（Flags）：共 6 位，包括 URG（紧急指针字段是否有效）、ACK（确认字段是否有效）、PSH（提示接收端应该尽快将这个报文段交给应用层）、RST（重置连接）、SYN（同步序号，用于建立连接）、FIN（结束发送数据）。\n* **窗口大小**（Window）：16 位，用于流量控制，表示接收端还能接收的数据的字节数（基于接收缓冲区的大小）。\n* **校验和**（Checksum）：16 位，覆盖整个 TCP 报文段（包括 TCP 头部、数据和一个伪头部）的校验和，用于检测数据在传输过程中的任何变化。\n* **紧急指针**（Urgent Pointer）：16 位，只有当 URG 控制位被设置时才有效，指出在报文段中有紧急数据的位置。"
+ },
+ {
+ "id": 490,
+ "question": "TCP 为什么可靠？",
+ "answer": "TCP 首先通过三次握手和四次挥手来保证连接的可靠性，然后通过校验和、序列号、确认应答、超时重传、滑动窗口等机制来保证数据的可靠传输。\n\n①、**校验和**：TCP 报文段包括一个校验和字段，用于检测报文段在传输过程中的变化。如果接收方检测到校验和错误，就会丢弃这个报文段。\n\n\n\n②、**序列号/确认机制**：TCP 将数据分成多个小段，每段数据都有唯一的序列号，以确保数据包的顺序传输和完整性。同时，发送方如果没有收到接收方的确认应答，会重传数据。\n\n\n\n③、**流量控制**：接收方会发送窗口大小告诉发送方它的接收能力。发送方会根据窗口大小调整发送速度，避免网络拥塞。\n\n\n\n④、**超时重传**：如果发送方发送的数据包超过了最大生存时间，接收方还没有收到，发送方会重传数据包以保证丢失数据重新传输。\n\n\n\n⑤、**拥塞控制**：TCP 会采用慢启动的策略，一开始发的少，然后逐步增加，当检测到网络拥塞时，会降低发送速率。在网络拥塞缓解后，传输速率也会自动恢复。\n\n"
+ },
+ {
+ "id": 491,
+ "question": "说说 TCP 的流量控制？",
+ "answer": "TCP 提供了一种机制，可以让发送端根据接收端的实际接收能力控制发送的数据量，这就是**流量控制**。\n\nTCP 通过**滑动窗口**来控制流量，我们看下简要流程：\n\n* 首先双方三次握手，初始化各自的窗口大小，均为 400 个字节。\n\n\n\n* 假如当前发送方给接收方发送了 200 个字节，那么，发送方的`SND.NXT`会右移 200 个字节，也就是说当前的可用窗口减少了 200 个字节。\n* 接受方收到后，放到缓冲队列里面，REV.WND =400-200=200 字节，所以 win=200 字节返回给发送方。接收方会在 ACK 的报文首部带上缩小后的滑动窗口 200 字节\n* 发送方又发送 200 字节过来，200 字节到达，继续放到缓冲队列。不过这时候，由于大量负载的原因，接受方处理不了这么多字节，只能处理 100 字节，剩余的 100 字节继续放到缓冲队列。这时候，REV.WND = 400-200-100=100 字节，即 win=100 返回发送方。\n* 发送方继续发送 100 字节过来，这时候，接收窗口 win 变为 0。\n* 发送方停止发送，开启一个定时任务，每隔一段时间，就去询问接受方，直到 win 大于 0，才继续开始发送。"
+ },
+ {
+ "id": 492,
+ "question": "详细说说 TCP 的滑动窗口？",
+ "answer": "TCP 发送一个数据，如果需要收到确认应答，才会发送下一个数据。这样的话就会有个缺点：效率会比较低。\n\n为了解决这个问题，TCP 引入了**窗口**，它是操作系统开辟的一个缓存空间。窗口大小值表示无需等待确认应答，而可以继续发送数据的最大值。\n\nTCP 头部有个字段叫 win，也即那个 **16 位的窗口大小**，它告诉对方本端的 TCP 接收缓冲区还能容纳多少字节的数据，这样对方就可以控制发送数据的速度，从而达到**流量控制**的目的。\n\n“通俗点讲，就是接受方每次收到数据包，在发送确认报文的时候，同时告诉发送方，自己的缓存区还有多少空余空间，缓冲区的空余空间，我们就称之为接受窗口大小。这就是 win。”\n\nTCP 滑动窗口分为两种: 发送窗口和接收窗口。**发送端的滑动窗口**包含四大部分，如下：\n\n* 已发送且已收到 ACK 确认\n* 已发送但未收到 ACK 确认\n* 未发送但可以发送\n* 未发送也不可以发送\n\n\n\n* 深蓝色框里就是发送窗口。\n* SND.WND: 表示发送窗口的大小, 上图虚线框的格子数是 10 个，即发送窗口大小是 10。\n* SND.NXT：下一个发送的位置，它指向未发送但可以发送的第一个字节的序列号。\n* SND.UNA: 一个绝对指针，它指向的是已发送但未确认的第一个字节的序列号。\n\n接收方的滑动窗口包含三大部分，如下：\n\n* 已成功接收并确认\n* 未收到数据但可以接收\n* 未收到数据并不可以接收的数据\n\n\n\n* 蓝色框内，就是接收窗口。\n* REV.WND: 表示接收窗口的大小, 上图虚线框的格子就是 9 个。\n* REV.NXT: 下一个接收的位置，它指向未收到但可以接收的第一个字节的序列号。"
+ },
+ {
+ "id": 493,
+ "question": "了解 Nagle 算法和延迟确认吗？",
+ "answer": "> **Nagle 算法和延迟确认是干什么的？**\n\n当我们 TCP 报⽂的承载的数据⾮常⼩的时候，例如⼏个字节，那么整个⽹络的效率是很低的，因为每个 TCP 报⽂中都会有 20 个字节的 TCP 头部，也会有 20 个字节的 IP 头部，⽽数据只有⼏个字节，所以在整个报⽂中有效数据占有的比例就会⾮常低。\n\n\n\n这就好像快递员开着⼤货⻋送⼀个⼩包裹⼀样浪费。\n\n那么就出现了常⻅的两种策略，来减少⼩报⽂的传输，分别是：\n\n* Nagle 算法\n* 延迟确认\n\n> **Nagle 算法**\n\nNagle 算法：**任意时刻，最多只能有一个未被确认的小段**。所谓 “小段”，指的是小于 MSS 尺寸的数据块，所谓 “未被确认”，是指一个数据块发送出去后，没有收到对方发送的 ACK 确认该数据已收到。\n\nNagle 算法的策略：\n\n* 没有已发送未确认报⽂时，⽴刻发送数据。\n* 存在未确认报⽂时，直到「没有已发送未确认报⽂」或「数据⻓度达到 MSS ⼤⼩」时，再发送数据。\n\n只要没满⾜上⾯条件中的⼀条，发送⽅⼀直在囤积数据，直到满⾜上⾯的发送条件。\n\n> **延迟确认**\n\n事实上当没有携带数据的 ACK，它的⽹络效率也是很低的，因为它也有 40 个字节的 IP 头 和 TCP 头，但却没有携带数据报⽂。\n\n为了解决 ACK 传输效率低问题，所以就衍⽣出了 **TCP** 延迟确认。\n\nTCP 延迟确认的策略：\n\n* 当有响应数据要发送时，ACK 会随着响应数据⼀起⽴刻发送给对⽅\n* 当没有响应数据要发送时，ACK 将会延迟⼀段时间，以等待是否有响应数据可以⼀起发送\n* 如果在延迟等待发送 ACK 期间，对⽅的第⼆个数据报⽂⼜到达了，这时就会⽴刻发送 ACK\n\n一般情况下，**Nagle 算法和延迟确认**不能一起使用，Nagle 算法意味着延迟发，**延迟确认**意味着延迟接收，两个凑在一起就会造成更大的延迟，会产生性能问题。"
+ },
+ {
+ "id": 494,
+ "question": "说说 TCP 的拥塞控制？",
+ "answer": "#### [什么是拥塞控制？](#什么是拥塞控制)\n\n流量控制是为了避免发送⽅的数据填满接收⽅的缓存，但并不能控制整个⽹络。\n\n⼀般来说，计算机⽹络会处在⼀个共享的环境。因此也有可能会因为其他主机之间的通信使得⽹络拥堵。\n\n当⽹络出现拥堵时，如果继续发送⼤量数据包，可能会导致数据包延时、丢失等，这时 **TCP** 就会重传数据，但重传会增加⽹络负担，于是会导致更⼤的延迟以及更多的丢包，就进⼊了恶性循环....\n\n所以，TCP 被设计成了⼀个非常⽆私的协议，当⽹络发送拥塞时，TCP 会⾃我牺牲，降低发送的数据流。\n\n拥塞控制的⽬的就是避免发送⽅的数据填满整个⽹络。\n\n就像是一个水管，不能让太多的水（数据流）流入水管，如果超过水管的承受能力，水管会被撑爆（丢包）。\n\n\n\n发送方会维护一个**拥塞窗口 cwnd** 的变量，调节所要发送数据的量。\n\n#### [什么是拥塞窗⼝？和发送窗⼝有什么关系呢？](#什么是拥塞窗口-和发送窗口有什么关系呢)\n\n拥塞窗⼝ **cwnd**是发送⽅维护的⼀个的状态变量，它会根据⽹络的拥塞程度动态变化的。\n\n发送窗⼝ swnd 和接收窗⼝ rwnd 是约等于的关系，那么由于加⼊了拥塞窗⼝的概念后，此时发送窗⼝的值是 swnd = min(cwnd, rwnd)，也就是拥塞窗⼝和接收窗⼝中的最⼩值。\n\n拥塞窗⼝ cwnd 变化的规则：\n\n* 只要⽹络中没有出现拥塞， cwnd 就会增⼤；\n* 但⽹络中出现了拥塞， cwnd 就减少；\n\n#### [拥塞控制有哪些常用算法？](#拥塞控制有哪些常用算法)\n\n拥塞控制主要有这几种常用算法：\n\n\n\n* 慢启动\n* 拥塞避免\n* 拥塞发生\n* 快速恢复\n\n①、慢启动算法\n\n慢启动算法，慢慢启动。\n\n它表示 TCP 建立连接完成后，一开始不要发送大量的数据，而是先探测一下网络的拥塞程度。由小到大逐渐增加拥塞窗口的大小，如果没有出现丢包，**每收到一个 ACK，就将拥塞窗口 cwnd 大小就加 1（单位是 MSS）**。**每轮次**发送窗口增加一倍，呈指数增长，如果出现丢包，拥塞窗口就减半，进入拥塞避免阶段。\n\n举个例子：\n\n* 连接建⽴完成后，⼀开始初始化 cwnd = 1 ，表示可以传⼀个 MSS ⼤⼩的数据。\n* 当收到⼀个 ACK 确认应答后，cwnd 增加 1，于是⼀次能够发送 2 个\n* 当收到 2 个的 ACK 确认应答后， cwnd 增加 2，于是就可以⽐之前多发 2 个，所以这⼀次能够发送 4 个\n* 当这 4 个的 ACK 确认到来的时候，每个确认 cwnd 增加 1， 4 个确认 cwnd 增加 4，于是就可以⽐之前多发 4 个，所以这⼀次能够发送 8 个。\n\n\n\n发包的个数是指数性的增⻓。\n\n\n\n为了防止 cwnd 增长过大引起网络拥塞，还需设置一个**慢启动阀值 ssthresh**（slow start threshold）状态变量。当`cwnd`到达该阀值后，就好像水管被关小了水龙头一样，减少拥塞状态。即当 **cwnd >ssthresh** 时，进入了**拥塞避免**算法。\n\n②、拥塞避免算法\n\n一般来说，慢启动阀值 ssthresh 是 65535 字节，`cwnd`到达**慢启动阀值**后\n\n* 每收到一个 ACK 时，cwnd = cwnd + 1/cwnd\n* 当每过一个 RTT 时，cwnd = cwnd + 1\n\n显然这是一个线性上升的算法，避免过快导致网络拥塞问题。\n\n接着上面慢启动的例子，假定 ssthresh 为 8 ：：\n\n* 当 8 个 ACK 应答确认到来时，每个确认增加 1/8，8 个 ACK 确认 cwnd ⼀共增加 1，于是这⼀次能够发送 9 个 MSS ⼤⼩的数据，变成了线性增⻓。\n\n\n\n③、拥塞发生\n\n当网络拥塞发生**丢包**时，会有两种情况：\n\n* RTO 超时重传\n* 快速重传\n\n如果是发生了 **RTO 超时重传**，就会使用拥塞发生算法\n\n* 慢启动阀值 sshthresh = cwnd /2\n* cwnd 重置为 1\n* 进入新的慢启动过程\n\n\n\n这种方式就像是飙车的时候急刹车，还飞速倒车，这。。。\n\n其实还有更好的处理方式，就是**快速重传**。发送方收到 3 个连续重复的 ACK 时，就会快速地重传，不必等待 **RTO 超时**再重传。\n\n发⽣快速重传的拥塞发⽣算法：\n\n* 拥塞窗口大小 cwnd = cwnd/2\n* 慢启动阀值 ssthresh = cwnd\n* 进入快速恢复算法\n\n④、快速恢复\n\n快速重传和快速恢复算法一般同时使用。快速恢复算法认为，还有 3 个重复 ACK 收到，说明网络也没那么糟糕，所以没有必要像 RTO 超时那么强烈。\n\n正如前面所说，进入快速恢复之前，cwnd 和 sshthresh 已被更新：\n\n* cwnd = cwnd /2\n* sshthresh = cwnd\n\n然后，进⼊快速恢复算法如下：\n\n* cwnd = sshthresh + 3\n* 重传重复的那几个 ACK（即丢失的那几个数据包）\n* 如果再收到重复的 ACK，那么 cwnd = cwnd +1\n* 如果收到新数据的 ACK 后, cwnd = sshthresh。因为收到新数据的 ACK，表明恢复过程已经结束，可以再次进入了拥塞避免的算法了。\n\n"
+ },
+ {
+ "id": 495,
+ "question": "说说 TCP 的重传机制？",
+ "answer": "超时重传机制是 TCP 的核心之一，它能确保在网络传输中如果某些数据包丢失或没有及时到达的话，TCP 能够重新发送这些数据包，以保证数据完整性。\n\n其原理是在发送某个数据后开启一个计时器，如果在一定时间内没有得到发送数据报的 ACK 报文，就重新发送数据，直到发送成功为止。\n\n重传包括**超时重传、快速重传、带选择确认的重传（SACK）和重复 SACK 四种**。\n\n\n\n#### [超时时间应该设置为多少呢？](#超时时间应该设置为多少呢)\n\nTCP 中的重传超时时间（RTO，Retransmission Timeout）不是一个固定的值，而是动态计算的，目的是为了适应不同的网络条件。\n\nRTO 有个标准方法的计算公式，叫 **Jacobson / Karels 算法**。\n\n①、计算 SRTT（Smoothed RTT，平滑往返时间），以避免单次测量中的抖动影响重传时间。\n\n\n```text\nSRTT = (1 - α) * SRTT + α * RTT\n```\n\n\n其中，α 是一个常量，通常取值为 0.125（即1/8），表示新测量值对平滑RTT的影响比例。\n\nRTT，也就是 Round-Trip Time，往返时间，即数据包从发送到接收到确认的时间。TCP 会对每个数据包的 RTT 进行测量，并不断更新这个值。\n\n\n\n②、计算 RTTVAR (RTT Variation，表示RTT的变化量，用于衡量RTT的波动)\n\n\n```text\nRTTVAR = (1 - β) * RTTVAR + β * (|RTT - SRTT|)\n```\n\n\nβ 通常取值为 0.25（即1/4），表示对RTTVAR更新的权重。\n\n③、最后，得出最终的 RTO\n\n\n```text\nRTO = SRTT + max(G, 4 x RTTVAR)\n```\n\n\nG 是一个小的常量偏移量，用来防止RTO过小。一般来说，G 的值通常是1毫秒。\n\n一般来说，RTO 略微大于 RTT，效果是最佳的。\n\n* 如果 RTO 设置很大，可能等了很久都没有重发。\n* 如果 RTO 设置很小，那很可能数据还没有丢失，就开始重发了。\n\n超时重传不是十分完美的重传方案，它有这些缺点：\n\n* 当报文丢失时，需要等待一定的超时周期，才开始重传。\n* 当报文丢失时，在等待超时的过程中，可能会出现这种情况：后面的报文已经被接收端接收了但却迟迟得不到确认，发送端会认为也丢失了，从而引起不必要的重传。\n* 并且，对于 TCP 来说，如果发生一次超时重传，下次的时间间隔就会加倍。\n\n#### [什么是快速重传？](#什么是快速重传)\n\nTCP 还有另外⼀种快速重传（**Fast Retransmit**）机制，它不以时间为驱动，⽽是以数据驱动重传。\n\n它不以时间驱动，而是以数据驱动。它是基于接收端的反馈信息来引发重传的。\n\n可以用它来解决超时重发的时间等待问题，快速重传流程如下：\n\n\n\n在上图，发送⽅发出了 1，2，3，4，5 份数据：\n\n* 第⼀份 Seq1 先送到了，于是就 Ack 回 2；\n* 结果 Seq2 因为某些原因没收到，Seq3 到达了，于是还是 Ack 回 2；\n* 后⾯的 Seq4 和 Seq5 都到了，但还是 Ack 回 2，因为 Seq2 还是没有收到；\n* 发送端收到了三个 **Ack = 2** 的确认，知道了 **Seq2** 还没有收到，就会在定时器过期之前，重传丢失的 **Seq2**。\n* 最后，收到了 Seq2，此时因为 Seq3，Seq4，Seq5 都收到了，于是 Ack 回 6 。\n\n快速重传机制只解决了⼀个问题，就是超时时间的问题，但是它依然⾯临着另外⼀个问题。就是重传的时候，是重传之前的⼀个，还是重传所有的问题。\n\n⽐如对于上⾯的例⼦，是重传 Seq2 呢？还是重传 Seq2、Seq3、Seq4、Seq5 呢？因为发送端并不清楚这连续的三个 Ack 2 是谁传回来的。\n\n根据 TCP 不同的实现，以上两种情况都是有可能的。可⻅，这是⼀把双刃剑。\n\n为了解决不知道该重传哪些 TCP 报⽂，于是就有 SACK ⽅法。\n\n#### [什么是带选择确认的重传（SACK）](#什么是带选择确认的重传-sack)\n\n为了解决应该重传多少个包的问题? TCP 提供了**带选择确认的重传**（即 SACK，Selective Acknowledgment）。\n\n**SACK 机制**就是，在快速重传的基础上，接收方返回最近收到报文段的序列号范围，这样发送方就知道接收方哪些数据包是没收到的。这样就很清楚应该重传哪些数据包。\n\n\n\n如上图中，发送⽅收到了三次同样的 ACK 确认报⽂，于是就会触发快速重发机制，通过 SACK 信息发现只有 200~299 这段数据丢失，则重发时，就只选择了这个 TCP 段进⾏重发。\n\n#### [什么是重复 SACK（D-SACK）](#什么是重复-sack-d-sack)\n\nD-SACK，英文是 Duplicate SACK，是在 SACK 的基础上做了一些扩展，主要用来告诉发送方，有哪些数据包，自己重复接受了。\n\nDSACK 的目的是帮助发送方判断，是否发生了包失序、ACK 丢失、包重复或伪重传。让 TCP 可以更好的做网络流控。\n\n例如 ACK 丢包导致的数据包重复：\n\n\n\n* 接收⽅发给发送⽅的两个 ACK 确认应答都丢失了，所以发送⽅超时后，重传第⼀个数据包（3000 ~\n\n3499）\n\n* 于是接收⽅发现数据是重复收到的，于是回了⼀个 **SACK = 3000~3500**，告诉「发送⽅」 3000~3500 的数据早已被接收了，因为 ACK 都到了 4000 了，已经意味着 4000 之前的所有数据都已收到，所以这个 SACK 就代表着 D-SACK 。这样发送⽅就知道了，数据没有丢，是接收⽅的 ACK 确认报⽂丢了。"
+ },
+ {
+ "id": 496,
+ "question": "说说 TCP 的粘包和拆包？",
+ "answer": "TCP 的粘包和拆包更多的是业务上的概念！\n\n> **什么是 TCP 粘包和拆包？**\n\nTCP 是面向流，没有界限的一串数据。TCP 底层并不了解上层业务数据的具体含义，它会根据 TCP 缓冲区的实际情况进行包的划分，所以在业务上认为，一**个完整的包可能会被 TCP 拆分成多个包进行发送**，**也有可能把多个小的包封装成一个大的数据包发送**，这就是所谓的 TCP 粘包和拆包问题。\n\n\n> **为什么会产生粘包和拆包呢?**\n\n* 要发送的数据小于 TCP 发送缓冲区的大小，TCP 将多次写入缓冲区的数据一次发送出去，将会发生粘包；\n* 接收数据端的应用层没有及时读取接收缓冲区中的数据，将发生粘包；\n* 要发送的数据大于 TCP 发送缓冲区剩余空间大小，将会发生拆包；\n* 待发送数据大于 MSS（最大报文长度），TCP 在传输前将进行拆包。即 TCP 报文长度 - TCP 头部长度 > MSS。\n\n> **那怎么解决呢？**\n\n* 发送端将每个数据包封装为固定长度\n* 在数据尾部增加特殊字符进行分割\n* 将数据分为两部分，一部分是头部，一部分是内容体；其中头部结构大小固定，且有一个字段声明内容体的大小。"
+ },
+ {
+ "id": 497,
+ "question": "一个TCP连接可以发送多少次HTTP请求?（补充）",
+ "answer": "> 2024年05月24日新增\n\n一个 TCP 连接可以发送多少次 HTTP 请求，取决于 HTTP 协议的版本。\n\n在 HTTP/1.0 中，每个 HTTP 请求-响应使用一个单独的 TCP 连接。这意味着每次发送 HTTP 请求都需要建立一个新的 TCP 连接。\n\nHTTP/1.1 引入了持久连接（Persistent Connection），默认情况下允许在一个 TCP 连接上发送多个 HTTP 请求。\n\n通过使用 `Connection: keep-alive` 头部实现，保持连接打开状态，直到明确关闭为止。这极大地提高了效率，因为无需为每个请求都建立新的连接。\n\n此外，HTTP/1.1 支持请求管道化（Pipelining），允许客户端在收到前一个响应之前发送多个请求。\n\nHTTP/2 进一步优化了连接复用，允许在单个 TCP 连接上同时发送多个请求和响应，这些请求和响应被分割成帧并通过流传输。HTTP/2 的多路复用（Multiplexing）机制显著提高了并发性能和资源利用效率。"
+ }
+ ]
+ },
+ {
+ "id": 72,
+ "categoryName": "UDP",
+ "questions": [
+ {
+ "id": 498,
+ "question": "说说 TCP 和 UDP 的区别？",
+ "answer": "TCP 是面向连接的，而 UDP 是无连接的。\n\n\n\nTCP 就像是打电话一对一私聊，UDP 就像是拿个大喇叭在广播（😂）。\n\n\n\n在数据传输开始之前，TCP 需要先建立连接，数据传输完成后，再断开连接。这个过程通常被称为“三次握手”、“四次挥手”。\n\nUDP 是无连接的，发送数据之前不需要建立连接，发送完毕也不需要断开，数据以数据报形式发送。\n\n换句话说：TCP 是可靠的，它通过确认机制、重发机制等来保证数据的可靠传输。而 UDP 是不可靠的，数据包可能会丢失、重复、乱序。\n\n#### [说说 TCP 和 UDP 的应用场景？](#说说-tcp-和-udp-的应用场景)\n\n* **TCP：** 适用于那些对数据准确性要求高于数据传输速度的场合。例如：网页浏览、电子邮件、文件传输（FTP）、远程控制、数据库链接。\n* **UDP：** 适用于对速度要求高、可以容忍一定数据丢失的场合。例如：QQ 聊天、在线视频、网络语音电话、广播通信。容忍一定的数据丢失。\n\n#### [你会如何设计 QQ 中的网络协议？](#你会如何设计-qq-中的网络协议)\n\n首先，我们要实现登录功能，这是使用 QQ 的第一步，为了保证账号和密码的安全性，我们可以选择 TCP + SSL/TLS 协议来进行登录。\n\n因为 TCP 协议是一种可靠的传输协议，能够保证数据的完整性，而 SSL/TLS 能够对通信进行加密，保证数据的安全性。\n\n接下来，我们需要考虑消息传递的实时性，如语音视频通话等，这时候我们可以选择 UDP 协议。UDP 的传输速度更快，对于实时性服务来说，速度是最重要的。\n\n#### [如何保证消息的不丢失？](#如何保证消息的不丢失)\n\n对于 TCP 协议来说，如果数据包在传输过程中丢失，TCP 协议会自动进行重传。\n\n而对于 UDP 协议来说，我们可以通过应用层的重传机制来保证消息的不丢失。当接收方收到消息后，返回一个确认信息给发送方，如果发送方在一定时间内没有收到确认信息，就重新发送消息。\n\n同时，每个消息都附带一个唯一的序列号，接收方根据序列号判断是否有消息丢失，如果发现序列号不连续，就可以要求发送方重新发送。这样还可以防止消息重复。\n\n当然了，消息持久化也很重要，可以将消息保存在服务器或者本地的数据库中，即使在网络中断或者其他异常情况下，也能从数据库中恢复消息。"
+ },
+ {
+ "id": 499,
+ "question": "为什么 QQ 采用 UDP 协议？",
+ "answer": "PS：这是多年前的老题了，拉出来怀怀旧。\n\n\n\n* 首先，QQ 并不是完全基于 UDP 实现。比如在使用 QQ 进行文件传输等活动的时候，就会使用 TCP 作为可靠传输的保证。\n* 使用 UDP 进行交互通信的好处在于，延迟较短，对数据丢失的处理比较简单。同时，TCP 是一个全双工协议，需要建立连接，所以网络开销也会相对大。\n* 如果使用 QQ 语音和 QQ 视频的话，UDP 的优势就更为突出了，首先延迟较小。最重要的一点是不可靠传输，这意味着如果数据丢失的话，不会有重传。因为用户一般来说可以接受图像稍微模糊一点，声音稍微不清晰一点，但是如果在几秒钟以后再出现之前丢失的画面和声音，这恐怕是很难接受的。\n* 由于 QQ 的服务器设计容量是海量级的应用，一台服务器要同时容纳十几万的并发连接，因此服务器端只有采用 UDP 协议与客户端进行通讯才能保证这种超大规模的服务\n\n简单总结一下：UDP 协议是无连接方式的协议，它的效率高，速度快，占资源少，对服务器的压力比较小。但是其传输机制为不可靠传送，必须依靠辅助的算法来完成传输控制。QQ 采用的通信协议以 UDP 为主，辅以 TCP 协议。"
+ },
+ {
+ "id": 500,
+ "question": "UDP 协议为什么不可靠？",
+ "answer": "UDP 在传输数据之前不需要先建立连接，远地主机的运输层在接收到 UDP 报文后，不需要确认，提供不可靠交付。总结就以下四点：\n\n* 不保证消息交付：不确认，不重传，无超时\n* 不保证交付顺序：不设置包序号，不重排，不会发生队首阻塞\n* 不跟踪连接状态：不必建立连接或重启状态机\n* 不进行拥塞控制：不内置客户端或网络反馈机制"
+ },
+ {
+ "id": 501,
+ "question": "DNS 为什么要用 UDP?",
+ "answer": "更准确地说，DNS 既使用 TCP 又使用 UDP。\n\n当进行区域传送（主域名服务器向辅助域名服务器传送变化的那部分数据）时会使用 TCP，因为数据同步传送的数据量比一个请求和应答的数据量要多，而 TCP 允许的报文长度更长，因此为了保证数据的正确性，会使用基于可靠连接的 TCP。\n\n当客户端想 DNS 服务器查询域名（域名解析）的时候，一般返回的内容不会超过 UDP 报文的最大长度，即 512 字节，用 UDP 传输时，不需要创建连接，从而大大提高了响应速度，但这要求域名解析服务器和域名服务器都必须自己处理超时和重传从而保证可靠性。"
+ }
+ ]
+ },
+ {
+ "id": 73,
+ "categoryName": "IP",
+ "questions": [
+ {
+ "id": 502,
+ "question": "IP 协议的定义和作用？",
+ "answer": "IP 协议（Internet Protocol）用于在计算机网络之间传输数据包，它定义了数据包的格式和处理规则，确保数据能够从一个设备传输到另一个设备，可能跨越多个中间网络设备（如路由器）。\n\n\n\n#### [IP 协议有哪些作用？](#ip-协议有哪些作用)\n\n①、**寻址**：每个连接到网络的设备都有一个唯一的 IP 地址。IP 协议使用这些地址来标识数据包的源地址和目的地址，确保数据包能够准确地传输到目标设备。\n\n②、**路由**：IP 协议负责决定数据包在网络传输中的路径。比如说路由器使用路由表和 IP 地址信息来确定数据包的最佳传输路径。\n\n③、**分片和重组**：当数据包过大无法在某个网络上传输时，IP 协议会将数据包分成更小的片段进行传输。接收端会根据头部信息将这些片段重新组装成完整的数据包。\n\n#### [举一个实际的例子来说明？](#举一个实际的例子来说明)\n\n假设有两个设备 A 和 B 通过互联网通信，A 的 IP 地址是 192.168.1.1，B 的 IP 地址是 203.0.113.5。数据包的传输过程如下：\n\n①、设备 A 发送数据包：\n\n* 设备 A 创建一个 IP 数据包，设置源地址为 192.168.1.1，目的地址为 203.0.113.5，将要传输的数据放入数据部分。\n* 数据包封装后，通过本地网络发送到路由器。\n\n②、路由器转发数据包：\n\n* 路由器根据路由表查找目的地址 203.0.113.5，确定数据包的传输路径。\n* 数据包可能经过多个中间路由器，每个路由器都根据路由表选择下一跳，最终到达目标设备的网络。\n\n③、设备 B 接收数据包：\n\n* 设备 B 接收数据包，读取 IP 头部信息，验证数据包的完整性。\n* 并数据部分取出，交给上层协议处理（如 TCP 或 UDP）。"
+ },
+ {
+ "id": 503,
+ "question": "IP 地址有哪些分类？",
+ "answer": "一个 IP 地址在这鞥个互联网范围内是惟一的，一般可以这么认为，IP 地址 = {<网络号>，<主机号>}。\n\n1. **网络号**：它标志主机所连接的网络地址表示属于互联网的哪一个网络。\n2. **主机号**：它标志主机地址表示其属于该网络中的哪一台主机。\n\nIP 地址分为 A，B，C，D，E 五大类：\n\n* A 类地址 (1~126)：以 0 开头，网络号占前 8 位，主机号占后面 24 位。\n* B 类地址 (128~191)：以 10 开头，网络号占前 16 位，主机号占后面 16 位。\n* C 类地址 (192~223)：以 110 开头，网络号占前 24 位，主机号占后面 8 位。\n* D 类地址 (224~239)：以 1110 开头，保留为多播地址。\n* E 类地址 (240~255)：以 1111 开头，保留位为将来使用\n\n"
+ },
+ {
+ "id": 504,
+ "question": "域名和 IP 的关系？一个 IP 可以对应多个域名吗？",
+ "answer": "* IP 地址在同一个网络中是惟一的，用来标识每一个网络上的设备，其相当于一个人的身份证号\n* 域名在同一个网络中也是惟一的，就像是一个人的名字、绰号\n\n假如你有多个不用的绰号，你的朋友可以用其中任何一个绰号叫你，但你的身份证号码却是惟一的。但同时你的绰号也可能和别人重复，假如你不在，有人叫你的绰号，其它人可能就答应了。\n\n一个域名可以对应多个 IP，但这种情况 DNS 做负载均衡的，在用户访问过程中，一个域名只能对应一个 IP。\n\n而一个 IP 却可以对应多个域名，是一对多的关系。"
+ },
+ {
+ "id": 505,
+ "question": "IPV4 地址不够如何解决？",
+ "answer": "我们知道，IP 地址有 32 位，可以标记 2 的 32 次方个地址，听起来很多，但是全球的网络设备数量已经远远超过这个数字，所以 IPV4 地址已经不够用了，那怎么解决呢？\n\n\n\n* DHCP：动态主机配置协议，动态分配 IP 地址，只给接入网络的设备分配 IP 地址，因此同一个 MAC 地址的设备，每次接入互联网时，得到的 IP 地址不一定是相同的，该协议使得空闲的 IP 地址可以得到充分利用。\n* CIDR：无类别域间路由。CIDR 消除了传统的 A 类、B 类、C 类地址以及划分子网的概念，因而更加有效地分配 IPv4 的地址空间，但无法从根本上解决地址耗尽的问题。\n* NAT：网络地址转换协议，我们知道属于不同局域网的主机可以使用相同的 IP 地址，从而一定程度上缓解了 IP 资源枯竭的问题，然而主机在局域网中使用的 IP 地址是不能在公网中使用的，当局域网主机想要与公网主机进行通信时，NAT 方法可以将该主机 IP 地址转换为全球 IP 地址。该协议能够有效解决 IP 地址不足的问题。\n* IPv6：作为接替 IPv4 的下一代互联网协议，其可以实现 2 的 128 次方个地址，而这个数量级，即使给地球上每一粒沙子都分配一个 IP 地址也够用，该协议能够从根本上解决 IPv4 地址不够用的问题。"
+ },
+ {
+ "id": 506,
+ "question": "说下 ARP 协议的工作过程？",
+ "answer": "ARP（Address Resolution Protocol，地址解析协议）是网络通信中的一种协议，主要目的是将网络层的 IP 地址解析为链路层的 MAC 地址。\n\n\n\n①、ARP 请求\n\n当主机 A 要发送数据给主机 B 时，首先会在自己的 ARP 缓存中查找主机 B 的 MAC 地址。\n\n如果没有找到，主机 A 会向网络中广播一个 ARP 请求数据包，请求网络中的所有主机告诉它们的 MAC 地址；这个请求包含了请求设备和目标设备的 IP 和 MAC 地址。\n\n②、ARP 应答\n\n网络中的所有主机都会收到这个 ARP 请求，但只有主机 B 会回复 ARP 应答，告诉主机 A 自己的 MAC 地址。\n\n并且主机 B 会将主机 A 的 IP 和 MAC 地址映射关系缓存到自己的 ARP 缓存中，以便下次通信时直接使用。\n\n③、更新 ARP 缓存\n\n主机 A 收到主机 B 的 ARP 应答后，也会将主机 B 的 IP 和 MAC 地址映射关系缓存到自己的 ARP 缓存中。"
+ },
+ {
+ "id": 507,
+ "question": "为什么既有 IP 地址，又有 MAC 地址？",
+ "answer": "> **MAC 地址和 IP 地址都有什么作用？**\n\n* MAC 地址是数据链路层和物理层使用的地址，是写在网卡上的物理地址，用来定义网络设备的位置，不可变更。\n* IP 地址是网络层和以上各层使用的地址，是一种逻辑地址。IP 地址用来区别网络上的计算机。\n\n> **为什么有了 MAC 地址还需要 IP 地址？**\n\n如果我们只使用 MAC 地址进行寻址的话，我们需要路由器记住每个 MAC 地址属于哪个子网，不然一次路由器收到数据包都要满世界寻找目的 MAC 地址。而我们知道 MAC 地址的长度为 48 位，也就是最多共有 2 的 48 次方个 MAC 地址，这就意味着每个路由器需要 256T 的内存，显然是不现实的。\n\n和 MAC 地址不同，IP 地址是和地域相关的，在一个子网中的设备，我们给其分配的 IP 地址前缀都是一样的，这样路由器就能根据 IP 地址的前缀知道这个设备属于哪个子网，剩下的寻址就交给子网内部实现，从而大大减少了路由器所需要的内存。\n\n> **为什么有了 IP 地址还需要 MAC 地址？**\n\n\n\n* 只有当设备连入网络时，才能根据他进入了哪个子网来为其分配 IP 地址，在设备还没有 IP 地址的时候，或者在分配 IP 的过程中。我们需要 MAC 地址来区分不同的设备。\n* IP 地址可以比作为地址，MAC 地址为收件人，在一次通信过程中，两者是缺一不可的。"
+ },
+ {
+ "id": 508,
+ "question": "ICMP 协议的功能？",
+ "answer": "ICMP（Internet Control Message Protocol） ，网际控制报文协议。\n\n* ICMP 协议是一种面向无连接的协议，用于传输出错报告控制信息。\n* 它是一个非常重要的协议，它对于网络安全具有极其重要的意义。它属于网络层协议，主要用于在主机与路由器之间传递控制信息，包括**报告错误、交换受限控制和状态信息**等。\n* 当遇到 IP 数据无法访问目标、IP 路由器无法按当前的传输速率转发数据包等情况时，会自动发送 ICMP 消息。\n\n比如我们日常使用得比较多的 **ping**，就是基于 ICMP 的。"
+ },
+ {
+ "id": 509,
+ "question": "说下 ping 的原理？",
+ "answer": "ping，**Packet Internet Groper**，一个网络工具，主要用来测试网络连接的可达性和延迟。\n\n\n\nPing 的过程主要基于 ICMP（Internet Control Message Protocol，互联网控制消息协议）实现，其基本过程包括：\n\n①、当执行 Ping 命令，如`ping javabetter.cn`，Ping 首先解析域名获取 IP 地址，然后向目标 IP 发送一个 ICMP Echo Request 消息。\n\n②、当目标 IP 收到 ICMP Echo Request 消息后，它会生成一个 ICMP Echo Reply 消息并返回，即 Ping 响应消息。\n\n③、发起 Ping 命令的设备接收到 ICMP Echo Reply 消息后，计算并显示从发送 Echo Request 到接收到 Echo Reply 的时间（通常称为往返时间 RTT，Round-Trip Time），以及可能的丢包情况。\n\nPing 通常会发送多个请求，以便提供平均响应时间和丢包率等信息，以便我们了解网络连接的质量。"
+ }
+ ]
+ },
+ {
+ "id": 74,
+ "categoryName": "网络安全",
+ "questions": [
+ {
+ "id": 510,
+ "question": "说说有哪些安全攻击？",
+ "answer": "网络安全攻击主要分为两种类型，**被动攻击**和**主动攻击**：\n\n\n\n* **被动攻击**：是指攻击者从网络上窃听他人的通信内容，通常把这类攻击称为截获，被动攻击主要有两种形式：消息内容泄露攻击和流量分析攻击。由于攻击者没有修改数据，使得这种攻击很难被检测到。\n* **主动攻击**：直接对现有的数据和服务造成影响，常见的主动攻击类型有：\n* **篡改**：攻击者故意篡改网络上送的报文，甚至把完全伪造的报文传送给接收方。\n* **恶意程序**：恶意程序种类繁多，包括计算机病毒、计算机蠕虫、特洛伊木马、后门入侵、流氓软件等等。\n* **拒绝服务 Dos**：攻击者向服务器不停地发送分组，使服务器无法提供正常服务。"
+ },
+ {
+ "id": 511,
+ "question": "DNS 劫持了解吗？",
+ "answer": "DNS 劫持即域名劫持，是通过将原域名对应的 IP 地址进行替换，从而使用户访问到错误的网站，或者使用户无法正常访问网站的一种攻击方式。\n\n\n\n域名劫持往往只能在特定的网络范围内进行，范围外的 DNS 服务器能够返回正常的 IP 地址。攻击者可以冒充原域名所属机构，通过电子邮件的方式修改组织机构的域名注册信息，或者将域名转让给其它主持，并将新的域名信息保存在所指定的 DNS 服务器中，从而使用户无法对原域名来进行解析以访问目标地址。\n\n> **DNS 劫持的步骤是什么样的？**\n\n1. 获取要劫持的域名信息：攻击者会首先访问域名查询要劫持的站点的域名信息。\n2. 控制域名响应的 E-Mail 账号：在获取到域名信息后，攻击者通过暴力破解或者专门的方法破解公司注册域名时使用的 E-mail 账号所对应的密码，更高级的攻击者甚至能够直接对 E-Mail 进行信息窃取。\n3. 修改注册信息：当攻击者破解了 E-Mail 后，会利用相关的更改功能修改该域名的注册信息，包括域名拥有者信息，DNS 服务器信息等。\n4. 使用 E-Mail 收发确认函：在修改完注册信息后，攻击者 E-Mail 在真正拥有者之前收到修改域名注册信息的相关确认信息，并回复确认修改文件，待网络公司恢复已成功修改信件后，攻击者便成功完成 DNS 劫持。\n\n> **怎么应对 DNS 劫持？**\n\n* 直接通过 IP 地址访问网站，避开 DNS 劫持\n* 由于域名劫持往往只能在特定的网络范围内进行，因此一些高级用户可以通过网络设置让 DNS 指向正常的域名服务器以实现对目标网址的正常访问，例如计算机首选 DNS 服务器的地址固定为 8.8.8.8。"
+ },
+ {
+ "id": 512,
+ "question": "什么是 CSRF 攻击？如何避免？",
+ "answer": "> **什么是 CSRF 攻击？**\n\nCSRF，跨站请求伪造（英文全称是 Cross-site request forgery），是一种挟持用户在当前已登录的 Web 应用程序上执行非本意的操作的攻击方法。\n\n> **CSRF 是如何攻击的呢？**\n\n来看一个例子：\n\n\n\n1. 用户登陆银行，没有退出，浏览器包含了 用户 在银行的身份认证信息。\n2. 攻击者将伪造的转账请求，包含在在帖子\n3. 用户在银行网站保持登陆的情况下，浏览帖子\n4. 将伪造的转账请求连同身份认证信息，发送到银行网站\n5. 银行网站看到身份认证信息，以为就是 用户的合法操作，最后造成用户资金损失。\n\n> **怎么应对 CSRF 攻击呢？**\n\n* **检查 Referer 字段**\n\nHTTP 头中的 Referer 字段记录了该 HTTP 请求的来源地址。在通常情况下，访问一个安全受限页面的请求来自于同一个网站，而如果黑客要对其实施 CSRF 攻击，他一般只能在他自己的网站构造请求。因此，可以通过验证 Referer 值来防御 CSRF 攻击。\n\n* **添加校验 token**\n\n以在 HTTP 请求中以参数的形式加入一个随机产生的 token，并在服务器端建立一个拦截器来验证这个 token，如果请求中没有 token 或者 token 内容不正确，则认为可能是 CSRF 攻击而拒绝该请求。\n\n* **敏感操作多重校验**\n\n对一些敏感的操作，除了需要校验用户的认证信息，还可以通过邮箱确认、验证码确认这样的方式多重校验。"
+ },
+ {
+ "id": 513,
+ "question": "什么是 DoS、DDoS、DRDoS 攻击？",
+ "answer": "\n\n* **DOS**: (Denial of Service), 翻译过来就是拒绝服务, 一切能引起拒绝 行为的攻击都被称为 DOS 攻击。最常见的 DoS 攻击就有**计算机网络宽带攻击**、**连通性攻击**。\n* **DDoS**: (Distributed Denial of Service)，翻译过来是分布式拒绝服务。是指处于不同位置的多个攻击者同时向一个或几个目标发动攻击，或者一个攻击者控制了位于不同位置的多台机器，并利用这些机器对受害者同时实施攻击。\n\n主要形式有流量攻击和资源耗尽攻击，常见的 DDoS 攻击有：**SYN Flood、Ping of Death、ACK Flood、UDP Flood** 等。\n\n* **DRDoS**: (Distributed Reflection Denial of Service)，中文是分布式反射拒绝服务，该方式靠的是发送大量带有被害者 IP 地址的数据包给攻击主机，然后攻击主机对 IP 地址源做出大量回应，从而形成拒绝服务攻击。\n\n> **如何防范 DDoS?**\n\n针对 DDoS 中的流量攻击，最直接的方法是增加带宽，理论上只要带宽大于攻击流量就可以了，但是这种方法成本非常高。在有充足带宽的前提下，我们应该尽量提升路由器、网卡、交换机等硬件设施的配置。\n\n针对资源耗尽攻击，我们可以升级主机服务器硬件，在网络带宽得到保证的前提下，使得服务器能够有效对抗海量的 SYN 攻击包。我们也可以安装专业的抗 DDoS 防火墙，从而对抗 SYN Flood 等流量型攻击。瓷碗，负载均衡，CDN 等技术都能有效对抗 DDos 攻击。"
+ },
+ {
+ "id": 514,
+ "question": "什么是 XSS 攻击，如何避免?",
+ "answer": "XSS 攻击也是比较常见，XSS，叫**跨站脚本攻击（Cross-Site Scripting）**，因为会与层叠样式表 (Cascading Style Sheets, CSS) 的缩写混淆，因此有人将跨站脚本攻击缩写为 XSS。它指的是恶意攻击者往 Web 页面里插入恶意 html 代码，当用户浏览网页的时候，嵌入其中 Web 里面的 html 代码会被执行，从而达到恶意攻击用户的特殊目的。\n\nXSS 攻击一般分三种类型：**存储型 、反射型 、DOM 型 XSS**\n\n> **XSS 是如何攻击的呢？**\n\n简单说，XSS 的攻击方式就是想办法“教唆”用户的浏览器去执行一些这个网页中原本不存在的前端代码。\n\n拿反射型举个例子吧，流程图如下：\n\n1. 攻击者构造出特殊的 URL，其中包含恶意代码。\n2. 用户打开带有恶意代码的 URL 时，访问正常网站服务器\n3. 网站服务端将恶意代码从 URL 中取出，拼接在 HTML 中返回给浏览器。\n4. 用户浏览器接收到响应后解析执行，混在其中的恶意代码也被执行，请求恶意服务器，发送用户数据\n5. 攻击者就可以窃取用户的数据，以此冒充用户的行为，调用目标网站接口执行攻击者指定的操作。\n\n\n> **如何应对 XSS 攻击？**\n\n* 对输入进行过滤，过滤标签等，只允许合法值。\n* HTML 转义\n* 对于链接跳转，如` 图文详解 63 道计算机网络面试高频题，这次吊打面试官，我觉得稳了（手动 dog）。整理：练习伴侣二，戳[转载链接](https://mp.weixin.qq.com/s/FvxyiMyq0422yifcyoG8vg)，作者：三分恶，戳[原文链接](https://mp.weixin.qq.com/s/yAlErlC09GnjaVvwUo3Acg)。\n\n*没有什么使我停留——除了目的，纵然岸旁有玫瑰、有绿荫、有宁静的港湾，我是不系之舟*。\n\n**系列内容**：\n\n\n\n---"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 11,
+ "topicName": "RocketMQ",
+ "categories": [
+ {
+ "id": 75,
+ "categoryName": "基础",
+ "questions": [
+ {
+ "id": 517,
+ "question": "为什么要使用消息队列呢？",
+ "answer": "消息队列（Message Queue, MQ）是一种非常重要的中间件技术，广泛应用于分布式系统中，以提高系统的可用性、解耦能力和异步通信效率。\n\n①、**解耦**\n\n生产者将消息放入队列，消费者从队列中取出消息，这样一来，生产者和消费者之间就不需要直接通信，生产者只管生产消息，消费者只管消费消息，这样就实现了解耦。\n\n\n\n像 中的任务审批，就用了 RocketMQ 来做解耦。\n\n\n\n②、**异步**：\n\n系统可以将那些耗时的任务放在消息队列中异步处理，从而快速响应用户的请求。比如说，用户下单后，系统可以先返回一个下单成功的消息，然后将订单信息放入消息队列中，后台系统再去处理订单信息。\n\n\n\n③、**削峰**：\n\n削峰填谷是一种常见的技术手段，用于应对系统高并发请求的瞬时流量高峰，通过消息队列，可以将瞬时的高峰流量转化为持续的低流量，从而保护系统不会因为瞬时的高流量而崩溃。\n\n\n\n#### [如何用RocketMQ做削峰填谷的？](#如何用rocketmq做削峰填谷的)\n\n用户请求到达系统后，由生产者接收请求并将其转化为消息，发送到 RocketMQ 队列中。队列用来充当缓冲区，将大量请求按照顺序排队，这样就可以削减请求高峰时对后端服务的直接压力。\n\n不仅如此，生产者通过异步方式发送消息，还可以快速响应用户请求。\n\n消费者从 RocketMQ 队列中按照一定速率读取消息并进行处理。可以根据后端处理能力和当前负载情况动态调整消费者的消费速率，达到填谷的效果。"
+ },
+ {
+ "id": 518,
+ "question": "为什么要选择 RocketMQ?",
+ "answer": "\n\n我们系统主要面向 C 端用户，有一定的并发量，对性能也有比较高的要求，所以选择了低延迟、吞吐量比较高，可用性比较好的 RocketMQ。"
+ },
+ {
+ "id": 519,
+ "question": "RocketMQ 有什么优缺点？",
+ "answer": "RocketMQ 优点：\n\n* 单机吞吐量：十万级\n* 可用性：非常高，分布式架构\n* 消息可靠性：经过参数优化配置，消息可以做到 0 丢失\n* 功能支持：MQ 功能较为完善，还是分布式的，扩展性好\n* 支持 10 亿级别的消息堆积，不会因为堆积导致性能下降\n* 源码是 Java，方便结合公司自己的业务二次开发\n* 天生为金融互联网领域而生，对于可靠性要求很高的场景，尤其是电商里面的订单扣款，以及业务削峰，在大量交易涌入时，后端可能无法及时处理的情况\n* **RoketMQ**在稳定性上可能更值得信赖，这些业务场景在阿里双 11 已经经历了多次考验，如果你的业务有上述并发场景，建议可以选择**RocketMQ**\n\nRocketMQ 缺点：\n\n* 支持的客户端语言不多，目前是 Java 及 c++，其中 c++不成熟\n* 没有在 MQ 核心中去实现**JMS**等接口，有些系统要迁移需要修改大量代码\n\n#### [说说你对 RocketMQ 的理解？](#说说你对-rocketmq-的理解)\n\n\n\nRocketMQ 是阿里巴巴开源的一款分布式消息中间件，具有高吞吐量、低延迟和高可用性。其主要组件包括生产者、消费者、Broker、Topic 和队列。消息由生产者发送到 Broker，再根据路由规则存储到队列中，消费者从队列中拉取消息进行处理。适用于异步解耦和流量削峰等场景。"
+ },
+ {
+ "id": 520,
+ "question": "消息队列有哪些消息模型？",
+ "answer": "消息队列有两种模型：**队列模型**和**发布/订阅模型**。\n\n* **队列模型**\n\n这是最初的一种消息队列模型，对应着消息队列“发-存-收”的模型。生产者往某个队列里面发送消息，一个队列可以存储多个生产者的消息，一个队列也可以有多个消费者，但是消费者之间是竞争关系，也就是说每条消息只能被一个消费者消费。\n\n\n\n* **发布/订阅模型**\n\n如果需要将一份消息数据分发给多个消费者，并且每个消费者都要求收到全量的消息。很显然，队列模型无法满足这个需求。解决的方式就是发布/订阅模型。\n\n在发布 - 订阅模型中，消息的发送方称为发布者（Publisher），消息的接收方称为订阅者（Subscriber），服务端存放消息的容器称为主题（Topic）。发布者将消息发送到主题中，订阅者在接收消息之前需要先“订阅主题”。“订阅”在这里既是一个动作，同时还可以认为是主题在消费时的一个逻辑副本，每份订阅中，订阅者都可以接收到主题的所有消息。\n\n\n\n它和 “队列模式” 的异同：生产者就是发布者，队列就是主题，消费者就是订阅者，无本质区别。唯一的不同点在于：一份消息数据是否可以被多次消费。"
+ },
+ {
+ "id": 521,
+ "question": "那 RocketMQ 的消息模型呢？",
+ "answer": "RocketMQ 使用的消息模型是标准的发布-订阅模型，在 RocketMQ 的术语表中，生产者、消费者和主题，与发布-订阅模型中的概念是完全一样的。\n\nRocketMQ 本身的消息是由下面几部分组成：\n\n\n\n* **Message**\n\n**Message**（消息）就是要传输的信息。\n\n一条消息必须有一个主题（Topic），主题可以看做是你的信件要邮寄的地址。\n\n一条消息也可以拥有一个可选的标签（Tag）和额处的键值对，它们可以用于设置一个业务 Key 并在 Broker 上查找此消息以便在开发期间查找问题。\n\n* **Topic**\n\n**Topic**（主题）可以看做消息的归类，它是消息的第一级类型。比如一个电商系统可以分为：交易消息、物流消息等，一条消息必须有一个 Topic 。\n\n**Topic** 与生产者和消费者的关系非常松散，一个 Topic 可以有 0 个、1 个、多个生产者向其发送消息，一个生产者也可以同时向不同的 Topic 发送消息。\n\n一个 Topic 也可以被 0 个、1 个、多个消费者订阅。\n\n* **Tag**\n\n**Tag**（标签）可以看作子主题，它是消息的第二级类型，用于为用户提供额外的灵活性。使用标签，同一业务模块不同目的的消息就可以用相同 Topic 而不同的 **Tag** 来标识。比如交易消息又可以分为：交易创建消息、交易完成消息等，一条消息可以没有 **Tag** 。\n\n标签有助于保持你的代码干净和连贯，并且还可以为 **RocketMQ** 提供的查询系统提供帮助。\n\n* **Group**\n\nRocketMQ 中，订阅者的概念是通过消费组（Consumer Group）来体现的。每个消费组都消费主题中一份完整的消息，不同消费组之间消费进度彼此不受影响，也就是说，一条消息被 Consumer Group1 消费过，也会再给 Consumer Group2 消费。\n\n消费组中包含多个消费者，同一个组内的消费者是竞争消费的关系，每个消费者负责消费组内的一部分消息。默认情况，如果一条消息被消费者 Consumer1 消费了，那同组的其他消费者就不会再收到这条消息。\n\n* **Message Queue**\n\n**Message Queue**（消息队列），一个 Topic 下可以设置多个消息队列，Topic 包括多个 Message Queue ，如果一个 Consumer 需要获取 Topic 下所有的消息，就要遍历所有的 Message Queue。\n\nRocketMQ 还有一些其它的 Queue——例如 ConsumerQueue。\n\n* **Offset**\n\n在 Topic 的消费过程中，由于消息需要被不同的组进行多次消费，所以消费完的消息并不会立即被删除，这就需要 RocketMQ 为每个消费组在每个队列上维护一个消费位置（Consumer Offset），这个位置之前的消息都被消费过，之后的消息都没有被消费过，每成功消费一条消息，消费位置就加一。\n\n也可以这么说，`Queue` 是一个长度无限的数组，**Offset** 就是下标。\n\nRocketMQ 的消息模型中，这些就是比较关键的概念了。画张图总结一下：\n\n"
+ },
+ {
+ "id": 522,
+ "question": "消息的消费模式了解吗？",
+ "answer": "消息消费模式有两种：**Clustering**（集群消费）和**Broadcasting**（广播消费）。\n\n\n\n默认情况下就是集群消费，这种模式下`一个消费者组共同消费一个主题的多个队列，一个队列只会被一个消费者消费`，如果某个消费者挂掉，分组内其它消费者会接替挂掉的消费者继续消费。\n\n而广播消费消息会发给消费者组中的每一个消费者进行消费。"
+ },
+ {
+ "id": 523,
+ "question": "RoctetMQ 基本架构了解吗？",
+ "answer": "先看图，RocketMQ 的基本架构：\n\n\n\nRocketMQ 一共有四个部分组成：NameServer，Broker，Producer 生产者，Consumer 消费者，它们对应了：发现、发、存、收，为了保证高可用，一般每一部分都是集群部署的。"
+ },
+ {
+ "id": 524,
+ "question": "那能介绍一下这四部分吗？",
+ "answer": "类比一下我们生活的邮政系统——\n\n邮政系统要正常运行，离不开下面这四个角色， 一是发信者，二 是收信者， 三是负责暂存传输的邮局， 四是负责协调各个地方邮局的管理机构。对应到 RocketMQ 中，这四个角色就是 Producer、 Consumer、 Broker 、NameServer。\n\n\n\n##### [NameServer](#nameserver)\n\nNameServer 是一个无状态的服务器，角色类似于 Kafka 使用的 Zookeeper，但比 Zookeeper 更轻量。\n\n特点：\n\n* 每个 NameServer 结点之间是相互独立，彼此没有任何信息交互。\n* Nameserver 被设计成几乎是无状态的，通过部署多个结点来标识自己是一个伪集群，Producer 在发送消息前从 NameServer 中获取 Topic 的路由信息也就是发往哪个 Broker，Consumer 也会定时从 NameServer 获取 Topic 的路由信息，Broker 在启动时会向 NameServer 注册，并定时进行心跳连接，且定时同步维护的 Topic 到 NameServer。\n\n功能主要有两个：\n\n* 1、和 Broker 结点保持长连接。\n* 2、维护 Topic 的路由信息。\n\n##### [Broker](#broker)\n\n消息存储和中转角色，负责存储和转发消息。\n\n* Broker 内部维护着一个个 Consumer Queue，用来存储消息的索引，真正存储消息的地方是 CommitLog（日志文件）。\n\n\n\n* 单个 Broker 与所有的 Nameserver 保持着长连接和心跳，并会定时将 Topic 信息同步到 NameServer，和 NameServer 的通信底层是通过 Netty 实现的。\n\n##### [Producer](#producer)\n\n消息生产者，业务端负责发送消息，由用户自行实现和分布式部署。\n\n* **Producer**由用户进行分布式部署，消息由**Producer**通过多种负载均衡模式发送到**Broker**集群，发送低延时，支持快速失败。\n* **RocketMQ** 提供了三种方式发送消息：同步、异步和单向\n* **同步发送**：同步发送指消息发送方发出数据后会在收到接收方发回响应之后才发下一个数据包。一般用于重要通知消息，例如重要通知邮件、营销短信。\n* **异步发送**：异步发送指发送方发出数据后，不等接收方发回响应，接着发送下个数据包，一般用于可能链路耗时较长而对响应时间敏感的业务场景，例如用户视频上传后通知启动转码服务。\n* **单向发送**：单向发送是指只负责发送消息而不等待服务器回应且没有回调函数触发，适用于某些耗时非常短但对可靠性要求并不高的场景，例如日志收集。\n\n##### [Consumer](#consumer)\n\n消息消费者，负责消费消息，一般是后台系统负责异步消费。\n\n* **Consumer**也由用户部署，支持 PUSH 和 PULL 两种消费模式，支持**集群消费**和**广播消费**，提供**实时的消息订阅机制**。\n* **Pull**：拉取型消费者（Pull Consumer）主动从消息服务器拉取信息，只要批量拉取到消息，用户应用就会启动消费过程，所以 Pull 称为主动消费型。\n* **Push**：推送型消费者（Push Consumer）封装了消息的拉取、消费进度和其他的内部维护工作，将消息到达时执行的回调接口留给用户应用程序来实现。所以 Push 称为被动消费类型，但其实从实现上看还是从消息服务器中拉取消息，不同于 Pull 的是 Push 首先要注册消费监听器，当监听器处触发后才开始消费消息。"
+ }
+ ]
+ },
+ {
+ "id": 76,
+ "categoryName": "进阶",
+ "questions": [
+ {
+ "id": 525,
+ "question": "如何保证消息的可用性/可靠性/不丢失呢？",
+ "answer": "消息可能在哪些阶段丢失呢？可能会在这三个阶段发生丢失：生产阶段、存储阶段、消费阶段。\n\n所以要从这三个阶段考虑：\n\n\n\n##### [生产](#生产)\n\n在生产阶段，主要**通过请求确认机制，来保证消息的可靠传递**。\n\n* 1、同步发送的时候，要注意处理响应结果和异常。如果返回响应 OK，表示消息成功发送到了 Broker，如果响应失败，或者发生其它异常，都应该重试。\n* 2、异步发送的时候，应该在回调方法里检查，如果发送失败或者异常，都应该进行重试。\n* 3、如果发生超时的情况，也可以通过查询日志的 API，来检查是否在 Broker 存储成功。\n\n##### [存储](#存储)\n\n存储阶段，可以通过**配置可靠性优先的 Broker 参数来避免因为宕机丢消息**，简单说就是可靠性优先的场景都应该使用同步。\n\n* 1、消息只要持久化到 CommitLog（日志文件）中，即使 Broker 宕机，未消费的消息也能重新恢复再消费。\n* 2、Broker 的刷盘机制：同步刷盘和异步刷盘，不管哪种刷盘都可以保证消息一定存储在 pagecache 中（内存中），但是同步刷盘更可靠，它是 Producer 发送消息后等数据持久化到磁盘之后再返回响应给 Producer。\n\n\n\n* 3、Broker 通过主从模式来保证高可用，Broker 支持 Master 和 Slave 同步复制、Master 和 Slave 异步复制模式，生产者的消息都是发送给 Master，但是消费既可以从 Master 消费，也可以从 Slave 消费。同步复制模式可以保证即使 Master 宕机，消息肯定在 Slave 中有备份，保证了消息不会丢失。\n\n##### [消费](#消费)\n\n从 Consumer 角度分析，如何保证消息被成功消费？\n\n* Consumer 保证消息成功消费的关键在于确认的时机，不要在收到消息后就立即发送消费确认，而是应该在执行完所有消费业务逻辑之后，再发送消费确认。因为消息队列维护了消费的位置，逻辑执行失败了，没有确认，再去队列拉取消息，就还是之前的一条。"
+ },
+ {
+ "id": 526,
+ "question": "如何处理消息重复的问题呢？",
+ "answer": "RocketMQ 可以保证消息一定投递，且不丢失，但无法保证消息不重复消费。\n\n因此，需要在业务端做好消息的幂等性处理，或者做消息去重。\n\n\n\n幂等性是指一个操作可以执行多次而不会产生副作用，即无论执行多少次，结果都是相同的。可以在业务逻辑中加入检查逻辑，确保同一消息多次消费不会产生副作用。\n\n例如，在支付场景下，消费者消费扣款的消息，对一笔订单执行扣款操作，金额为100元。\n\n如果因网络不稳定等原因导致扣款消息重复投递，消费者重复消费了该扣款消息，但最终的业务结果要保证只扣款一次，金额为100元。如果扣款操作是符合要求的，那么就可以认为整个消费过程实现了消息幂等。\n\n消息去重，是指在消费者消费消息之前，先检查一下是否已经消费过这条消息，如果消费过了，就不再消费。\n\n业务端可以通过一个专门的表来记录已经消费过的消息 ID，每次消费消息之前，先查询一下这个表，如果已经存在，就不再消费。\n\n\n```java\npublic void processMessage(String messageId, String message) {\n if (!isMessageProcessed(messageId)) {\n // 处理消息\n markMessageAsProcessed(messageId);\n }\n}\n\nprivate boolean isMessageProcessed(String messageId) {\n // 查询去重表，检查消息ID是否存在\n}\n\nprivate void markMessageAsProcessed(String messageId) {\n // 将消息ID插入去重表\n}\n```\n\n\n#### [如何保证消息的幂等性？](#如何保证消息的幂等性)\n\n\n\n首先，消息必须携带业务唯一标识，可以通过雪花算法生成全局唯一 ID。\n\n\n```java\nMessage msg = new Message(TOPIC /* Topic */,\n TAG /* Tag */,\n (\"Hello RocketMQ \" + i).getBytes(RemotingHelper.DEFAULT_CHARSET) /* Message body */\n );\nmessage.setKey(\"ORDERID_100\"); // 订单编号\nSendResult sendResult = producer.send(message);\n```\n\n\n其次，在消费者接收到消息后，判断 Redis 中是否存在该业务主键的标志位，若存在标志位，则认为消费成功，否则执行业务逻辑，执行完成后，在缓存中添加标志位。\n\n\n```java\npublic ConsumeConcurrentlyStatus consumeMessage(List msgs, ConsumeConcurrentlyContext context) {\n try {\n for (MessageExt messageExt : msgs) {\n String bizKey = messageExt.getKeys(); // 唯一业务主键\n //1. 判断是否存在标志\n if(redisTemplate.hasKey(RedisKeyConstants.WAITING_SEND_LOCK + bizKey)) {\n \t\t\tcontinue;\n \t\t }\n \t //2. 执行业务逻辑\n //TODO do business\n //3. 设置标志位\n redisTemplate.opsForValue().set(RedisKeyConstants.WAITING_SEND_LOCK + bizKey, \"1\", 72, TimeUnit.HOURS);\n }\n return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;\n } catch (Exception e) {\n logger.error(\"consumeMessage error: \", e);\n return ConsumeConcurrentlyStatus.RECONSUME_LATER;\n }\n}\n```\n\n\n然后，利用数据库的唯一索引来防止业务的重复插入。\n\n\n```sql\nCREATE TABLE `t_order` (\n `id` bigint(20) NOT NULL AUTO_INCREMENT,\n `order_id` varchar(64) NOT NULL COMMENT '订单编号',\n `order_name` varchar(64) NOT NULL COMMENT '订单名称',\n PRIMARY KEY (`id`),\n UNIQUE KEY `order_id` (`order_id`)\n) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订单表';\n```\n\n\n最后，在数据库表中使用版本号，通过乐观锁机制来保证幂等性。每次更新操作时检查版本号是否一致，只有一致时才执行更新并递增版本号。如果版本号不一致，则说明操作已被执行过，拒绝重复操作。\n\n\n```java\npublic void updateRecordWithOptimisticLock(int id, String newValue, int expectedVersion) {\n int updatedRows = jdbcTemplate.update(\n \"UPDATE records SET value = ?, version = version + 1 WHERE id = ? AND version = ?\",\n newValue, id, expectedVersion\n );\n if (updatedRows == 0) {\n throw new OptimisticLockingFailureException(\"Record has been modified by another transaction\");\n }\n}\n```\n\n\n或者悲观锁机制，通过数据库的锁机制来保证幂等性。\n\n\n```java\npublic void updateRecordWithPessimisticLock(int id) {\n jdbcTemplate.queryForObject(\"SELECT * FROM records WHERE id = ? FOR UPDATE\", id);\n jdbcTemplate.update(\"UPDATE records SET value = ? WHERE id = ?\", \"newValue\", id);\n}\n```\n\n\n#### [雪花算法了解吗？](#雪花算法了解吗)\n\n雪花算法是由 Twitter 开发的一种分布式唯一 ID 生成算法。\n\n雪花算法以 64 bit 来存储组成 ID 的4 个部分：\n\n1. 最高位占1 bit，始终为 0，表示正数。\n2. 中位占 41 bit，值为毫秒级时间戳；\n3. 中下位占 10 bit，机器 ID（包括数据中心 ID 和机器 ID），可以支持 1024 个节点。\n4. 末位占 12 bit，值为当前毫秒内生成的不同的自增序列，值的上限为 4096；\n\n目前雪花算法的实现比较多，可以直接使用 Hutool 工具类库中的 `IdUtil.getSnowflake()` 方法来获取雪花 ID。\n\n\n```java\nlong id = IdUtil.getSnowflakeNextId();\n```"
+ },
+ {
+ "id": 527,
+ "question": "怎么处理消息积压？",
+ "answer": "发生了消息积压，这时候就得想办法赶紧把积压的消息消费完，就得考虑提高消费能力，一般有两种办法：\n\n\n\n* **消费者扩容**：如果当前 Topic 的 Message Queue 的数量大于消费者数量，就可以对消费者进行扩容，增加消费者，来提高消费能力，尽快把积压的消息消费玩。\n* **消息迁移 Queue 扩容**：如果当前 Topic 的 Message Queue 的数量小于或者等于消费者数量，这种情况，再扩容消费者就没什么用，就得考虑扩容 Message Queue。可以新建一个临时的 Topic，临时的 Topic 多设置一些 Message Queue，然后先用一些消费者把消费的数据丢到临时的 Topic，因为不用业务处理，只是转发一下消息，还是很快的。接下来用扩容的消费者去消费新的 Topic 里的数据，消费完了之后，恢复原状。\n\n"
+ },
+ {
+ "id": 528,
+ "question": "顺序消息如何实现？",
+ "answer": "RocketMQ 实现顺序消息的关键在于保证消息生产和消费过程中严格的顺序控制，即确保同一业务的消息按顺序发送到同一个队列中，并由同一个消费者线程按顺序消费。\n\n\n\n#### [局部顺序消息如何实现？](#局部顺序消息如何实现)\n\n局部顺序消息保证在某个逻辑分区或业务逻辑下的消息顺序，例如同一个订单或用户的消息按顺序消费，而不同订单或用户之间的顺序不做保证。\n\n\n\n#### [全局顺序消息如何实现？](#全局顺序消息如何实现)\n\n全局顺序消息保证消息在整个系统范围内的严格顺序，即消息按照生产的顺序被消费。\n\n可以将所有消息发送到一个单独的队列中，确保所有消息按生产顺序发送和消费。\n\n"
+ },
+ {
+ "id": 529,
+ "question": "如何实现消息过滤？",
+ "answer": "有两种方案：\n\n* 一种是在 Broker 端按照 Consumer 的去重逻辑进行过滤，这样做的好处是避免了无用的消息传输到 Consumer 端，缺点是加重了 Broker 的负担，实现起来相对复杂。\n* 另一种是在 Consumer 端过滤，比如按照消息设置的 tag 去重，这样的好处是实现起来简单，缺点是有大量无用的消息到达了 Consumer 端只能丢弃不处理。\n\n一般采用 Cosumer 端过滤，如果希望提高吞吐量，可以采用 Broker 过滤。\n\n对消息的过滤有三种方式：\n\n\n\n* 根据 Tag 过滤：这是最常见的一种，用起来高效简单\n\n\n```text\nDefaultMQPushConsumer consumer = new DefaultMQPushConsumer(\"CID_EXAMPLE\");\nconsumer.subscribe(\"TOPIC\", \"TAGA || TAGB || TAGC\");\n```\n\n\n* SQL 表达式过滤：SQL 表达式过滤更加灵活\n\n\n```text\nDefaultMQPushConsumer consumer = new DefaultMQPushConsumer(\"please_rename_unique_group_name_4\");\n// 只有订阅的消息有这个属性a, a >=0 and a <= 3\nconsumer.subscribe(\"TopicTest\", MessageSelector.bySql(\"a between 0 and 3\");\nconsumer.registerMessageListener(new MessageListenerConcurrently() {\n @Override\n public ConsumeConcurrentlyStatus consumeMessage(List msgs, ConsumeConcurrentlyContext context) {\n return ConsumeConcurrentlyStatus.CONSUME_SUCCESS;\n }\n});\nconsumer.start();\n```\n\n\n* Filter Server 方式：最灵活，也是最复杂的一种方式，允许用户自定义函数进行过滤"
+ },
+ {
+ "id": 530,
+ "question": "延时消息了解吗？",
+ "answer": "电商的订单超时自动取消，就是一个典型的利用延时消息的例子，用户提交了一个订单，就可以发送一个延时消息，1h 后去检查这个订单的状态，如果还是未付款就取消订单释放库存。\n\nRocketMQ 是支持延时消息的，只需要在生产消息的时候设置消息的延时级别：\n\n\n```text\n// 实例化一个生产者来产生延时消息\nDefaultMQProducer producer = new DefaultMQProducer(\"ExampleProducerGroup\");\n// 启动生产者\nproducer.start();\nint totalMessagesToSend = 100;\nfor (int i = 0; i < totalMessagesToSend; i++) {\n Message message = new Message(\"TestTopic\", (\"Hello scheduled message \" + i).getBytes());\n // 设置延时等级3,这个消息将在10s之后发送(现在只支持固定的几个时间,详看delayTimeLevel)\n message.setDelayTimeLevel(3);\n // 发送消息\n producer.send(message);\n}\n```\n\n\n但是目前 RocketMQ 支持的延时级别是有限的：\n\n\n```text\nprivate String messageDelayLevel = \"1s 5s 10s 30s 1m 2m 3m 4m 5m 6m 7m 8m 9m 10m 20m 30m 1h 2h\";\n```\n\n\n#### [RocketMQ 怎么实现延时消息的？](#rocketmq-怎么实现延时消息的)\n\n简单，八个字：`临时存储`+`定时任务`。\n\nBroker 收到延时消息了，会先发送到主题（SCHEDULE\\_TOPIC\\_XXXX）的相应时间段的 Message Queue 中，然后通过一个定时任务轮询这些队列，到期后，把消息投递到目标 Topic 的队列中，然后消费者就可以正常消费这些消息。\n\n"
+ },
+ {
+ "id": 531,
+ "question": "怎么实现分布式消息事务的？半消息？",
+ "answer": "半消息：是指暂时还不能被 Consumer 消费的消息，Producer 成功发送到 Broker 端的消息，但是此消息被标记为 “暂不可投递” 状态，只有等 Producer 端执行完本地事务后经过二次确认了之后，Consumer 才能消费此条消息。\n\n依赖半消息，可以实现分布式消息事务，其中的关键在于二次确认以及消息回查：\n\n\n\n* 1、Producer 向 broker 发送半消息\n* 2、Producer 端收到响应，消息发送成功，此时消息是半消息，标记为 “不可投递” 状态，Consumer 消费不了。\n* 3、Producer 端执行本地事务。\n* 4、正常情况本地事务执行完成，Producer 向 Broker 发送 Commit/Rollback，如果是 Commit，Broker 端将半消息标记为正常消息，Consumer 可以消费，如果是 Rollback，Broker 丢弃此消息。\n* 5、异常情况，Broker 端迟迟等不到二次确认。在一定时间后，会查询所有的半消息，然后到 Producer 端查询半消息的执行情况。\n* 6、Producer 端查询本地事务的状态\n* 7、根据事务的状态提交 commit/rollback 到 broker 端。（5，6，7 是消息回查）\n* 8、消费者段消费到消息之后，执行本地事务。"
+ },
+ {
+ "id": 532,
+ "question": "死信队列知道吗？",
+ "answer": "死信队列用于存储那些无法被正常处理的消息，这些消息被称为死信（Dead Letter）。\n\n\n\n产生死信的原因是，消费者在处理消息时发生异常，且达到了最大重试次数。当消费失败的原因排查并解决后，可以重发这些死信消息，让消费者重新消费；如果暂时无法处理，为避免到期后死信消息被删除，可以先将死信消息导出并进行保存。"
+ },
+ {
+ "id": 533,
+ "question": "如何保证 RocketMQ 的高可用？",
+ "answer": "NameServer 因为是无状态，且不相互通信的，所以只要集群部署就可以保证高可用。\n\n\n\nRocketMQ 的高可用主要是在体现在 Broker 的读和写的高可用，Broker 的高可用是通过`集群`和`主从`实现的。\n\n\n\nBroker 可以配置两种角色：Master 和 Slave，Master 角色的 Broker 支持读和写，Slave 角色的 Broker 只支持读，Master 会向 Slave 同步消息。\n\n也就是说 Producer 只能向 Master 角色的 Broker 写入消息，Cosumer 可以从 Master 和 Slave 角色的 Broker 读取消息。\n\nConsumer 的配置文件中，并不需要设置是从 Master 读还是从 Slave 读，当 Master 不可用或者繁忙的时候， Consumer 的读请求会被自动切换到从 Slave。有了自动切换 Consumer 这种机制，当一个 Master 角色的机器出现故障后，Consumer 仍然可以从 Slave 读取消息，不影响 Consumer 读取消息，这就实现了读的高可用。\n\n如何达到发送端写的高可用性呢？在创建 Topic 的时候，把 Topic 的多个 Message Queue 创建在多个 Broker 组上（相同 Broker 名称，不同 brokerId 机器组成 Broker 组），这样当 Broker 组的 Master 不可用后，其他组 Master 仍然可用， Producer 仍然可以发送消息 RocketMQ 目前还不支持把 Slave 自动转成 Master ，如果机器资源不足，需要把 Slave 转成 Master ，则要手动停止 Slave 色的 Broker ，更改配置文件，用新的配置文件启动 Broker。"
+ }
+ ]
+ },
+ {
+ "id": 77,
+ "categoryName": "原理",
+ "questions": [
+ {
+ "id": 534,
+ "question": "说一下 RocketMQ 的整体工作流程？",
+ "answer": "简单来说，RocketMQ 是一个分布式消息队列，也就是`消息队列`+`分布式系统`。\n\n作为消息队列，它是`发`-`存`-`收`的一个模型，对应的就是 Producer、Broker、Cosumer；作为分布式系统，它要有服务端、客户端、注册中心，对应的就是 Broker、Producer/Consumer、NameServer\n\n所以我们看一下它主要的工作流程：RocketMQ 由 NameServer 注册中心集群、Producer 生产者集群、Consumer 消费者集群和若干 Broker（RocketMQ 进程）组成：\n\n1. Broker 在启动的时候去向所有的 NameServer 注册，并保持长连接，每 30s 发送一次心跳\n2. Producer 在发送消息的时候从 NameServer 获取 Broker 服务器地址，根据负载均衡算法选择一台服务器来发送消息\n3. Conusmer 消费消息的时候同样从 NameServer 获取 Broker 地址，然后主动拉取消息来消费\n\n"
+ },
+ {
+ "id": 535,
+ "question": "为什么 RocketMQ 不使用 Zookeeper 作为注册中心呢？",
+ "answer": "Kafka 我们都知道采用 Zookeeper 作为注册中心——当然也开始逐渐去 Zookeeper，RocketMQ 不使用 Zookeeper 其实主要可能从这几方面来考虑：\n\n1. 基于可用性的考虑，根据 CAP 理论，同时最多只能满足两个点，而 Zookeeper 满足的是 CP，也就是说 Zookeeper 并不能保证服务的可用性，Zookeeper 在进行选举的时候，整个选举的时间太长，期间整个集群都处于不可用的状态，而这对于一个注册中心来说肯定是不能接受的，作为服务发现来说就应该是为可用性而设计。\n2. 基于性能的考虑，NameServer 本身的实现非常轻量，而且可以通过增加机器的方式水平扩展，增加集群的抗压能力，而 Zookeeper 的写是不可扩展的，Zookeeper 要解决这个问题只能通过划分领域，划分多个 Zookeeper 集群来解决，首先操作起来太复杂，其次这样还是又违反了 CAP 中的 A 的设计，导致服务之间是不连通的。\n3. 持久化的机制来带的问题，ZooKeeper 的 ZAB 协议对每一个写请求，会在每个 ZooKeeper 节点上保持写一个事务日志，同时再加上定期的将内存数据镜像（Snapshot）到磁盘来保证数据的一致性和持久性，而对于一个简单的服务发现的场景来说，这其实没有太大的必要，这个实现方案太重了。而且本身存储的数据应该是高度定制化的。\n4. 消息发送应该弱依赖注册中心，而 RocketMQ 的设计理念也正是基于此，生产者在第一次发送消息的时候从 NameServer 获取到 Broker 地址后缓存到本地，如果 NameServer 整个集群不可用，短时间内对于生产者和消费者并不会产生太大影响。"
+ },
+ {
+ "id": 536,
+ "question": "Broker 是怎么保存数据的呢？",
+ "answer": "RocketMQ 主要的存储文件包括 CommitLog 文件、ConsumeQueue 文件、Indexfile 文件。\n\n\n\n消息存储的整体的设计：\n\n\n\n* **CommitLog**：消息主体以及元数据的存储主体，存储 Producer 端写入的消息主体内容,消息内容不是定长的。单个文件大小默认 1G, 文件名长度为 20 位，左边补零，剩余为起始偏移量，比如 00000000000000000000 代表了第一个文件，起始偏移量为 0，文件大小为 1G=1073741824；当第一个文件写满了，第二个文件为 00000000001073741824，起始偏移量为 1073741824，以此类推。消息主要是顺序写入日志文件，当文件满了，写入下一个文件。\n\nCommitLog 文件保存于${Rocket\\_Home}/store/commitlog 目录中，从图中我们可以明显看出来文件名的偏移量，每个文件默认 1G，写满后自动生成一个新的文件。\n\n\n\n* **ConsumeQueue**：消息消费队列，引入的目的主要是提高消息消费的性能，由于 RocketMQ 是基于主题 topic 的订阅模式，消息消费是针对主题进行的，如果要遍历 commitlog 文件中根据 topic 检索消息是非常低效的。\n\nConsumer 即可根据 ConsumeQueue 来查找待消费的消息。其中，ConsumeQueue（逻辑消费队列）作为消费消息的索引，保存了指定 Topic 下的队列消息在 CommitLog 中的起始物理偏移量 offset，消息大小 size 和消息 Tag 的 HashCode 值。\n\nConsumeQueue 文件可以看成是基于 Topic 的 CommitLog 索引文件，故 ConsumeQueue 文件夹的组织方式如下：topic/queue/file 三层组织结构，具体存储路径为：$HOME/store/consumequeue/{topic}/{queueId}/{fileName}。同样 ConsumeQueue 文件采取定长设计，每一个条目共 20 个字节，分别为 8 字节的 CommitLog 物理偏移量、4 字节的消息长度、8 字节 tag hashcode，单个文件由 30W 个条目组成，可以像数组一样随机访问每一个条目，每个 ConsumeQueue 文件大小约 5.72M；\n\n\n\n* **IndexFile**：IndexFile（索引文件）提供了一种可以通过 key 或时间区间来查询消息的方法。Index 文件的存储位置是： {fileName}，文件名 fileName 是以创建时的时间戳命名的，固定的单个 IndexFile 文件大小约为 400M，一个 IndexFile 可以保存 2000W 个索引，IndexFile 的底层存储设计为在文件系统中实现 HashMap 结构，故 RocketMQ 的索引文件其底层实现为 hash 索引。\n\n\n\n总结一下：RocketMQ 采用的是混合型的存储结构，即为 Broker 单个实例下所有的队列共用一个日志数据文件（即为 CommitLog）来存储。\n\nRocketMQ 的混合型存储结构(多个 Topic 的消息实体内容都存储于一个 CommitLog 中)针对 Producer 和 Consumer 分别采用了数据和索引部分相分离的存储结构，Producer 发送消息至 Broker 端，然后 Broker 端使用同步或者异步的方式对消息刷盘持久化，保存至 CommitLog 中。\n\n只要消息被刷盘持久化至磁盘文件 CommitLog 中，那么 Producer 发送的消息就不会丢失。正因为如此，Consumer 也就肯定有机会去消费这条消息。当无法拉取到消息后，可以等下一次消息拉取，同时服务端也支持长轮询模式，如果一个消息拉取请求未拉取到消息，Broker 允许等待 30s 的时间，只要这段时间内有新消息到达，将直接返回给消费端。\n\n这里，RocketMQ 的具体做法是，使用 Broker 端的后台服务线程—ReputMessageService 不停地分发请求并异步构建 ConsumeQueue（逻辑消费队列）和 IndexFile（索引文件）数据。\n\n"
+ },
+ {
+ "id": 537,
+ "question": "说说 RocketMQ 怎么对文件进行读写的？",
+ "answer": "RocketMQ 对文件的读写巧妙地利用了操作系统的一些高效文件读写方式——`PageCache`、`顺序读写`、`零拷贝`。\n\n* PageCache、顺序读取\n\n在 RocketMQ 中，ConsumeQueue 逻辑消费队列存储的数据较少，并且是顺序读取，在 page cache 机制的预读取作用下，Consume Queue 文件的读性能几乎接近读内存，即使在有消息堆积情况下也不会影响性能。而对于 CommitLog 消息存储的日志数据文件来说，读取消息内容时候会产生较多的随机访问读取，严重影响性能。如果选择合适的系统 IO 调度算法，比如设置调度算法为“Deadline”（此时块存储采用 SSD 的话），随机读的性能也会有所提升。\n\n页缓存（PageCache)是 OS 对文件的缓存，用于加速对文件的读写。一般来说，程序对文件进行顺序读写的速度几乎接近于内存的读写速度，主要原因就是由于 OS 使用 PageCache 机制对读写访问操作进行了性能优化，将一部分的内存用作 PageCache。对于数据的写入，OS 会先写入至 Cache 内，随后通过异步的方式由 pdflush 内核线程将 Cache 内的数据刷盘至物理磁盘上。对于数据的读取，如果一次读取文件时出现未命中 PageCache 的情况，OS 从物理磁盘上访问读取文件的同时，会顺序对其他相邻块的数据文件进行预读取。\n\n* 零拷贝\n\n另外，RocketMQ 主要通过 MappedByteBuffer 对文件进行读写操作。其中，利用了 NIO 中的 FileChannel 模型将磁盘上的物理文件直接映射到用户态的内存地址中（这种 Mmap 的方式减少了传统 IO，将磁盘文件数据在操作系统内核地址空间的缓冲区，和用户应用程序地址空间的缓冲区之间来回进行拷贝的性能开销），将对文件的操作转化为直接对内存地址进行操作，从而极大地提高了文件的读写效率（正因为需要使用内存映射机制，故 RocketMQ 的文件存储都使用定长结构来存储，方便一次将整个文件映射至内存）。\n\n##### [说说什么是零拷贝?](#说说什么是零拷贝)\n\n在操作系统中，使用传统的方式，数据需要经历几次拷贝，还要经历用户态/内核态切换。\n\n\n\n1. 从磁盘复制数据到内核态内存；\n2. 从内核态内存复制到用户态内存；\n3. 然后从用户态内存复制到网络驱动的内核态内存；\n4. 最后是从网络驱动的内核态内存复制到网卡中进行传输。\n\n所以，可以通过零拷贝的方式，**减少用户态与内核态的上下文切换**和**内存拷贝的次数**，用来提升 I/O 的性能。零拷贝比较常见的实现方式是**mmap**，这种机制在 Java 中是通过 MappedByteBuffer 实现的。\n\n"
+ },
+ {
+ "id": 538,
+ "question": "消息刷盘怎么实现的呢？",
+ "answer": "RocketMQ 提供了两种刷盘策略：同步刷盘和异步刷盘\n\n* 同步刷盘：在消息达到 Broker 的内存之后，必须刷到 commitLog 日志文件中才算成功，然后返回 Producer 数据已经发送成功。\n* 异步刷盘：异步刷盘是指消息达到 Broker 内存后就返回 Producer 数据已经发送成功，会唤醒一个线程去将数据持久化到 CommitLog 日志文件中。\n\n**Broker** 在消息的存取时直接操作的是内存（内存映射文件），这可以提供系统的吞吐量，但是无法避免机器掉电时数据丢失，所以需要持久化到磁盘中。\n\n刷盘的最终实现都是使用**NIO**中的 MappedByteBuffer.force() 将映射区的数据写入到磁盘，如果是同步刷盘的话，在**Broker**把消息写到**CommitLog**映射区后，就会等待写入完成。\n\n异步而言，只是唤醒对应的线程，不保证执行的时机，流程如图所示。\n\n"
+ },
+ {
+ "id": 539,
+ "question": "能说下 RocketMQ 的负载均衡是如何实现的？",
+ "answer": "RocketMQ 中的负载均衡都在 Client 端完成，具体来说的话，主要可以分为 Producer 端发送消息时候的负载均衡和 Consumer 端订阅消息的负载均衡。\n\n##### [Producer 的负载均衡](#producer-的负载均衡)\n\nProducer 端在发送消息的时候，会先根据 Topic 找到指定的 TopicPublishInfo，在获取了 TopicPublishInfo 路由信息后，RocketMQ 的客户端在默认方式下 selectOneMessageQueue()方法会从 TopicPublishInfo 中的 messageQueueList 中选择一个队列（MessageQueue）进行发送消息。具这里有一个 sendLatencyFaultEnable 开关变量，如果开启，在随机递增取模的基础上，再过滤掉 not available 的 Broker 代理。\n\n\n\n所谓的\"latencyFaultTolerance\"，是指对之前失败的，按一定的时间做退避。例如，如果上次请求的 latency 超过 550Lms，就退避 3000Lms；超过 1000L，就退避 60000L；如果关闭，采用随机递增取模的方式选择一个队列（MessageQueue）来发送消息，latencyFaultTolerance 机制是实现消息发送高可用的核心关键所在。\n\n##### [Consumer 的负载均衡](#consumer-的负载均衡)\n\n在 RocketMQ 中，Consumer 端的两种消费模式（Push/Pull）都是基于拉模式来获取消息的，而在 Push 模式只是对 pull 模式的一种封装，其本质实现为消息拉取线程在从服务器拉取到一批消息后，然后提交到消息消费线程池后，又“马不停蹄”的继续向服务器再次尝试拉取消息。如果未拉取到消息，则延迟一下又继续拉取。在两种基于拉模式的消费方式（Push/Pull）中，均需要 Consumer 端知道从 Broker 端的哪一个消息队列中去获取消息。因此，有必要在 Consumer 端来做负载均衡，即 Broker 端中多个 MessageQueue 分配给同一个 ConsumerGroup 中的哪些 Consumer 消费。\n\n1. Consumer 端的心跳包发送\n\n在 Consumer 启动后，它就会通过定时任务不断地向 RocketMQ 集群中的所有 Broker 实例发送心跳包（其中包含了，消息消费分组名称、订阅关系集合、消息通信模式和客户端 id 的值等信息）。Broker 端在收到 Consumer 的心跳消息后，会将它维护在 ConsumerManager 的本地缓存变量—consumerTable，同时并将封装后的客户端网络通道信息保存在本地缓存变量—channelInfoTable 中，为之后做 Consumer 端的负载均衡提供可以依据的元数据信息。\n\n2. Consumer 端实现负载均衡的核心类—RebalanceImpl\n\n在 Consumer 实例的启动流程中的启动 MQClientInstance 实例部分，会完成负载均衡服务线程—RebalanceService 的启动（每隔 20s 执行一次）。\n\n通过查看源码可以发现，RebalanceService 线程的 run()方法最终调用的是 RebalanceImpl 类的 rebalanceByTopic()方法，这个方法是实现 Consumer 端负载均衡的核心。\n\nrebalanceByTopic()方法会根据消费者通信类型为“广播模式”还是“集群模式”做不同的逻辑处理。这里主要来看下集群模式下的主要处理流程：\n\n\n\n(1) 从 rebalanceImpl 实例的本地缓存变量—topicSubscribeInfoTable 中，获取该 Topic 主题下的消息消费队列集合（mqSet）；\n\n(2) 根据 topic 和 consumerGroup 为参数调用 mQClientFactory.findConsumerIdList()方法向 Broker 端发送通信请求，获取该消费组下消费者 Id 列表；\n\n(3) 先对 Topic 下的消息消费队列、消费者 Id 排序，然后用消息队列分配策略算法（默认为：消息队列的平均分配算法），计算出待拉取的消息队列。这里的平均分配算法，类似于分页的算法，将所有 MessageQueue 排好序类似于记录，将所有消费端 Consumer 排好序类似页数，并求出每一页需要包含的平均 size 和每个页面记录的范围 range，最后遍历整个 range 而计算出当前 Consumer 端应该分配到的的 MessageQueue。\n\n\n\n(4) 然后，调用 updateProcessQueueTableInRebalance()方法，具体的做法是，先将分配到的消息队列集合（mqSet）与 processQueueTable 做一个过滤比对。\n\n\n\n* 上图中 processQueueTable 标注的红色部分，表示与分配到的消息队列集合 mqSet 互不包含。将这些队列设置 Dropped 属性为 true，然后查看这些队列是否可以移除出 processQueueTable 缓存变量，这里具体执行 removeUnnecessaryMessageQueue()方法，即每隔 1s 查看是否可以获取当前消费处理队列的锁，拿到的话返回 true。如果等待 1s 后，仍然拿不到当前消费处理队列的锁则返回 false。如果返回 true，则从 processQueueTable 缓存变量中移除对应的 Entry；\n* 上图中 processQueueTable 的绿色部分，表示与分配到的消息队列集合 mqSet 的交集。判断该 ProcessQueue 是否已经过期了，在 Pull 模式的不用管，如果是 Push 模式的，设置 Dropped 属性为 true，并且调用 removeUnnecessaryMessageQueue()方法，像上面一样尝试移除 Entry；\n* 最后，为过滤后的消息队列集合（mqSet）中的每个 MessageQueue 创建一个 ProcessQueue 对象并存入 RebalanceImpl 的 processQueueTable 队列中（其中调用 RebalanceImpl 实例的 computePullFromWhere(MessageQueue mq)方法获取该 MessageQueue 对象的下一个进度消费值 offset，随后填充至接下来要创建的 pullRequest 对象属性中），并创建拉取请求对象—pullRequest 添加到拉取列表—pullRequestList 中，最后执行 dispatchPullRequest()方法，将 Pull 消息的请求对象 PullRequest 依次放入 PullMessageService 服务线程的阻塞队列 pullRequestQueue 中，待该服务线程取出后向 Broker 端发起 Pull 消息的请求。其中，可以重点对比下，RebalancePushImpl 和 RebalancePullImpl 两个实现类的 dispatchPullRequest()方法不同，RebalancePullImpl 类里面的该方法为空。\n\n消息消费队列在同一消费组不同消费者之间的负载均衡，其核心设计理念是在一个消息消费队列在同一时间只允许被同一消费组内的一个消费者消费，一个消息消费者能同时消费多个消息队列。"
+ },
+ {
+ "id": 540,
+ "question": "RocketMQ 消息长轮询了解吗？",
+ "answer": "所谓的长轮询，就是 Consumer 拉取消息，如果对应的 Queue 如果没有数据，Broker 不会立即返回，而是把 PullReuqest hold 起来，等待 queue 有了消息后，或者长轮询阻塞时间到了，再重新处理该 queue 上的所有 PullRequest。\n\n\n\n* PullMessageProcessor#processRequest\n\n\n```text\n//如果没有拉到数据\ncase ResponseCode.PULL_NOT_FOUND:\n// broker 和 consumer 都允许 suspend，默认开启\nif (brokerAllowSuspend && hasSuspendFlag) {\n long pollingTimeMills = suspendTimeoutMillisLong;\n if (!this.brokerController.getBrokerConfig().isLongPollingEnable()) {\n pollingTimeMills = this.brokerController.getBrokerConfig().getShortPollingTimeMills();\n }\n\n String topic = requestHeader.getTopic();\n long offset = requestHeader.getQueueOffset();\n int queueId = requestHeader.getQueueId();\n //封装一个PullRequest\n PullRequest pullRequest = new PullRequest(request, channel, pollingTimeMills,\n this.brokerController.getMessageStore().now(), offset, subscriptionData, messageFilter);\n //把PullRequest挂起来\n this.brokerController.getPullRequestHoldService().suspendPullRequest(topic, queueId, pullRequest);\n response = null;\n break;\n}\n```\n\n\n挂起的请求，有一个服务线程会不停地检查，看 queue 中是否有数据，或者超时。\n\n* PullRequestHoldService#run()\n\n\n```text\n@Override\npublic void run() {\n log.info(\"{} service started\", this.getServiceName());\n while (!this.isStopped()) {\n try {\n if (this.brokerController.getBrokerConfig().isLongPollingEnable()) {\n this.waitForRunning(5 * 1000);\n } else {\n this.waitForRunning(this.brokerController.getBrokerConfig().getShortPollingTimeMills());\n }\n\n long beginLockTimestamp = this.systemClock.now();\n //检查hold住的请求\n this.checkHoldRequest();\n long costTime = this.systemClock.now() - beginLockTimestamp;\n if (costTime > 5 * 1000) {\n log.info(\"[NOTIFYME] check hold request cost {} ms.\", costTime);\n }\n } catch (Throwable e) {\n log.warn(this.getServiceName() + \" service has exception. \", e);\n }\n }\n\n log.info(\"{} service end\", this.getServiceName());\n}\n```\n\n> 图文详解 RocketMQ 面试高频题，这次吊打面试官，我觉得稳了（手动 dog）。整理：练习伴侣二，戳[转载链接](https://mp.weixin.qq.com/s/N6wq52pBGh8xkS-5uRcO2g)，作者：三分恶，戳[原文链接](https://mp.weixin.qq.com/s/IvBt3tB_IWZgPjKv5WGS4A)。\n\n---\n\n*没有什么使我停留——除了目的，纵然岸旁有玫瑰、有绿荫、有宁静的港湾，我是不系之舟*。\n\n**系列内容**：\n\n\n\n---"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 12,
+ "topicName": "分布式",
+ "categories": [
+ {
+ "id": 78,
+ "categoryName": "分布式理论",
+ "questions": [
+ {
+ "id": 541,
+ "question": "说说 CAP 原则？",
+ "answer": "CAP 原则又称 CAP 定理，指的是在一个分布式系统中，Consistency（一致性）、 Availability（可用性）、Partition tolerance（分区容错性）这 3 个基本需求，最多只能同时满足其中的 2 个。\n\n\n\n| 选项 | 描述 |\n| --- | --- |\n| Consistency（一致性） | 指数据在多个副本之间能够保持一致的特性（严格的一致性） |\n| Availability（可用性） | 指系统提供的服务必须一直处于可用的状态，每次请求都能获取到非错的响应（不保证获取的数据为最新数据） |\n| Partition tolerance（分区容错性） | 分布式系统在遇到任何网络分区故障的时候，仍然能够对外提供满足一致性和可用性的服务，除非整个网络环境都发生了故障 |"
+ },
+ {
+ "id": 542,
+ "question": "为什么 CAP 不可兼得呢？",
+ "answer": "首先对于分布式系统，分区是必然存在的，所谓分区指的是分布式系统可能出现的字区域网络不通，成为孤立区域的的情况。\n\n\n\n那么分区容错性（**P**）就必须要满足，因为如果要牺牲分区容错性，就得把服务和资源放到一个机器，或者一个“同生共死”的集群，那就违背了分布式的初衷。\n\n那么满足分区容错的基础上，能不能同时满足`一致性`和`可用性`？\n\n假如现在有两个分区`N1`和`N2`，N1 和 N2 分别有不同的分区存储 D1 和 D2，以及不同的服务 S1 和 S2。\n\n* 在满足`一致性` 的时候，N1 和 N2 的数据要求值一样的，D1=D2。\n* 在满足`可用性`的时候，无论访问 N1 还是 N2，都能获取及时的响应。\n\n\n\n假如现在有这样的场景：\n\n* 用户访问了 N1，修改了 D1 的数据。\n* 用户再次访问，请求落在了 N2。此时 D1 和 D2 的数据不一致。\n\n接下来：\n\n* 保证`一致性`：此时 D1 和 D2 数据不一致，要保证一致性就不能返回不一致的数据，`可用性`无法保证。\n* 保证`可用性`：立即响应，可用性得到了保证，但是此时响应的数据和 D1 不一致，`一致性`无法保证。\n\n所以，可以看出，分区容错的前提下，`一致性`和`可用性`是矛盾的。"
+ },
+ {
+ "id": 543,
+ "question": "CAP 对应的模型和应用？",
+ "answer": "**CA without P**\n\n理论上放弃 P（分区容错性），则 C（强一致性）和 A（可用性）是可以保证的。实际上分区是不可避免的，严格上 CA 指的是允许分区后各子系统依然保持 CA。\n\nCA 模型的常见应用：\n\n* 集群数据库\n* xFS 文件系统\n\n**CP without A**\n\n放弃 A（可用），相当于每个请求都需要在 Server 之间强一致，而 P（分区）会导致同步时间无限延长，如此 CP 也是可以保证的。很多传统的数据库分布式事务都属于这种模式。\n\nCP 模型的常见应用：\n\n* 分布式数据库\n* 分布式锁\n\n**AP wihtout C**\n\n要高可用并允许分区，则需放弃一致性。一旦分区发生，节点之间可能会失去联系，为了高可用，每个节点只能用本地数据提供服务，而这样会导致全局数据的不一致性。现在众多的 NoSQL 都属于此类。\n\nAP 模型常见应用：\n\n* Web 缓存\n* DNS\n\n举个大家更熟悉的例子，像我们熟悉的注册中心`ZooKeeper`、`Eureka`、`Nacos`中：\n\n* ZooKeeper 保证的是 CP\n* Eureka 保证的则是 AP\n* Nacos 不仅支持 CP 也支持 AP"
+ },
+ {
+ "id": 544,
+ "question": "BASE 理论了解吗？",
+ "answer": "BASE（Basically Available、Soft state、Eventual consistency）是基于 CAP 理论逐步演化而来的，核心思想是即便不能达到强一致性（Strong consistency），也可以根据应用特点采用适当的方式来达到最终一致性（Eventual consistency）的效果。\n\n\n\nBASE 的主要含义：\n\n* **Basically Available（基本可用）**\n\n什么是基本可用呢？假设系统出现了不可预知的故障，但还是能用，只是相比较正常的系统而言，可能会有响应时间上的损失，或者功能上的降级。\n\n* **Soft State（软状态）**\n\n什么是硬状态呢？要求多个节点的数据副本都是一致的，这是一种“硬状态”。\n\n软状态也称为弱状态，相比较硬状态而言，允许系统中的数据存在中间状态，并认为该状态不影响系统的整体可用性，即允许系统在多个不同节点的数据副本存在数据延时。\n\n* **Eventually Consistent（最终一致性）**\n\n上面说了软状态，但是不应该一直都是软状态。在一定时间后，应该到达一个最终的状态，保证所有副本保持数据一致性，从而达到数据的最终一致性。这个时间取决于网络延时、系统负载、数据复制方案设计等等因素。"
+ }
+ ]
+ },
+ {
+ "id": 79,
+ "categoryName": "分布式锁",
+ "questions": [
+ {
+ "id": 545,
+ "question": "有哪些分布式锁的实现方案呢？",
+ "answer": "常见的分布式锁实现方案有三种：`MySQL分布式锁`、`ZooKepper分布式锁`、`Redis分布式锁`。\n\n\n\n#### [5.1 MySQL 分布式锁如何实现呢？](#_5-1-mysql-分布式锁如何实现呢)\n\n用数据库实现分布式锁比较简单，就是创建一张锁表，数据库对字段作唯一性约束。\n\n加锁的时候，在锁表中增加一条记录即可；释放锁的时候删除记录就行。\n\n如果有并发请求同时提交到数据库，数据库会保证只有一个请求能够得到锁。\n\n这种属于数据库 IO 操作，效率不高，而且频繁操作会增大数据库的开销，因此这种方式在高并发、高性能的场景中用的不多。\n\n#### [5.2 ZooKeeper 如何实现分布式锁？](#_5-2-zookeeper-如何实现分布式锁)\n\nZooKeeper 也是常见分布式锁实现方法。\n\nZooKeeper 的数据节点和文件目录类似，例如有一个 lock 节点，在此节点下建立子节点是可以保证先后顺序的，即便是两个进程同时申请新建节点，也会按照先后顺序建立两个节点。\n\n\n\n所以我们可以用此特性实现分布式锁。以某个资源为目录，然后这个目录下面的节点就是我们需要获取锁的客户端，每个服务在目录下创建节点，如果它的节点，序号在目录下最小，那么就获取到锁，否则等待。释放锁，就是删除服务创建的节点。\n\nZK 实际上是一个比较重的分布式组件，实际上应用没那么多了，所以用 ZK 实现分布式锁，其实相对也比较少。\n\n#### [5.3 Redis 怎么实现分布式锁？](#_5-3-redis-怎么实现分布式锁)\n\nRedis 实现分布式锁，是当前应用最广泛的分布式锁实现方式。\n\nRedis 执行命令是单线程的，Redis 实现分布式锁就是利用这个特性。\n\n实现分布式锁最简单的一个命令：setNx(set if not exist)，如果不存在则更新：\n\n\n```text\nsetNx resourceName value\n```\n\n\n加锁了之后如果机器宕机，那我这个锁就无法释放，所以需要加入过期时间，而且过期时间需要和 setNx 同一个原子操作，在 Redis2.8 之前需要用 lua 脚本，但是 redis2.8 之后 redis 支持 nx 和 ex 操作是同一原子操作。\n\n\n```text\nset resourceName value ex 5 nx\n```\n\n\n* **Redission**\n\n当然，一般生产中都是使用 Redission 客户端，非常良好地封装了分布式锁的 api，而且支持 RedLock。"
+ }
+ ]
+ },
+ {
+ "id": 80,
+ "categoryName": "分布式事务",
+ "questions": [
+ {
+ "id": 546,
+ "question": "什么是分布式事务?",
+ "answer": "在分布式环境下，会涉及到多个数据库，比如说支付库、商品库、订单库。因此要保证跨服务的事务一致性就变得非常复杂。\n\n\n\n分布式事务其实就是将单一库的事务概念扩大到了多库，目的是为了保证跨服的数据一致性。"
+ },
+ {
+ "id": 547,
+ "question": "分布式事务有哪些常见的实现方案？",
+ "answer": "分布式事务的实现方式主要包括：\n\n* 二阶段提交（2PC）：通过准备和提交阶段保证一致性，但性能较差。\n* 三阶段提交（3PC）：在 2PC 的基础上增加了一个超时机制，降低了阻塞，但依旧存在数据不一致的风险。\n* TCC：根据业务逻辑拆分为 Try、Confirm 和 Cancel 三个阶段，适合锁定资源的业务场景。\n* 本地消息表：在数据库中存储事务事件，通过定时任务处理消息。\n* 基于 MQ 的分布式事务：通过消息队列来实现异步确保，利用重试机制保障最终一致性，适用于对实时性要求不高的场景。\n\n#### [7.1 说说 2PC 两阶段提交？](#_7-1-说说-2pc-两阶段提交)\n\n说到 2PC，就不得先说分布式事务中的 XA 协议。\n\n在这个协议里，有三个角色：\n\n* **AP（Application）**：应用系统（服务）\n* **TM（Transaction Manager）**：事务管理器（全局事务管理）\n* **RM（Resource Manager）**：资源管理器（数据库）\n\n\n\nXA 协议采用**两阶段提交**方式来管理分布式事务。XA 接口提供资源管理器与事务管理器之间进行通信的标准接口。\n\n两阶段提交的思路可以概括为：参与者将操作成败通知协调者，再由协调者根据所有参与者的反馈情况决定各参与者是否要提交操作还是回滚操作。\n\n\n\n* 准备阶段：事务管理器要求每个涉及到事务的数据库预提交(precommit)此操作，并反映是否可以提交\n* 提交阶段：事务协调器要求每个数据库提交数据，或者回滚数据。\n\n优点：尽量保证了数据的强一致，实现成本较低，在各大主流数据库都有自己实现，对于 MySQL 是从 5.5 开始支持。\n\n缺点:\n\n* 单点问题：事务管理器在整个流程中扮演的角色很关键，如果其宕机，比如在第一阶段已经完成，在第二阶段正准备提交的时候事务管理器宕机，资源管理器就会一直阻塞，导致数据库无法使用。\n* 同步阻塞：在准备就绪之后，资源管理器中的资源一直处于阻塞，直到提交完成，释放资源。\n* 数据不一致：两阶段提交协议虽然为分布式数据强一致性所设计，但仍然存在数据不一致性的可能，比如在第二阶段中，假设协调者发出了事务 commit 的通知，但是因为网络问题该通知仅被一部分参与者所收到并执行了 commit 操作，其余的参与者则因为没有收到通知一直处于阻塞状态，这时候就产生了数据的不一致性。\n\n#### [7.2 3PC（三阶段提交）了解吗？](#_7-2-3pc-三阶段提交-了解吗)\n\n三阶段提交（`3PC`）是二阶段提交（`2PC`）的一种改进版本 ，为解决两阶段提交协议的单点故障和同步阻塞问题。\n\n三阶段提交有这么三个阶段：`CanCommit`，`PreCommit`，`DoCommit`三个阶段\n\n\n\n* **CanCommit**：准备阶段。协调者向参与者发送 commit 请求，参与者如果可以提交就返回 Yes 响应，否则返回 No 响应。\n* **PreCommit**：预提交阶段。协调者根据参与者在**准备阶段**的响应判断是否执行事务还是中断事务，参与者执行完操作之后返回 ACK 响应，同时开始等待最终指令。\n* **DoCommit**：提交阶段。协调者根据参与者在**准备阶段**的响应判断是否执行事务还是中断事务：\n* 如果所有参与者都返回正确的`ACK`响应，则提交事务\n* 如果参与者有一个或多个参与者收到错误的`ACK`响应或者超时，则中断事务\n* 如果参与者无法及时接收到来自协调者的提交或者中断事务请求时，在等待超时之后，会继续进行事务提交\n\n可以看出，三阶段提交解决的只是两阶段提交中**单体故障**和**同步阻塞**的问题，因为加入了超时机制，这里的超时的机制作用于 **预提交阶段** 和 **提交阶段**。如果等待 **预提交请求** 超时，参与者直接回到准备阶段之前。如果等到**提交请求**超时，那参与者就会提交事务了。\n\n**无论是 2PC 还是 3PC 都不能保证分布式系统中的数据 100%一致**。\n\n#### [7.3 TCC 了解吗？](#_7-3-tcc-了解吗)\n\n**TCC（Try Confirm Cancel）** ，是两阶段提交的一个变种，针对每个操作，都需要有一个其对应的确认和取消操作，当操作成功时调用确认操作，当操作失败时调用取消操作，类似于二阶段提交，只不过是这里的提交和回滚是针对业务上的，所以基于 TCC 实现的分布式事务也可以看做是对业务的一种补偿机制。\n\n\n\n* **Try**：尝试待执行的业务。订单系统将当前订单状态设置为支付中，库存系统校验当前剩余库存数量是否大于 1，然后将可用库存数量设置为库存剩余数量-1，。\n* **Confirm**：确认执行业务，如果 Try 阶段执行成功，接着执行 Confirm 阶段，将订单状态修改为支付成功，库存剩余数量修改为可用库存数量。\n* **Cancel**：取消待执行的业务，如果 Try 阶段执行失败，执行 Cancel 阶段，将订单状态修改为支付失败，可用库存数量修改为库存剩余数量。\n\n**TCC** 是业务层面的分布式事务，保证最终一致性，不会一直持有资源的锁。\n\n* **优点：** 把数据库层的二阶段提交交给应用层来实现，规避了数据库的 2PC 性能低下问题\n* **缺点**：TCC 的 Try、Confirm 和 Cancel 操作功能需业务提供，开发成本高。TCC 对业务的侵入较大和业务紧耦合，需要根据特定的场景和业务逻辑来设计相应的操作\n\n#### [7.4 本地消息表了解吗？](#_7-4-本地消息表了解吗)\n\n本地消息表的核心思想是将分布式事务拆分成本地事务进行处理。\n\n例如，可以在订单库新增一个消息表，将新增订单和新增消息放到一个事务里完成，然后通过轮询的方式去查询消息表，将消息推送到 MQ，库存服务去消费 MQ。\n\n\n\n**执行流程：**\n\n1. 订单服务，添加一条订单和一条消息，在一个事务里提交\n2. 订单服务，使用定时任务轮询查询状态为未同步的消息表，发送到 MQ，如果发送失败，就重试发送\n3. 库存服务，接收 MQ 消息，修改库存表，需要保证幂等操作\n4. 如果修改成功，调用 rpc 接口修改订单系统消息表的状态为已完成或者直接删除这条消息\n5. 如果修改失败，可以不做处理，等待重试\n\n订单服务中的消息有可能由于业务问题会一直重复发送，所以为了避免这种情况可以记录一下发送次数，当达到次数限制之后报警，人工接入处理；库存服务需要保证幂等，避免同一条消息被多次消费造成数据不一致。\n\n本地消息表这种方案实现了最终一致性，需要在业务系统里增加消息表，业务逻辑中多一次插入的 DB 操作，所以性能会有损耗，而且最终一致性的间隔主要有定时任务的间隔时间决定\n\n#### [7.5 MQ 消息事务了解吗？](#_7-5-mq-消息事务了解吗)\n\n基于 MQ 的分布式事务是指**将两个事务通过消息队列进行异步解耦**，利用重试机制保障最终一致性，适用于对实时性要求不高的场景。\n\n订单服务执行自己的本地事务，并发送消息到 MQ，库存服务接收到消息后，执行自己的本地事务，如果消费失败，可以利用重试机制确保最终一致性。\n\n\n\n延迟队列在分布式事务中通常用于异步补偿、定时校验和故障重试等场景，确保数据最终一致性。\n\n当主事务执行完成后，延迟队列会在一定时间后检查各子事务的状态，如果有失败的子事务，可以触发补偿操作，重试或回滚事务。\n\n当分布式锁因为某些原因未被正常释放时，可以通过延迟队列在超时后自动释放锁，防止死锁。\n\n#### [7.6 最大努力通知了解吗？](#_7-6-最大努力通知了解吗)\n\n最大努力通知相比实现会简单一些，适用于一些对最终一致性实时性要求没那么高的业务，比如支付通知，短信通知。\n\n以支付通知为例，业务系统调用支付平台进行支付，支付平台进行支付，进行操作支付之后支付平台会去同步通知业务系统支付操作是否成功，如果不成功，会一直异步重试，但是会有一个最大通知次数，如果超过这个次数后还是通知失败，就不再通知，业务系统自行调用支付平台提供一个查询接口，供业务系统进行查询支付操作是否成功。\n\n\n\n**执行流程：**\n\n1. 业务系统调用支付平台支付接口， 并在本地进行记录，支付状态为支付中\n2. 支付平台进行支付操作之后，无论成功还是失败，同步给业务系统一个结果通知\n3. 如果通知一直失败则根据重试规则异步进行重试，达到最大通知次数后，不再通知\n4. 支付平台提供查询订单支付操作结果接口\n5. 业务系统根据一定业务规则去支付平台查询支付结果"
+ },
+ {
+ "id": 548,
+ "question": "你们用什么？能说一下 Seata 吗？",
+ "answer": "我们用比较常用的是 Seata——自己去实现分布式事务调度还是比较麻烦的。\n\n**Seata** 的设计目标是对业务无侵入，因此它是从业务无侵入的两阶段提交（全局事务）着手，在传统的两阶段上进行改进，他把一个分布式事务理解成一个包含了若干分支事务的全局事务。而全局事务的职责是协调它管理的分支事务达成一致性，要么一起成功提交，要么一起失败回滚。也就是一荣俱荣一损俱损~\n\n\n\n**Seata** 中存在这么几种重要角色：\n\n* **TC（Transaction Coordinator）**：事务协调者。管理全局的分支事务的状态，用于全局性事务的提交和回滚。\n* **TM（Transaction Manager）**：事务管理者。用于开启、提交或回滚事务。\n* **RM（Resource Manager）**：资源管理器。用于分支事务上的资源管理，向 **TC** 注册分支事务，上报分支事务的状态，接收 **TC** 的命令来提交或者回滚分支事务。\n\n\n\nSeata 整体执行流程：\n\n1. 服务 A 中的 **TM** 向 **TC** 申请开启一个全局事务，**TC** 就会创建一个全局事务并返回一个唯一的 **XID**\n2. 服务 A 中的 **RM** 向 **TC** 注册分支事务，然后将这个分支事务纳入 **XID** 对应的全局事务管辖中\n3. 服务 A 开始执行分支事务\n4. 服务 A 开始远程调用 B 服务，此时 **XID** 会根据调用链传播\n5. 服务 B 中的 **RM** 也向 **TC** 注册分支事务，然后将这个分支事务纳入 **XID** 对应的全局事务管辖中\n6. 服务 B 开始执行分支事务\n7. 全局事务调用处理结束后，**TM** 会根据有误异常情况，向 **TC** 发起全局事务的提交或回滚\n8. **TC** 协调其管辖之下的所有分支事务，决定是提交还是回滚"
+ }
+ ]
+ },
+ {
+ "id": 81,
+ "categoryName": "分布式一致性算法",
+ "questions": [
+ {
+ "id": 549,
+ "question": "分布式算法 paxos 了解么 ？",
+ "answer": "`Paxos` 有点类似前面说的 `2PC`，`3PC`，但比这两种算法更加完善。在很多多大厂都得到了工程实践，比如阿里的 `OceanBase` 的 **分布式数据库**， `Google` 的 `chubby` **分布式锁** 。\n\n#### [Paxos 算法是什么？](#paxos-算法是什么)\n\n`Paxos` 算法是 **基于消息传递** 且具有 **高效容错特性** 的一致性算法，目前公认的解决 **分布式一致性问题** 最有效的算法之一。\n\n#### [Paxos 算法的工作流程？](#paxos-算法的工作流程)\n\n##### [角色](#角色)\n\n在 Paxos 中有这么几个角色：\n\n1. **Proposer（提议者）** : 提议者提出提案，用于投票表决。\n2. **Accecptor（接受者）** : 对提案进行投票，并接受达成共识的提案。\n3. **Learner（学习者）** : 被告知投票的结果，接受达成共识的提案。\n\n在实际中，一个节点可以同时充当不同角色。\n\n\n\n提议者提出提案，提案=编号+value，可以表示为[M,V]，每个提案都有唯一编号，而且编号的大小是趋势递增的。\n\n##### [算法流程](#算法流程)\n\nPaxos 算法包含两个阶段，第一阶段 **Prepare(准备)** 、第二阶段 **Accept(接受)** 。\n\n\n\n###### [Prepare(准备)阶段](#prepare-准备-阶段)\n\n1. 提议者提议一个新的提案 P[Mn,?]，然后向接受者的某个超过半数的子集成员发送编号为 Mn 的准备请求\n2. 如果一个接受者收到一个编号为 Mn 的准备请求，并且编号 Mn 大于它已经响应的所有准备请求的编号，那么它就会将它已经批准过的最大编号的提案作为响应反馈给提议者，同时该接受者会承诺不会再批准任何编号小于 Mn 的提案。\n\n总结一下，接受者在收到提案后，会给与提议者**两个承诺**与**一个应答**：\n\n* 两个承诺：\n* 承诺不会再接受提案号小于或等于 Mn 的 Prepare 请求\n* 承诺不会再接受提案号小于 Mn 的 Accept 请求\n* 一个应答：\n* 不违背以前作出的承诺的前提下，回复已经通过的提案中提案号最大的那个提案所设定的值和提案号 Mmax，如果这个值从来没有被任何提案设定过，则返回空值。如果不满足已经做出的承诺，即收到的提案号并不是决策节点收到过的最大的，那允许直接对此 Prepare 请求不予理会。\n\n###### [Accept(接受)阶段](#accept-接受-阶段)\n\n1. 如果提议者收到来自半数以上的接受者对于它发出的编号为 Mn 的准备请求的响应，那么它就会发送一个针对[Mn,Vn]的接受请求给接受者，注意 Vn 的值就是收到的响应中编号最大的提案的值，如果响应中不包含任何提案，那么它可以随意选定一个值。\n2. 如果接受者收到这个针对[Mn,Vn]提案的接受请求，只要该接受者尚未对编号大于 Mn 的准备请求做出响应，它就可以通过这个提案。\n\n当提议者收到了多数接受者的接受应答后，协商结束，共识决议形成，将形成的决议发送给所有学习节点进行学习。\n\n所以 Paxos 算法的整体详细流程如下：\n\n\n\n#### [Paxos 算法有什么缺点吗？怎么优化？](#paxos-算法有什么缺点吗-怎么优化)\n\n前面描述的可以称之为 Basic Paxos 算法，在单提议者的前提下是没有问题的，但是假如有多个提议者互不相让，那么就可能导致整个提议的过程进入了死循环。\n\nLamport 提出了 Multi Paxos 的算法思想。\n\nMulti Paxos 算法思想，简单说就是在多个提议者的情况下，选出一个 Leader（领导者），由领导者作为唯一的提议者，这样就可以解决提议者冲突的问题。"
+ },
+ {
+ "id": 550,
+ "question": "说说 Raft 算法？",
+ "answer": "#### [Raft 算法是什么？](#raft-算法是什么)\n\n`Raft` 也是一个 **一致性算法**，和 `Paxos` 目标相同。但它还有另一个名字 - **易于理解的一致性算法**。`Paxos` 和 `Raft` 都是为了实现 **一致性** 产生的。这个过程如同选举一样，**参选者** 需要说服 **大多数选民** (Server) 投票给他，一旦选定后就跟随其操作。`Paxos` 和 `Raft` 的区别在于选举的 **具体过程** 不同。\n\n#### [Raft 算法的工作流程？](#raft-算法的工作流程)\n\n##### [Raft 算法的角色](#raft-算法的角色)\n\n`Raft` 协议将 `Server` 进程分为三种角色：\n\n* **Leader（领导者）**\n* **Follower（跟随者）**\n* **Candidate（候选人）**\n\n就像一个民主社会，领导者由跟随者投票选出。刚开始没有 **领导者**，所有集群中的 **参与者** 都是 **跟随者**。\n\n那么首先开启一轮大选。在大选期间 **所有跟随者** 都能参与竞选，这时所有跟随者的角色就变成了 **候选人**，民主投票选出领袖后就开始了这届领袖的任期，然后选举结束，所有除 **领导者** 的 **候选人** 又变回 **跟随者** 服从领导者领导。\n\n这里提到一个概念 **「任期」**，用术语 `Term` 表达。\n\n三类角色的变迁图如下：\n\n\n\n##### [Leader 选举过程](#leader-选举过程)\n\nRaft 使用心跳（heartbeat）触发 Leader 选举。当 Server 启动时，初始化为 Follower。Leader 向所有 Followers 周期性发送 heartbeat。如果 Follower 在选举超时时间内没有收到 Leader 的 heartbeat，就会等待一段随机的时间后发起一次 Leader 选举。\n\nFollower 将其当前 term 加一然后转换为 Candidate。它首先给自己投票并且给集群中的其他服务器发送 RequestVote RPC 。结果有以下三种情况：\n\n* 赢得了多数（超过 1/2）的选票，成功选举为 Leader；\n* 收到了 Leader 的消息，表示有其它服务器已经抢先当选了 Leader；\n* 没有 Server 赢得多数的选票，Leader 选举失败，等待选举时间超时（`Election Timeout`）后发起下一次选举。\n\n\n\n选出 `Leader` 后，`Leader` 通过 **定期** 向所有 `Follower` 发送 **心跳信息** 维持其统治。若 `Follower` 一段时间未收到 `Leader` 的 **心跳**，则认为 `Leader` 可能已经挂了，然后再次发起 **选举** 过程。"
+ }
+ ]
+ },
+ {
+ "id": 82,
+ "categoryName": "分布式设计",
+ "questions": [
+ {
+ "id": 551,
+ "question": "说说什么是幂等性？",
+ "answer": "> 什么是幂等性？\n\n幂等性是一个数学概念，用在接口上：用在接口上就可以理解为：**同一个接口，多次发出同一个请求，请求的结果是一致的。**\n\n简单说，就是多次调用如一次。\n\n> 什么是幂等性问题？\n\n在系统的运行中，可能会出现这样的问题：\n\n1. 用户在填写某些`form表单`时，保存按钮不小心快速点了两次，表中竟然产生了两条重复的数据，只是 id 不一样。\n2. 开发人员在项目中为了解决`接口超时`问题，通常会引入了`重试机制`。第一次请求接口超时了，请求方没能及时获取返回结果（此时有可能已经成功了），于是会对该请求重试几次，这样也会产生重复的数据。\n3. mq 消费者在读取消息时，有时候会读取到`重复消息`，也会产生重复的数据。\n\n这些都是常见的幂等性问题。\n\n在分布式系统里，只要下游服务有写（保存、更新）的操作，都有可能会产生幂等性问题。\n\nPS:幂等和防重有些不同，防重强调的防止数据重复，幂等强调的是多次调用如一次，防重包含幂等。"
+ },
+ {
+ "id": 552,
+ "question": "怎么保证接口幂等性？",
+ "answer": "\n\n1. insert 前先 select\n\n在保存数据的接口中，在`insert`前，先根据`requestId`等字段先`select`一下数据。如果该数据已存在，则直接返回，如果不存在，才执行 `insert`操作。\n\n2. 加唯一索引\n\n加唯一索引是个非常简单但很有效的办法，如果重复插入数据的话，就会抛出异常，为了保证幂等性，一般需要捕获这个异常。\n\n如果是`java`程序需要捕获：`DuplicateKeyException`异常，如果使用了`spring`框架还需要捕获：`MySQLIntegrityConstraintViolationException`异常。\n\n3. 加悲观锁\n\n更新逻辑，比如更新用户账户余额，可以加悲观锁，把对应用户的哪一行数据锁住。同一时刻只允许一个请求获得锁，其他请求则等待。\n\n\n```text\nselect * from user id=123 for update;\n```\n\n\n这种方式有一个缺点，获取不到锁的请求一般只能报失败，比较难保证接口返回相同值。\n\n4. 加乐观锁\n\n更新逻辑，也可以用乐观锁，性能更好。可以在表中增加一个`timestamp`或者`version`字段，例如`version`:\n\n在更新前，先查询一下数据，将 version 也作为更新的条件，同时也更新 version：\n\n\n```text\nupdate user set amount=amount+100,version=version+1 where id=123 and version=1;\n```\n\n\n更新成功后，version 增加，重复更新请求进来就无法更新了。\n\n5. 建防重表\n\n有时候表中并非所有的场景都不允许产生重复的数据，只有某些特定场景才不允许。这时候，就可以使用防重表的方式。\n\n例如消息消费中，创建防重表，存储消息的唯一 ID，消费时先去查询是否已经消费，已经消费直接返回成功。\n\n6. 状态机\n\n有些业务表是有状态的，比如订单表中有：1-下单、2-已支付、3-完成、4-撤销等状态，可以通过限制状态的流动来完成幂等。\n\n7. 分布式锁\n\n直接在数据库上加锁的做法性能不够友好，可以使用分布式锁的方式，目前最流行的分布式锁实现是通过 Redis，具体实现一般都是使用 Redission 框架。\n\n8. token 机制\n\n请求接口之前，需要先获取一个唯一的 token，再带着这个 token 去完成业务操作，服务端根据这个 token 是否存在，来判断是否是重复的请求。"
+ }
+ ]
+ },
+ {
+ "id": 83,
+ "categoryName": "分布式限流",
+ "questions": [
+ {
+ "id": 553,
+ "question": "你了解哪些限流算法？",
+ "answer": "* 计数器\n\n计数器比较简单粗暴，比如我们要限制 1s 能够通过的请求数，实现的思路就是从第一个请求进来开始计时，在接下来的 1s 内，每个请求进来请求数就+1，超过最大请求数的请求会被拒绝，等到 1s 结束后计数清零，重新开始计数。\n\n这种方式有个很大的弊端：比如前 10ms 已经通过了最大的请求数，那么后面的 990ms 的请求只能拒绝，这种现象叫做“突刺现象”。\n\n* 漏桶算法\n\n就是桶底出水的速度恒定，进水的速度可能快慢不一，但是当进水量大于出水量的时候，水会被装在桶里，不会直接被丢弃；但是桶也是有容量限制的，当桶装满水后溢出的部分还是会被丢弃的。\n\n**算法实现**：可以准备一个队列来保存暂时处理不了的请求，然后通过一个线程池定期从队列中获取请求来执行。\n\n\n\n* 令牌桶算法\n\n令牌桶就是生产访问令牌的一个地方，生产的速度恒定，用户访问的时候当桶中有令牌时就可以访问，否则将触发限流。\n\n**实现方案**：Guava RateLimiter 限流\n\nGuava RateLimiter 是一个谷歌提供的限流，其基于令牌桶算法，比较适用于单实例的系统。\n\n\n\n这一期的分布式面试题就整理到这里了，主要是偏理论的一些问题，分布式其实是个很大的类型，比如分布式调用、分布式治理……\n\n所以，这篇文章只是个开始，后面还会有分布式调用（RPC）、微服务相关的主题文章，敬请期待。\n\n> 图文详解 12 道分布式面试高频题，这次面试，一定吊打面试官，整理：练习伴侣二，戳[转载链接](https://mp.weixin.qq.com/s/nLwHEmVGtl-2FDugMqYs3A)，作者：三分恶，戳[原文链接](https://mp.weixin.qq.com/s/d84tWIjbcGKhwUptzkO2hQ)。\n\n---\n\n*没有什么使我停留——除了目的，纵然岸旁有玫瑰、有绿荫、有宁静的港湾，我是不系之舟*。\n\n**系列内容**：\n\n\n\n---"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 13,
+ "topicName": "微服务",
+ "categories": [
+ {
+ "id": 84,
+ "categoryName": "概览",
+ "questions": [
+ {
+ "id": 554,
+ "question": "什么是微服务？",
+ "answer": "微服务（Microservices）是一种软件架构风格，将一个大型应用程序划分为一组小型、自治且松耦合的服务。每个微服务负责执行特定的业务功能，并通过轻量级通信机制（如 HTTP）相互协作。每个微服务可以独立开发、部署和扩展，使得应用程序更加灵活、可伸缩和可维护。\n\n在微服务的架构演进中，一般可能会存在这样的演进方向：单体式-->服务化-->微服务。\n\n单体服务一般是所有项目最开始的样子：\n\n* 单体服务（Monolithic Service）是一种传统的软件架构方式，将整个应用程序作为一个单一的、紧耦合的单元进行开发和部署。单体服务通常由多个模块组成，这些模块共享同一个数据库和代码库。然而，随着应用程序规模的增长，单体服务可能变得庞大且难以维护，且部署和扩展困难。\n\n后来，单体服务过大，维护困难，渐渐演变到了分布式的 SOA：\n\n* SOA（Service-Oriented Architecture，面向服务的架构）是一种软件架构设计原则，强调将应用程序拆分为相互独立的服务，通过标准化的接口进行通信。SOA 关注于服务的重用性和组合性，但并没有具体规定服务的大小。\n* 微服务是在 SOA 的基础上进一步发展而来，是一种特定规模下的服务拆分和部署方式。微服务架构强调将应用程序拆分为小型、自治且松耦合的服务，每个服务都专注于特定的业务功能。这种架构使得应用程序更加灵活、可伸缩和可维护。\n\n需要注意的是，微服务是一种特定的架构风格，而 SOA 是一种设计原则。微服务可以看作是对 SOA 思想的一种具体实践方式，但并不等同于 SOA。\n\n\n\n微服务与单体服务的区别在于规模和部署方式。微服务将应用程序拆分为更小的、自治的服务单元，每个服务都有自己的数据库和代码库，可以独立开发、测试、部署和扩展，带来了更大的灵活性、可维护性、可扩展性和容错性。"
+ },
+ {
+ "id": 555,
+ "question": "微服务带来了哪些挑战？",
+ "answer": "微服务架构不是万金油，尽它有很多优点，但是对于是否采用微服务架构，是否将原来的单体服务进行拆分，还是要考虑到服务拆分后可能带来的一些挑战和问题：\n\n\n\n1. 系统复杂性增加：一个服务拆成了多个服务，整体系统的复杂性增加，需要处理服务之间的通信、部署、监控和维护等方面的复杂性。\n2. 服务间通信开销：微服务之间通过网络进行通信，传递数据需要额外的网络开销和序列化开销，可能导致性能瓶颈和增加系统延迟。\n3. 数据一致性和事务管理：每个微服务都有自己的数据存储，数据一致性和跨服务的事务管理变得更加复杂，需要额外解决分布式事务和数据同步的问题。\n4. 部署和运维复杂性：微服务架构涉及多个独立部署的服务，对于部署、监控和容错机制的要求更高，需要建立适当的部署管道和自动化工具，以简化部署和运维过程。\n5. 团队沟通和协作成本：每个微服务都由专门的团队负责，可能增加团队之间的沟通和协作成本。需要有效的沟通渠道和协作机制，确保服务之间的协调和一致性。\n6. 服务治理和版本管理：随着微服务数量的增加，服务的治理和版本管理变得更加复杂。需要考虑服务的注册发现、负载均衡、监控和故障处理等方面，以确保整个系统的可靠性和稳定性。\n7. 分布式系统的复杂性：微服务架构涉及构建和管理分布式系统，而分布式系统本身具有一些固有的挑战，如网络延迟、分布式一致性和容错性。\n\n简单说，采用微服务需要权衡这些问题和挑战，根据实际的需求来选择对应的技术方案，很多时候单体能搞定的也可以用单体，不能为了微服务而微服务。"
+ },
+ {
+ "id": 556,
+ "question": "现在有哪些流行的微服务解决方案？",
+ "answer": "目前最主流的微服务开源解决方案有三种：\n\n1. Dubbo：\n\n\n\n* Dubbo 是一个高性能、轻量级的 Java 微服务框架，最初由阿里巴巴（Alibaba）开发并于 2011 年开源。它提供了服务注册与发现、负载均衡、容错、分布式调用等功能，后来一度停止维护，在近两年，又重新开始迭代，并推出了 Dubbo3。\n* Dubbo 使用基于 RPC（Remote Procedure Call）的通信模型，具有较高的性能和可扩展性。它支持多种传输协议（如 TCP、HTTP、Redis）和序列化方式（如 JSON、Hessian、Protobuf），可根据需求进行配置。\n* Dubbo 更多地被认为是一个高性能的 RPC（远程过程调用）框架，一些服务治理功能依赖于第三方组件实现，比如使用 ZooKeeper、Apollo 等等。\n\n3. Spring Cloud Netflix：\n\n* Spring Cloud Netflix 是 Spring Cloud 的一个子项目，结合了 Netflix 开源的多个组件，但是 Netflix 自 2018 年停止维护和更新 Netflix OSS 项目，包括 Eureka、Hystrix 等组件，所以 Spring Cloud Netflix 也逐渐进入了维护模式。\n* 该项目包含了许多流行的 Netflix 组件，如 Eureka（服务注册与发现）、Ribbon（客户端负载均衡）、Hystrix（断路器）、Zuul（API 网关）等。它们都是高度可扩展的、经过大规模实践验证的微服务组件。\n\n5. Spring Cloud Alibaba：\n\n#### [这三种方案有什么区别吗？](#这三种方案有什么区别吗)\n\n三种方案的区别：\n\n| 特点 | Dubbo | Spring Cloud Netflix | Spring Cloud Alibaba |\n| --- | --- | --- | --- |\n| 开发语言 | Java | Java | Java |\n| 服务治理 | 提供完整的服务治理功能 | 提供部分服务治理功能 | 提供完整的服务治理功能 |\n| 服务注册与发现 | ZooKeeper/Nacos | Eureka/Consul | Nacos |\n| 负载均衡 | 自带负载均衡策略 | Ribbon | Ribbon\\Dubbo 负载均衡策略 |\n| 服务调用 | RPC 方式 | RestTemplate/Feign | Feign/RestTemplate/Dubbo |\n| 熔断器 | Sentinel | Hystrix | Sentinel/Resilience4j |\n| 配置中心 | Apollo | Spring Cloud Config | Nacos Config |\n| API 网关 | Higress/APISIX | Zuul/Gateway | Spring Cloud Gateway |\n| 分布式事务 | Seata | 不支持分布式事务 | Seata |\n| 限流和降级 | Sentinel | Hystrix | Sentinel |\n| 分布式追踪和监控 | Skywalking | Spring Cloud Sleuth + Zipkin | SkyWalking 或 Sentinel Dashboard |\n| 微服务网格 | Dubbo Mesh | 不支持微服务网格 | Service Mesh（Nacos+Dubbo Mesh） |\n| 社区活跃度 | 相对较高 | 目前较低 | 相对较高 |\n| 孵化和成熟度 | 孵化较早，成熟度较高 | 成熟度较高 | 孵化较新，但迅速发展 |\n\n* Spring Cloud Alibaba 是 Spring Cloud 的另一个子项目，与阿里巴巴的分布式应用开发框架相关。它提供了一整套与 Alibaba 生态系统集成的解决方案。\n* 该项目包括 Nacos（服务注册与发现、配置管理）、Sentinel（流量控制、熔断降级）、RocketMQ（消息队列）等组件，以及与 Alibaba Cloud（阿里云）的集成。它为构建基于 Spring Cloud 的微服务架构提供了丰富的选项。\n* 据说 SpringCloud Alibaba 项目的发起人已经跑路去了腾讯，并发起了 SpringCloud Tecent 项目，社区发展存在隐忧。\n\n> 在面试中，微服务一般主要讨论的是 Spring Cloud Netflix，其次是 Spring Cloud Alibaba，Dubbo 更多的是作为一个 RPC 框架来问。"
+ },
+ {
+ "id": 557,
+ "question": "说下微服务有哪些组件？",
+ "answer": "微服务给系统开发带来了一些问题和挑战，如服务调用的复杂性、分布式事务的处理、服务的动态管理等。为了更好地解决这些问题和挑战，各种微服务治理的组件应运而生，充当微服务架构的基石和支撑。\n\n\n\n微服务的各个组件和常见实现：\n\n1. 注册中心：用于服务的注册与发现，管理微服务的地址信息。常见的实现包括：\n\n* Spring Cloud Netflix：Eureka、Consul\n* Spring Cloud Alibaba：Nacos\n\n3. 配置中心：用于集中管理微服务的配置信息，可以动态修改配置而不需要重启服务。常见的实现包括：\n\n* Spring Cloud Netflix：Spring Cloud Config\n* Spring Cloud Alibaba：Nacos Config\n\n5. 远程调用：用于在不同的微服务之间进行通信和协作。常见的实现保包括：\n\n* RESTful API：如 RestTemplate、Feign\n* RPC（远程过程调用）：如 Dubbo、gRPC\n\n7. API 网关：作为微服务架构的入口，统一暴露服务，并提供路由、负载均衡、安全认证等功能。常见的实现包括：\n\n* Spring Cloud Netflix：Zuul、Gateway\n* Spring Cloud Alibaba：Gateway、Apisix 等\n\n9. 分布式事务：保证跨多个微服务的一致性和原子性操作。常见的实现包括：\n\n* Spring Cloud Alibaba：Seata\n\n11. 熔断器：用于防止微服务之间的故障扩散，提高系统的容错能力。常见的实现包括：\n\n* Spring Cloud Netflix：Hystrix\n* Spring Cloud Alibaba：Sentinel、Resilience4j\n\n13. 限流和降级：用于防止微服务过载，对请求进行限制和降级处理。常见的实现包括：\n\n* Spring Cloud Netflix：Hystrix\n* Spring Cloud Alibaba：Sentinel\n\n15. 分布式追踪和监控：用于跟踪和监控微服务的请求流程和性能指标。常见的实现包括：\n\n* Spring Cloud Netflix：Spring Cloud Sleuth + Zipkin\n* Spring Cloud Alibaba：SkyWalking、Sentinel Dashboard"
+ }
+ ]
+ },
+ {
+ "id": 85,
+ "categoryName": "注册中心",
+ "questions": [
+ {
+ "id": 558,
+ "question": "注册中心是用来干什么的？",
+ "answer": "注册中心是用来管理和维护分布式系统中各个服务的地址和元数据的组件。它主要用于实现`服务发现`和`服务注册`功能。\n\n\n\n总结一下注册中心的作用：\n\n1. **服务注册**：各个服务在启动时向注册中心注册自己的网络地址、服务实例信息和其他相关元数据。这样，其他服务就可以通过注册中心获取到当前可用的服务列表。\n2. **服务发现**：客户端通过向注册中心查询特定服务的注册信息，获得可用的服务实例列表。这样客户端就可以根据需要选择合适的服务进行调用，实现了服务间的解耦。\n3. **负载均衡**：注册中心可以对同一服务的多个实例进行负载均衡，将请求分发到不同的实例上，提高整体的系统性能和可用性。\n4. **故障恢复**：注册中心能够监测和检测服务的状态，当服务实例发生故障或下线时，可以及时更新注册信息，从而保证服务能够正常工作。\n5. **服务治理**：通过注册中心可以进行服务的配置管理、动态扩缩容、服务路由、灰度发布等操作，实现对服务的动态管理和控制。"
+ },
+ {
+ "id": 559,
+ "question": "SpringCloud 可以选择哪些注册中心？",
+ "answer": "SpringCloud 可以与多种注册中心进行集成，常见的注册中心包括：\n\n1. Eureka：Eureka 是 Netflix 开源的服务发现框架，具有高可用、弹性、可扩展等特点，并与 Spring Cloud 集成良好。\n2. Consul：Consul 是一种分布式服务发现和配置管理系统，由 HashiCorp 开发。它提供了服务注册、服务发现、健康检查、键值存储等功能，并支持多数据中心部署。\n3. ZooKeeper：ZooKeeper 是 Apache 基金会开源的分布式协调服务，可以用作服务注册中心。它具有高可用、一致性、可靠性等特点。\n4. Nacos：Nacos 是阿里巴巴开源的一个动态服务发现、配置管理和服务管理平台。它提供了服务注册和发现、配置管理、动态 DNS 服务等功能。\n5. etcd：etcd 是 CoreOS 开源的一种分布式键值存储系统，可以被用作服务注册中心。它具有高可用、强一致性、分布式复制等特性。"
+ },
+ {
+ "id": 560,
+ "question": "说下 Eureka、ZooKeeper、Nacos 的区别？",
+ "answer": "| 特性 | Eureka | ZooKeeper | Nacos |\n| --- | --- | --- | --- |\n| 开发公司 | Netflix | Apache 基金会 | 阿里巴巴 |\n| CAP | AP（可用性和分区容忍性） | CP（一致性和分区容忍性） | 既支持 AP，也支持 CP |\n| 功能 | 服务注册与发现 | 分布式协调、配置管理、分布式锁 | 服务注册与发现、配置管理、服务管理 |\n| 定位 | 适用于构建基于 HTTP 的微服务架构 | 通用的分布式协调服务框架 | 适用于微服务和云原生应用 |\n| 访问协议 | HTTP | TCP | HTTP/DNS |\n| 自我保护 | 支持 | - | 支持 |\n| 数据存储 | 内嵌数据库、多个实例形成集群 | ACID 特性的分布式文件系统 ZAB 协议 | 内嵌数据库、MySQL 等 |\n| 健康检查 | Client Beat | Keep Alive | TCP/HTTP/MYSQL/Client Beat |\n| 特点 | 简单易用、自我保护机制 | 高性能、强一致性 | 动态配置管理、流量管理、灰度发布等 |\n\n可以看到 Eureka 和 ZooKeeper 的最大区别是一个支持`AP`，一个支持`CP`，Nacos 既支持既支持`AP`，也支持`CP`。"
+ },
+ {
+ "id": 561,
+ "question": "Eureka 实现原理了解吗？",
+ "answer": "\n\nEureka 的实现原理，大概可以从这几个方面来看：\n\n1. 服务注册与发现: 当一个服务实例启动时，它会向 Eureka Server 发送注册请求，将自己的信息注册到注册中心。Eureka Server 会将这些信息保存在内存中，并提供 REST 接口供其他服务查询。服务消费者可以通过查询服务实例列表来获取可用的服务提供者实例，从而实现服务的发现。\n2. 服务健康检查: Eureka 通过心跳机制来检测服务实例的健康状态。服务实例会定期向 Eureka Server 发送心跳，也就是续约，以表明自己的存活状态。如果 Eureka Server 在一定时间内没有收到某个服务实例的心跳，则会将其标记为不可用，并从服务列表中移除，下线实例。\n3. 服务负载均衡: Eureka 客户端在调用其他服务时，会从本地缓存中获取服务的注册信息。如果缓存中没有对应的信息，则会向 Eureka Server 发送查询请求。Eureka Server 会返回一个可用的服务实例列表给客户端，客户端可以使用负载均衡算法选择其中一个进行调用。\n\n> 其它的注册中心，如 Nacos、Consul 等等，在服务注册和发现上，实现原理都是大同小异。"
+ },
+ {
+ "id": 562,
+ "question": "Eureka Server 怎么保证高可用？",
+ "answer": "Eureka Server 保证高可用，主要通过这三个方面来实现：\n\n\n\n1. 多实例部署: 通过将多个 Eureka Server 实例部署在不同的节点上，可以实现高可用性。当其中一个实例发生故障时，其他实例仍然可以提供服务，并保持注册信息的一致性。\n2. 服务注册信息的复制: 当一个服务实例向 Eureka Server 注册时，每个 Eureka Server 实例都会复制其他实例的注册信息，以保持数据的一致性。当某个 Eureka Server 实例发生故障时，其他实例可以接管其工作，保证整个系统的正常运行。\n3. 自我保护机制: Eureka 还具有自我保护机制。当 Eureka Server 节点在一定时间内没有接收到心跳时，它会进入自我保护模式。在自我保护模式下，Eureka Server 不再剔除注册表中的服务实例，以保护现有的注册信息。这样可以防止由于网络抖动或其他原因导致的误剔除，进一步提高系统的稳定性。"
+ }
+ ]
+ },
+ {
+ "id": 86,
+ "categoryName": "配置中心",
+ "questions": [
+ {
+ "id": 563,
+ "question": "为什么微服务需要配置中心？",
+ "answer": "微服务架构中的每个服务通常都需要一些配置信息，例如数据库连接地址、服务端口、日志级别等。这些配置可能因为不同环境、不同部署实例或者动态运行时需要进行调整和管理。\n\n微服务的实例一般非常多，如果每个实例都需要一个个地去做这些配置，那么运维成本将会非常大，这时候就需要一个集中化的配置中心，去管理这些配置。"
+ },
+ {
+ "id": 564,
+ "question": "SpringCloud 可以选择哪些配置中心？",
+ "answer": "和注册中心一样，SpringCloud 也支持对多种配置中心的集成。常见的配置中心选型包括：\n\n1. Spring Cloud Config：官方推荐的配置中心，支持将配置文件存储在 Git、SVN 等版本控制系统中，并提供 RESTful API 进行访问和管理。\n2. ZooKeeper：一个开源的分布式协调服务，可以用作配置中心。它具有高可用性、一致性和通知机制等特性。\n3. Consul：另一个开源的分布式服务发现和配置管理工具，也可用作配置中心。支持多种配置文件格式，提供健康检查、故障转移和动态变更等功能。\n4. Etcd：一个分布式键值存储系统，可用作配置中心。它使用基于 Raft 算法的一致性机制，提供分布式数据一致性保证。\n5. Apollo：携程开源的配置中心，支持多种语言和框架。提供细粒度的配置权限管理、配置变更通知和灰度发布等高级特性，还有可视化的配置管理界面。\n6. Nacos：阿里巴巴开源的服务发现、配置管理和服务管理平台，也可以作为配置中心使用。支持服务注册与发现、动态配置管理、服务健康监测和动态 DNS 服务等功能。"
+ },
+ {
+ "id": 565,
+ "question": "Nacos 配置中心的原理了解吗？",
+ "answer": "配置中心，说白了就是一句话：配置信息的 CRUD。\n\n\n\n具体的实现大概可以分成这么几个部分：\n\n1. 配置信息存储：Nacos 默认使用内嵌数据库 Derby 来存储配置信息，还可以采用 MySQL 等关系型数据库。\n2. 注册配置信息：服务启动时，Nacos Client 会向 Nacos Server 注册自己的配置信息，这个注册过程就是把配置信息写入存储，并生成版本号。\n3. 获取配置信息：服务运行期间，Nacos Client 通过 API 从 Nacos Server 获取配置信息。Server 根据键查找对应的配置信息，并返回给 Client。\n4. 监听配置变化：Nacos Client 可以通过注册监听器的方式，实现对配置信息的监听。当配置信息发生变化时，Nacos Server 会通知已注册的监听器，并触发相应的回调方法。"
+ },
+ {
+ "id": 566,
+ "question": "Nacos 配置中心长轮询机制？",
+ "answer": "一般来说客户端和服务端的交互分为两种：`推（Push）`和`拉（Pull）`，Nacos 在`Pull`的基础上，采用了长轮询来进行配置的动态刷新。\n\n在长轮询模式下，客户端定时向服务端发起请求，检查配置信息是否发生变更。如果没有变更，服务端会\"hold\"住这个请求，即暂时不返回结果，直到配置发生变化或达到一定的超时时间。\n\n具体的实现过程如下：\n\n\n\n1. 客户端发起 Pull 请求，服务端检查配置是否有变更。如果没有变更，则设置一个定时任务，在一段时间后执行，并将当前的客户端连接加入到等待队列中。\n2. 在等待期间，如果配置发生变更，服务端会立即返回结果给客户端，完成一次\"推送\"操作。\n3. 如果在等待期间没有配置变更，等待时间达到预设的超时时间后，服务端会自动返回结果给客户端，即使配置没有变更。\n4. 如果在等待期间，通过 Nacos Dashboard 或 API 对配置进行了修改，会触发一个事件机制，服务端会遍历等待队列，找到发生变更的配置项对应的客户端连接，并将变更的数据通过连接返回，完成一次\"推送\"操作。\n\n通过长轮询的方式，Nacos 客户端能够实时感知配置的变化，并及时获取最新的配置信息。同时，这种方式也降低了服务端的压力，避免了大量的长连接占用内存资源。"
+ }
+ ]
+ },
+ {
+ "id": 87,
+ "categoryName": "远程调用",
+ "questions": [
+ {
+ "id": 567,
+ "question": "能说下 HTTP 和 RPC 的区别吗？",
+ "answer": "HTTP 和 RPC 不算是一个层面上的东西：\n\n\n\nHTTP 是应用层协议，用于传输超文本数据，基于请求-响应模型，常用于 Web 开发、API 调用等场景。\n\nRPC 是远程过程调用协议，用于实现分布式系统中不同节点之间的通信，基于方法调用模型，常用于构建面向服务的微服务架构。\n\n在微服务架构中，Feign 和 Dubbo 都是用于实现远程调用的框架，Feign 基于 HTTP 协议，Dubbo 基于 RPC 协议。\n\n如果硬要说区别的话，如下：\n\n| - | HTTP | RPC |\n| --- | --- | --- |\n| 定义 | HTTP（超文本传输协议）是一种用于传输超文本的协议。 | RPC（远程过程调用）是一种用于实现分布式系统中不同节点之间通信的协议。 |\n| 通信方式 | 基于请求-响应模型，客户端发送请求，服务器返回响应。 | 基于方法调用模型，客户端调用远程方法并等待结果。 |\n| 传输协议 | 基于 TCP 协议，可使用其他传输层协议如 TLS/SSL 进行安全加密。 | 可以使用多种传输协议，如 TCP、UDP 等。 |\n| 数据格式 | 基于文本，常用的数据格式有 JSON、XML 等。 | 可以使用各种数据格式，如二进制、JSON、Protocol Buffers 等。 |\n| 接口定义 | 使用 RESTful 风格的接口进行定义，常用的方法有 GET、POST、PUT、DELETE 等。 | 使用 IDL（接口定义语言）进行接口定义，如 Protocol Buffers、Thrift 等。 |\n| 跨语言性 | 支持跨语言通信，可以使用 HTTP 作为通信协议实现不同语言之间的通信。 | 支持跨语言通信，可以使用 IDL 生成不同语言的客户端和服务端代码。 |\n| 灵活性 | 更加灵活，适用于不同类型的应用场景，如 Web 开发、API 调用等。 | 更加高效，适用于需要高性能和低延迟的分布式系统。 |\n\n#### [RPC了解吗？](#rpc了解吗)\n\nRPC（Remote Procedure Call）是一种远程过程调用协议，用于实现分布式系统中不同节点之间的通信。它基于方法调用模型，允许客户端调用远程服务的方法，并等待结果返回。\n\n像 gRPC、Dubbo、Thrift 等都是 RPC 框架，它们提供了 IDL（接口定义语言）来定义服务接口，以及序列化协议来进行数据传输。"
+ },
+ {
+ "id": 568,
+ "question": "那 Feign 和 Dubbo 的区别呢？",
+ "answer": "这两个才是适合拿来比较的东西：\n\n| - | Feign | Dubbo |\n| --- | --- | --- |\n| 定义 | Feign 是一个声明式的 Web 服务客户端，用于简化 HTTP API 的调用。 | Dubbo 是一个分布式服务框架，用于构建面向服务的微服务架构。 |\n| 通信方式 | 基于 HTTP 协议，使用 RESTful 风格的接口进行定义和调用。 | 基于 RPC 协议，支持多种序列化协议如 gRPC、Hessian 等。 |\n| 服务发现 | 通常结合服务注册中心（如 Eureka、Consul）进行服务发现和负载均衡。 | 通过 ZooKeeper、Nacos 等进行服务注册和发现，并提供负载均衡功能。 |\n| 服务治理 | 不直接提供服务治理功能，需要结合其他组件或框架进行服务治理。 | 提供服务注册与发现、负载均衡、容错机制、服务降级等服务治理功能。 |\n| 跨语言性 | 支持跨语言通信，可以使用 HTTP 作为通信协议实现不同语言之间的通信。 | 支持跨语言通信，通过 Dubbo 的 IDL 生成不同语言的客户端和服务端代码。 |\n| 生态系统 | 集成了 Spring Cloud 生态系统，与 Spring Boot 无缝集成。 | 拥有完整的生态系统，包括注册中心、配置中心、监控中心等组件。 |\n| 适用场景 | 适用于构建 RESTful 风格的微服务架构，特别适合基于 HTTP 的微服务调用。 | 适用于构建面向服务的微服务架构，提供更全面的服务治理和容错机制。 |\n\n需要注意的是，Feign 和 Dubbo 并不是互斥的关系。实际上，Dubbo 可以使用 HTTP 协议作为通信方式，而 Feign 也可以集成 RPC 协议进行远程调用。选择使用哪种远程调用方式取决于具体的业务需求和技术栈的选择。"
+ },
+ {
+ "id": 569,
+ "question": "说一下 Fegin?",
+ "answer": "Feign 是一个声明式的 Web 服务客户端，它简化了使用基于 HTTP 的远程服务的开发。\n\nFeign 是在 RestTemplate 和 Ribbon 的基础上进一步封装，使用 RestTemplate 实现 Http 调用，使用 Ribbon 实现负载均衡。\n\n\n\nFeign 的主要特点和功能包括：\n\n1. 声明式 API：Feign 允许开发者使用简单的注解来定义和描述对远程服务的访问。通过使用注解，开发者可以轻松地指定 URL、HTTP 方法、请求参数、请求头等信息，使得远程调用变得非常直观和易于理解。\n\n\n```text\n@FeignClient(name = \"example\", url = \"https://api.example.com\")\n public interface ExampleService {\n @GetMapping(\"/endpoint\")\n String getEndpointData();\n }\n```\n\n\n2. 集成负载均衡：Feign 集成了 Ribbon 负载均衡器，可以自动实现客户端的负载均衡。它可以根据服务名和可用实例进行动态路由，并分发请求到不同的服务实例上，提高系统的可用性和可伸缩性。\n3. 容错机制：Feign 支持集成 Hystrix 容错框架，可以在调用远程服务时提供容错和断路器功能。当远程服务不可用或响应时间过长时，Feign 可以快速失败并返回预设的响应结果，避免对整个系统造成级联故障。"
+ },
+ {
+ "id": 570,
+ "question": "为什么 Feign 第一次调用耗时很长？",
+ "answer": "主要原因是由于 Ribbon 的懒加载机制，当第一次调用发生时，Feign 会触发 Ribbon 的加载过程，包括从服务注册中心获取服务列表、建立连接池等操作，这个加载过程会增加首次调用的耗时。\n\n\n```text\nribbon:\n eager-load:\n enabled: true\n clients: service-1\n```\n\n\n那怎么解决这个问题呢？\n\n可以在应用启动时预热 Feign 客户端，自动触发一次无关紧要的调用，来提前加载 Ribbon 和其他相关组件。这样，就相当于提前进行了第一次调用。"
+ },
+ {
+ "id": 571,
+ "question": "Feign 怎么实现认证传递？",
+ "answer": "比较常见的一个做法是，`使用拦截器传递认证信息`。可以通过实现`RequestInterceptor`接口来定义拦截器，在拦截器里，把认证信息添加到请求头中，然后将其注册到 Feign 的配置中。\n\n\n```text\n@Configuration\n public class FeignClientConfig {\n\n @Bean\n public RequestInterceptor requestInterceptor() {\n return new RequestInterceptor() {\n @Override\n public void apply(RequestTemplate template) {\n // 添加认证信息到请求头中\n template.header(\"Authorization\", \"Bearer \" + getToken());\n }\n };\n }\n\n private String getToken() {\n // 获取认证信息的逻辑，可以从SecurityContext或其他地方获取\n // 返回认证信息的字符串形式\n return \"your_token\";\n }\n }\n```"
+ },
+ {
+ "id": 572,
+ "question": "Fegin 怎么做负载均衡？Ribbon?",
+ "answer": "在 Feign 中，负载均衡是通过集成 Ribbon 来实现的。\n\nRibbon 是 Netflix 开源的一个客户端负载均衡器，可以与 Feign 无缝集成，为 Feign 提供负载均衡的能力。\n\nRibbon 通过从服务注册中心获取可用服务列表，并通过负载均衡算法选择合适的服务实例进行请求转发，实现客户端的负载均衡。\n\n"
+ },
+ {
+ "id": 573,
+ "question": "说说有哪些负载均衡算法？",
+ "answer": "常见的负载均衡算法包含以下几种：\n\n\n\n1. **轮询算法（Round Robin）**：轮询算法是最简单的负载均衡算法之一。它按照顺序将请求依次分配给每个后端服务器，循环往复。当请求到达时，负载均衡器按照事先定义的顺序选择下一个服务器。轮询算法适用于后端服务器具有相同的处理能力和性能的场景。\n2. **加权轮询算法（Weighted Round Robin）**：加权轮询算法在轮询算法的基础上增加了权重的概念。每个后端服务器都被赋予一个权重值，权重值越高，被选中的概率就越大。这样可以根据服务器的处理能力和性能调整请求的分配比例，使得性能较高的服务器能够处理更多的请求。\n3. **随机算法（Random）**：随机算法将请求随机分配给后端服务器。每个后端服务器有相等的被选中概率，没有考虑服务器的实际负载情况。这种算法简单快速，适用于后端服务器性能相近且无需考虑请求处理能力的场景。\n4. **加权随机算法（Weighted Random）**：加权随机算法在随机算法的基础上引入了权重的概念。每个后端服务器被赋予一个权重值，权重值越高，被选中的概率就越大。这样可以根据服务器的处理能力和性能调整请求的分配比例。\n5. **最少连接算法（Least Connection）**：最少连接算法会根据后端服务器当前的连接数来决定请求的分配。负载均衡器会选择当前连接数最少的服务器进行请求分配，以保证后端服务器的负载均衡。这种算法适用于后端服务器的处理能力不同或者请求的处理时间不同的场景。\n6. **哈希算法（Hash）**：哈希算法会根据请求的某个特定属性（如客户端 IP 地址、请求 URL 等）计算哈希值，然后根据哈希值选择相应的后端服务器。\n\n常见的负载均衡器，比如 Ribbion、Gateway 等等，基本都支持这些负载均衡算法。\n\n> 关于 Dubbo，后面会单独出一期。"
+ }
+ ]
+ },
+ {
+ "id": 88,
+ "categoryName": "服务容灾",
+ "questions": [
+ {
+ "id": 574,
+ "question": "什么是服务雪崩？",
+ "answer": "在微服务中，假如一个或者多个服务出现故障，如果这时候，依赖的服务还在不断发起请求，或者重试，那么这些请求的压力会不断在下游堆积，导致下游服务的负载急剧增加。不断累计之下，可能会导致故障的进一步加剧，可能会导致级联式的失败，甚至导致整个系统崩溃，这就叫服务雪崩。\n\n\n\n一般，为了防止服务雪崩，可以采用这些措施：\n\n1. 服务高可用部署：确保各个服务都具备高可用性，通过冗余部署、故障转移等方式来减少单点故障的影响。\n2. 限流和熔断：对服务之间的请求进行限流和熔断，以防止过多的请求涌入导致后端服务不可用。\n3. 缓存和降级：合理使用缓存来减轻后端服务的负载压力，并在必要时进行服务降级，保证核心功能的可用性。"
+ },
+ {
+ "id": 575,
+ "question": "什么是服务熔断？什么是服务降级？",
+ "answer": "#### [什么是服务熔断？](#什么是服务熔断)\n\n服务熔断是微服务架构中的容错机制，用于保护系统免受服务故障或异常的影响。当某个服务出现故障或异常时，服务熔断可以快速隔离该服务，确保系统稳定可用。\n\n它通过监控服务的调用情况，当错误率或响应时间超过阈值时，触发熔断机制，后续请求将返回默认值或错误信息，避免资源浪费和系统崩溃。\n\n服务熔断还支持自动恢复，重新尝试对故障服务的请求，确保服务恢复正常后继续使用。\n\n#### [什么是服务降级？](#什么是服务降级)\n\n服务降级是也是一种微服务架构中的容错机制，用于在系统资源紧张或服务故障时保证核心功能的可用性。\n\n当系统出现异常情况时，服务降级会主动屏蔽一些非核心或可选的功能，而只提供最基本的功能，以确保系统的稳定运行。通过减少对资源的依赖，服务降级可以保证系统的可用性和性能。\n\n它可以根据业务需求和系统状况来制定策略，例如替换耗时操作、返回默认响应、返回静态错误页面等。\n\n#### [有哪些熔断降级方案实现？](#有哪些熔断降级方案实现)\n\n目前常见的服务熔断降级实现方案有这么几种：\n\n| 框架 | 实现方案 | 特点 |\n| --- | --- | --- |\n| Spring Cloud | Netflix Hystrix | - 提供线程隔离、服务降级、请求缓存、请求合并等功能 |\n\n- 可与 Spring Cloud 其他组件无缝集成\n\n- 官方已宣布停止维护，推荐使用 Resilience4j 代替| Spring Cloud|Resilience4j|- 轻量级服务熔断库\n\n- 提供类似于 Hystrix 的功能\n\n- 具有更好的性能和更简洁的 API\n\n- 可与 Spring Cloud 其他组件无缝集成| Spring Cloud Alibaba|Sentinel|- 阿里巴巴开源的流量控制和熔断降级组件\n\n- 提供实时监控、流量控制、熔断降级等功能\n\n- 与 Spring Cloud Alibaba 生态系统紧密集成| Dubbo|Dubbo 自带熔断降级机制|- Dubbo 框架本身提供的熔断降级机制\n\n- 可通过配置实现服务熔断和降级\n\n- 与 Dubbo 的 RPC 框架紧密集成|"
+ },
+ {
+ "id": 576,
+ "question": "Hystrix 怎么实现服务容错？",
+ "answer": "尽管已经不再更新，但是 Hystrix 是非常经典的服务容错开源库，它提供了多种机制来保护系统：\n\n\n\n1. 服务熔断（Circuit Breaker）：Hystrix 通过设置阈值来监控服务的错误率或响应时间。当错误率或响应时间超过预设的阈值时，熔断器将会打开，后续的请求将不再发送到实际的服务提供方，而是返回预设的默认值或错误信息。这样可以快速隔离故障服务，防止故障扩散，提高系统的稳定性和可用性。\n2. 服务降级（Fallback）：当服务熔断打开时，Hystrix 可以提供一个备用的降级方法或返回默认值，以保证系统继续正常运行。开发者可以定义降级逻辑，例如返回缓存数据、执行简化的逻辑或调用其他可靠的服务，以提供有限但可用的功能。\n\n\n```text\nimport com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;\n\n /**\n\n * 服务降级示例\n\n **/\n @Service\n public class MyService {\n\n @HystrixCommand(fallbackMethod = \"fallbackMethod\")\n public String myServiceMethod() {\n // 实际的服务调用逻辑\n // ...\n }\n\n public String fallbackMethod() {\n // 降级方法的逻辑，当服务调用失败时会执行此方法\n // 可以返回默认值或执行其他备用逻辑\n // ...\n }\n }\n```\n\n\n3. 请求缓存（Request Caching）：Hystrix 可以缓存对同一请求的响应结果，当下次请求相同的数据时，直接从缓存中获取，避免重复的网络请求，提高系统的性能和响应速度。\n4. 请求合并（Request Collapsing）：Hystrix 可以将多个并发的请求合并为一个批量请求，减少网络开销和资源占用。这对于一些高并发的场景可以有效地减少请求次数，提高系统的性能。\n5. 实时监控和度量（Real-time Monitoring and Metrics）：Hystrix 提供了实时监控和度量功能，可以对服务的执行情况进行监控和统计，包括错误率、响应时间、并发量等指标。通过监控数据，可以及时发现和解决服务故障或性能问题。\n6. 线程池隔离（Thread Pool Isolation）：Hystrix 将每个依赖服务的请求都放在独立的线程池中执行，避免因某个服务的故障导致整个系统的线程资源耗尽。通过线程池隔离，可以提高系统的稳定性和可用性。"
+ },
+ {
+ "id": 577,
+ "question": "Sentinel 怎么实现限流的？",
+ "answer": "Sentinel 通过动态管理限流规则，根据定义的规则对请求进行限流控制。具体实现步骤如下：\n\n1. 定义资源：在 Sentinel 中，资源可以是 URL、方法等，用于标识需要进行限流的请求。\n\n\n```text\n// 原本的业务方法.\n @SentinelResource(blockHandler = \"blockHandlerForGetUser\")\n public User getUserById(String id) {\n throw new RuntimeException(\"getUserById command failed\");\n }\n\n // blockHandler 函数，原方法调用被限流/降级/系统保护的时候调用\n public User blockHandlerForGetUser(String id, BlockException ex) {\n return new User(\"admin\");\n }\n```\n\n\n2. 配置限流规则：在 Sentinel 的配置文件中定义资源的限流规则。规则可以包括资源名称、限流阈值、限流模式（令牌桶或漏桶）等。\n\n\n```text\nprivate static void initFlowQpsRule() {\n List rules = new ArrayList<>();\n FlowRule rule1 = new FlowRule();\n rule1.setResource(resource);\n // Set max qps to 20\n rule1.setCount(20);\n rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);\n rule1.setLimitApp(\"default\");\n rules.add(rule1);\n FlowRuleManager.loadRules(rules);\n }\n```\n\n\n3. 监控流量：Sentinel 会监控每个资源的流量情况，包括请求的 QPS（每秒请求数）、线程数、响应时间等。\n\n\n\n4. 限流控制：当请求到达时，Sentinel 会根据资源的限流规则判断是否需要进行限流控制。如果请求超过了限流阈值，则可以进行限制、拒绝或进行其他降级处理。\n\n\n\n#### [Sentinel 采用的什么限流算法？](#sentinel-采用的什么限流算法)\n\nSentinel 使用滑动窗口限流算法来实现限流。\n\n滑动窗口限流算法是一种基于时间窗口的限流算法。它将一段时间划分为多个时间窗口，并在每个时间窗口内统计请求的数量。通过动态地调整时间窗口的大小和滑动步长，可以更精确地控制请求的通过速率。\n\n> 滑动窗口限流可以查看前面的分布式篇。\n\n#### [Sentinel 怎么实现集群限流？](#sentinel-怎么实现集群限流)\n\nSentinel 利用了 Token Server 和 Token Client 的机制来实现集群限流。\n\n开启集群限流后，Client 向 Token Server 发送请求，Token Server 根据配置的规则决定是否限流。T\n\n"
+ }
+ ]
+ },
+ {
+ "id": 89,
+ "categoryName": "服务网关",
+ "questions": [
+ {
+ "id": 578,
+ "question": "什么是 API 网关？",
+ "answer": "API 网关（API Gateway）是一种中间层服务器，用于集中管理、保护和路由对后端服务的访问。它充当了客户端与后端服务之间的入口点，提供了一组统一的接口来管理和控制 API 的访问。\n\n\n\nAPI 网关的主要功能包括：\n\n1. 路由转发：API 网关根据请求的 URL 路径或其他标识，将请求路由到相应的后端服务。通过配置路由规则，可以灵活地将请求分发给不同的后端服务。\n2. 负载均衡：API 网关可以在后端服务之间实现负载均衡，将请求平均分发到多个实例上，提高系统的吞吐量和可扩展性。\n3. 安全认证与授权：API 网关可以集中处理身份验证和授权，确保只有经过身份验证的客户端才能访问后端服务。它可以与身份提供者（如 OAuth、OpenID Connect）集成，进行用户认证和授权操作。\n4. 缓存：API 网关可以缓存后端服务的响应，减少对后端服务的请求次数，提高系统性能和响应速度。\n5. 监控与日志：API 网关可以收集和记录请求的指标和日志，提供实时监控和分析，帮助开发人员和运维人员进行故障排查和性能优化。\n6. 数据转换与协议转换：API 网关可以在客户端和后端服务之间进行数据格式转换和协议转换，如将请求从 HTTP 转换为 WebSocket，或将请求的参数进行格式转换，以满足后端服务的需求。\n7. API 版本管理：API 网关可以管理不同版本的 API，允许同时存在多个 API 版本，并通过路由规则将请求正确地路由到相应的 API 版本上。\n\n……\n\n通过使用 API 网关，可以简化前端与后端服务的交互，提供统一的接口和安全性保障，同时也方便了服务治理和监控。它是构建微服务架构和实现 API 管理的重要组件之一。"
+ },
+ {
+ "id": 579,
+ "question": "SpringCloud 可以选择哪些 API 网关？",
+ "answer": "使用 SpringCloud 开发，可以采用以下的 API 网关选型：\n\n1. Netflix Zuul（已停止更新）：Netflix Zuul 是 Spring Cloud 早期版本中提供的默认 API 网关。它基于 Servlet 技术栈，可以进行路由、过滤、负载均衡等功能。然而，自 2020 年 12 月起，Netflix 宣布停止对 Zuul 1 的维护，转而支持新的 API 网关项目。\n2. Spring Cloud Gateway：Spring Cloud Gateway 是 Spring Cloud 官方推荐的 API 网关，取代了 Netflix Zuul。它基于非阻塞的 WebFlux 框架，充分利用了响应式编程的优势，并提供了路由、过滤、断路器、限流等特性。Spring Cloud Gateway 还支持与 Spring Cloud 的其他组件集成，如服务发现、负载均衡等。\n3. Kong：Kong 是一个独立的、云原生的 API 网关和服务管理平台，可以与 Spring Cloud 集成。Kong 基于 Nginx，提供了强大的路由、认证、授权、监控和扩展能力。它支持多种插件和扩展，可满足不同的 API 管理需求。\n4. APISIX：APISIX 基于 Nginx 和 Lua 开发，它具有强大的路由、流量控制、插件扩展等功能。APISIX 支持灵活的配置方式，可以根据需求进行动态路由、负载均衡和限流等操作。\n\n……"
+ },
+ {
+ "id": 580,
+ "question": "Spring Cloud Gateway 核心概念？",
+ "answer": "\n\n在 Spring Cloud Gateway 里，有三个关键组件：\n\n* **Route（路由）**：路由是 Spring Cloud Gateway 的基本构建块，它定义了请求的匹配规则和转发目标。通过配置路由，可以将请求映射到后端的服务实例或 URL 上。路由规则可以根据请求的路径、方法、请求头等条件进行匹配，并指定转发的目标 URI。\n* **Predicate（断言）**：断言用于匹配请求的条件，如果请求满足断言的条件，则会应用所配置的过滤器。Spring Cloud Gateway 提供了多种内置的断言，如 Path（路径匹配）、Method（请求方法匹配）、Header（请求头匹配）等，同时也支持自定义断言。\n* **Filter（过滤器）**：过滤器用于对请求进行处理和转换，可以修改请求、响应以及执行其他自定义逻辑。Spring Cloud Gateway 提供了多个内置的过滤器，如请求转发、请求重试、请求限流等。同时也支持自定义过滤器，可以根据需求编写自己的过滤器逻辑。\n\n我们再来看下 Spring Cloud Gateway 的具体工作流程：\n\n\n\n又有两个比较重要的概念：\n\n* **Gateway Handler（网关处理器）**：网关处理器是 Spring Cloud Gateway 的核心组件，负责将请求转发到匹配的路由上。它根据路由配置和断言条件进行路由匹配，选择合适的路由进行请求转发。网关处理器还会依次应用配置的过滤器链，对请求进行处理和转换。\n* **Gateway Filter Chain（网关过滤器链）**：网关过滤器链由一系列过滤器组成，按照配置的顺序依次执行。每个过滤器可以在请求前、请求后或请求发生错误时进行处理。过滤器链的执行过程可以修改请求、响应以及执行其他自定义逻辑。"
+ }
+ ]
+ },
+ {
+ "id": 90,
+ "categoryName": "链路追踪",
+ "questions": [
+ {
+ "id": 581,
+ "question": "为什么要用微服务链路追踪？",
+ "answer": "在微服务中，有的山下游可能有十几个服务，如果某一环出了问题，排查起来非常困难，所以，就需要进行链路追踪，来帮助排查问题。\n\n\n\n通过链路追踪，可以可视化地追踪请求从一个微服务到另一个微服务的调用情况。除了排查问题，链路追踪黑还可以帮助优化性能，可视化依赖关系、服务监控和告警。"
+ },
+ {
+ "id": 582,
+ "question": "SpringCloud 可以选择哪些微服务链路追踪方案？",
+ "answer": "Spring Cloud 提供了多种选择的微服务链路追踪方案。以下是一些常用的方案：\n\n1. Zipkin：Zipkin 是一个开源的分布式实时追踪系统，由 Twitter 开发并贡献给开源社区。Spring Cloud Sleuth 提供了与 Zipkin 的集成，可以通过在微服务中添加相应的依赖和配置，将追踪信息发送到 Zipkin 服务器，并通过 Zipkin UI 进行可视化展示和查询。\n\n\n\n2. Jaeger：Jaeger 是 Uber 开源的分布式追踪系统，也被纳入了 CNCF（云原生计算基金会）的维护。通过使用 Spring Cloud Sleuth 和 Jaeger 客户端库，可以将追踪信息发送到 Jaeger 并进行可视化展示和查询。\n3. SkyWalking：Apache SkyWalking 是一款开源的应用性能监控与分析系统，提供了对 Java、.NET 和 Node.js 等语言的支持。它可以与 Spring Cloud Sleuth 集成，将追踪数据发送到 SkyWalking 服务器进行可视化展示和分析。\n\n\n\n4. Pinpoint：Pinpoint 是 Naver 开源的分布式应用性能监控系统，支持 Java 和 .NET。它提供了与 Spring Cloud Sleuth 的集成，可以将追踪数据发送到 Pinpoint 服务器，并通过其 UI 进行分析和监控。\n\n\n\n这些方案都可以与 Spring Cloud Sleuth 进行集成，Spring Cloud Sleuth 是 Spring Cloud 中的一个组件，提供了在微服务调用时生成追踪信息的能力。"
+ }
+ ]
+ },
+ {
+ "id": 91,
+ "categoryName": "分布式事务",
+ "questions": [
+ {
+ "id": 583,
+ "question": "Seata 支持哪些模式的分布式事务？",
+ "answer": "Seata 以下几种模式的分布式事务：\n\n1. AT（Atomikos）模式：AT 模式是 Seata 默认支持的模式，也是最常用的模式之一。在 AT 模式下，Seata 通过在业务代码中嵌入事务上下文，实现对分布式事务的管理。Seata 会拦截并解析业务代码中的 SQL 语句，通过对数据库连接进行拦截和代理，实现事务的管理和协调。\n\n\n\n2. TCC（Try-Confirm-Cancel）模式：TCC 模式是一种基于补偿机制的分布式事务模式。在 TCC 模式中，业务逻辑需要实现 Try、Confirm 和 Cancel 三个阶段的操作。Seata 通过调用业务代码中的 Try、Confirm 和 Cancel 方法，并在每个阶段记录相关的操作日志，来实现分布式事务的一致性。\n\n\n\n3. SAGA 模式：SAGA 模式是一种基于事件驱动的分布式事务模式。在 SAGA 模式中，每个服务都可以发布和订阅事件，通过事件的传递和处理来实现分布式事务的一致性。Seata 提供了与 SAGA 模式兼容的 Saga 框架，用于管理和协调分布式事务的各个阶段。\n\n\n\n4. XA 模式：XA 模式是一种基于两阶段提交（Two-Phase Commit）协议的分布式事务模式。在 XA 模式中，Seata 通过与数据库的 XA 事务协议进行交互，实现对分布式事务的管理和协调。XA 模式需要数据库本身支持 XA 事务，并且需要在应用程序中配置相应的 XA 数据源。\n\n"
+ },
+ {
+ "id": 584,
+ "question": "了解 Seata 的实现原理吗？",
+ "answer": "Seata 的实现原理主要包括三个核心组件：事务协调器（Transaction Coordinator）、事务管理器（Transaction Manager）和资源管理器（Resource Manager）。\n\n* **事务协调器（Transaction Coordinator）**：事务协调器负责协调和管理分布式事务的整个过程。它接收事务的开始和结束请求，并根据事务的状态进行协调和处理。事务协调器还负责记录和管理事务的全局事务 ID（Global Transaction ID）和分支事务 ID（Branch Transaction ID）。\n* **事务管理器（Transaction Manager）**：事务管理器负责全局事务的管理和控制。它协调各个分支事务的提交或回滚，并保证分布式事务的一致性和隔离性。事务管理器还负责与事务协调器进行通信，并将事务的状态变更进行持久化。\n* **资源管理器（Resource Manager）**：资源管理器负责管理和控制各个参与者（Participant）的事务操作。它与事务管理器进行通信，并根据事务管理器的指令执行相应的事务操作，包括提交和回滚。\n\n\n\nSeata 的实现原理基于**两阶段提交（Two-Phase Commit）协议**，具体的机制如下：\n\n1. 一阶段：在事务提交的过程中，首先进行预提交阶段。事务协调器向各个资源管理器发送预提交请求，资源管理器执行相应的事务操作并返回执行结果。在此阶段，业务数据和回滚日志记录在同一个本地事务中提交，并释放本地锁和连接资源。\n2. 二阶段：在预提交阶段成功后，进入真正的提交阶段。此阶段主要包括提交异步化和回滚反向补偿两个步骤：\n\n* 提交异步化：事务协调器发出真正的提交请求，各个资源管理器执行最终的提交操作。这个阶段的操作是非常快速的，以确保事务的提交效率。\n* 回滚反向补偿：如果在预提交阶段中有任何一个资源管理器返回失败结果，事务协调器发出回滚请求，各个资源管理器执行回滚操作，利用一阶段的回滚日志进行反向补偿。\n\n#### [Seata 的事务执行流程是什么样的？](#seata-的事务执行流程是什么样的)\n\nSeata 事务的执行流程可以简要概括为以下几个步骤：\n\n1. 事务发起方（Transaction Starter）发起全局事务：事务发起方是指发起分布式事务的应用程序或服务。它向 Seata 的事务协调器发送全局事务的开始请求，生成全局事务 ID（Global Transaction ID）。\n2. 事务协调器创建全局事务记录：事务协调器接收到全局事务的开始请求后，会为该事务创建相应的全局事务记录，并生成分支事务 ID（Branch Transaction ID）。\n3. 分支事务注册：事务发起方将全局事务 ID 和分支事务 ID 发送给各个参与者（Participant），即资源管理器。参与者将分支事务 ID 注册到本地事务管理器，并将事务的执行结果反馈给事务协调器。\n4. 执行业务逻辑：在分布式事务的上下文中，各个参与者执行各自的本地事务，即执行业务逻辑和数据库操作。\n5. 预提交阶段：事务发起方向事务协调器发送预提交请求，事务协调器将预提交请求发送给各个参与者。\n6. 执行本地事务确认：参与者接收到预提交请求后，执行本地事务的确认操作，并将本地事务的执行结果反馈给事务协调器。\n7. 全局事务提交或回滚：事务协调器根据参与者反馈的结果进行判断，如果所有参与者的本地事务都执行成功，事务协调器发送真正的提交请求给参与者，参与者执行最终的提交操作；如果有任何一个参与者的本地事务执行失败，事务协调器发送回滚请求给参与者，参与者执行回滚操作。\n8. 完成全局事务：事务协调器接收到参与者的提交或回滚结果后，根据结果更新全局事务的状态，并通知事务发起方全局事务的最终结果。\n\n#### [全局事务 ID 和分支事务 ID 是怎么传递的？](#全局事务-id-和分支事务-id-是怎么传递的)\n\n全局事务 ID 和分支事务 ID 在分布式事务中通过上下文传递的方式进行传递。常见的传递方式包括参数传递、线程上下文传递和消息中间件传递。具体的传递方式可以根据业务场景和技术选型进行选择和调整。\n\n#### [Seata 的事务回滚是怎么实现的？](#seata-的事务回滚是怎么实现的)\n\n\n\nSeata 的事务回滚是通过回滚日志实现的。每个参与者在执行本地事务期间生成回滚日志，记录了对数据的修改操作。\n\n当需要回滚事务时，事务协调器向参与者发送回滚请求，参与者根据回滚日志中的信息执行撤销操作，将数据恢复到事务开始前的状态。\n\n回滚日志的管理和存储是 Seata 的核心机制，可以选择将日志存储在不同的介质中。通过回滚日志的持久化和恢复，Seata 确保了事务的一致性和恢复性。"
+ }
+ ]
+ },
+ {
+ "id": 92,
+ "categoryName": "服务监控",
+ "questions": [
+ {
+ "id": 585,
+ "question": "你们的服务怎么做监控和告警？",
+ "answer": "我们使用 Prometheus 和 Grafana 来实现整个微服务集群的监控和告警：\n\n1. Prometheus：Prometheus 是一个开源的监控系统，具有灵活的数据模型和强大的查询语言，能够收集和存储时间序列数据。它可以通过 HTTP 协议定期拉取微服务的指标数据，并提供可扩展的存储和查询功能。\n2. Grafana：Grafana 是一个开源的可视化仪表板工具，可以与 Prometheus 结合使用，创建实时和历史数据的仪表板。Grafana 提供了丰富的图表和可视化选项，可以帮助用户更好地理解和分析微服务的性能和状态。\n\n"
+ },
+ {
+ "id": 586,
+ "question": "你们的服务怎么做日志收集？",
+ "answer": "日志收集有很多种方案，我们用的是`ELK`：\n\n* **Elasticsearch**：Elasticsearch 是一个分布式搜索和分析引擎，用于存储和索引大量的日志数据。它提供了快速的搜索和聚合功能，可以高效地处理大规模的日志数据。\n* **Logstash**：Logstash 是一个用于收集、过滤和转发日志数据的工具。它可以从各种来源（如文件、网络、消息队列等）收集日志数据，并对数据进行处理和转换，然后将其发送到 Elasticsearch 进行存储和索引。\n* **Kibana**：Kibana 是一个用于日志数据可视化和分析的工具。它提供了丰富的图表、仪表盘和搜索功能，可以帮助用户实时监控和分析日志数据，发现潜在的问题和趋势。\n\n简单说，这三者里**Elasticsearch**提供数据存储和检索能力，**Logstash**负责将日志收集到 ES，**Kibana**负责日志数据的可视化分析。\n\n使用 ELK 进行微服务日志收集的一般流程如下：\n\n\n\n1. 在每个微服务中配置日志输出：将微服务的日志输出到标准输出（stdout）或日志文件。\n2. 使用 Logstash 收集日志：配置 Logstash 收集器，通过配置输入插件（如文件输入、网络输入等）监听微服务的日志输出，并进行过滤和处理。\n3. 将日志数据发送到 Elasticsearch：配置 Logstash 的输出插件，将经过处理的日志数据发送到 Elasticsearch 进行存储和索引。\n4. 使用 Kibana 进行可视化和分析：通过 Kibana 连接到 Elasticsearch，创建仪表盘、图表和搜索查询，实时监控和分析微服务的日志数据。\n\n> 1.3 万字 33 张手绘图，详解 33 道微服务（Dubbo、Spring Cloud）面试高频题（让天下没有难背的八股），面渣背会这些八股文，这次吊打面试官，我觉得稳了（手动 dog）。整理：练习伴侣二，戳[转载链接](https://mp.weixin.qq.com/s/IgY6cU_5Xic-2KAAhxK9MA)，作者：三分恶，戳[原文链接](https://mp.weixin.qq.com/s/S8_I9mDNh7XnnQaXJFr2CQ)。\n\n---\n\n*没有什么使我停留——除了目的，纵然岸旁有玫瑰、有绿荫、有宁静的港湾，我是不系之舟*。\n\n**系列内容**：\n\n\n\n---"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 14,
+ "topicName": "设计模式",
+ "categories": [
+ {
+ "id": 93,
+ "categoryName": "什么是责任链模式？",
+ "questions": [
+ {
+ "id": 587,
+ "question": "基本概念",
+ "answer": "责任链模式主要包括以下几个角色：\n\n* **Handler（抽象处理者）**：定义了一个处理请求的接口或抽象类，其中通常会包含一个指向链中下一个处理者的引用。\n* **ConcreteHandler（具体处理者）**：实现抽象处理者的处理方法，如果它能处理请求，则处理；否则将请求转发给链中的下一个处理者。\n* **Client（客户端）**：创建处理链，并向链的第一个处理者对象提交请求。"
+ },
+ {
+ "id": 588,
+ "question": "工作流程",
+ "answer": "1. 客户端将请求发送给链上的第一个处理者对象。\n2. 处理者接收到请求后，决定自己是否有能力进行处理。\n * 如果可以处理，就处理请求。\n * 如果不能处理，就将请求转发给链上的下一个处理者。\n3. 过程重复，直到链上的某个处理者能处理该请求或者链上没有更多的处理者。"
+ },
+ {
+ "id": 589,
+ "question": "应用场景",
+ "answer": "责任链模式适用于以下场景：\n\n* 有多个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定。\n* 在不明确指定接收者的情况下，向多个对象中的一个提交请求。\n* 需要动态组织和管理处理者时。"
+ },
+ {
+ "id": 590,
+ "question": "优缺点",
+ "answer": "**优点**：\n\n* 降低耦合度：它将请求的发送者和接收者解耦。\n* 增加了给对象指派职责的灵活性：可以在运行时动态改变链中的成员或调整它们的次序。\n* 可以方便地增加新的处理类，在不影响现有代码的情况下扩展功能。\n\n**缺点**：\n\n* 请求可能不会被处理：如果没有任何处理者处理请求，它可能会达到链的末端并被丢弃。\n* 性能问题：一个请求可能会在链上进行较长的遍历，影响性能。\n* 调试困难：特别是在链较长时，调试可能会比较麻烦。"
+ },
+ {
+ "id": 591,
+ "question": "实现示例",
+ "answer": "假设有一个日志系统，根据日志的严重性级别（错误、警告、信息）将日志消息发送给不同的处理器处理。\n\n\n```java\nabstract class Logger {\n public static int INFO = 1;\n public static int DEBUG = 2;\n public static int ERROR = 3;\n\n protected int level;\n\n // 责任链中的下一个元素\n protected Logger nextLogger;\n\n public void setNextLogger(Logger nextLogger) {\n this.nextLogger = nextLogger;\n }\n\n public void logMessage(int level, String message) {\n if (this.level <= level) {\n write(message);\n }\n if (nextLogger != null) {\n nextLogger.logMessage(level, message);\n }\n }\n\n abstract protected void write(String message);\n}\n\nclass ConsoleLogger extends Logger {\n public ConsoleLogger(int level) {\n this.level = level;\n }\n\n @Override\n protected void write(String message) {\n System.out.println(\"Standard Console::Logger: \" + message);\n }\n}\n\nclass ErrorLogger extends Logger {\n public ErrorLogger(int level) {\n this.level = level;\n }\n\n @Override\n protected void write(String message) {\n System.out.println(\"Error Console::Logger: \" + message);\n }\n}\n\nclass FileLogger extends Logger {\n public FileLogger(int level) {\n this.level = level;\n }\n\n @Override\n protected void write(String message) {\n System.out.println(\"File::Logger: \" + message);\n }\n}\n\npublic class ChainPatternDemo {\n private static Logger getChainOfLoggers() {\n Logger errorLogger = new ErrorLogger(Logger.ERROR);\n Logger fileLogger = new FileLogger(Logger.DEBUG);\n Logger consoleLogger = new ConsoleLogger(Logger.INFO);\n\n errorLogger.setNextLogger(fileLogger);\n fileLogger.setNextLogger(consoleLogger);\n\n return errorLogger;\n }\n\n public static void main(String[] args) {\n Logger loggerChain = getChainOfLoggers();\n\n loggerChain.logMessage(Logger.INFO, \"INFO 级别\");\n loggerChain.logMessage(Logger.DEBUG, \" Debug 级别\");\n loggerChain.logMessage(Logger.ERROR, \"Error 级别\");\n }\n}\n```\n\n\n在这个示例中，创建了一个日志处理链。不同级别的日志将被相应级别的处理器处理。责任链模式让日志系统的扩展和维护变得更加灵活。\n\n输出结果：\n\n\n```text\nStandard Console::Logger: INFO 级别\nFile::Logger: Debug 级别\nStandard Console::Logger: Debug 级别\nError Console::Logger: Error 级别\nFile::Logger: Error 级别\nStandard Console::Logger: Error 级别\n```"
+ }
+ ]
+ },
+ {
+ "id": 94,
+ "categoryName": "什么是工厂模式？",
+ "questions": [
+ {
+ "id": 592,
+ "question": "工厂模式的主要类型",
+ "answer": "①、**简单工厂模式**（Simple Factory）：它引入了创建者的概念，将实例化的代码从应用程序的业务逻辑中分离出来。简单工厂模式包括一个工厂类，它提供一个方法用于创建对象。\n\n\n```java\nclass SimpleFactory {\n public static Transport createTransport(String type) {\n if (\"truck\".equalsIgnoreCase(type)) {\n return new Truck();\n } else if (\"ship\".equalsIgnoreCase(type)) {\n return new Ship();\n }\n return null;\n }\n\n public static void main(String[] args) {\n Transport truck = SimpleFactory.createTransport(\"truck\");\n truck.deliver();\n\n Transport ship = SimpleFactory.createTransport(\"ship\");\n ship.deliver();\n }\n}\n```\n\n\n②、**工厂方法模式**（Factory Method）：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类进行。\n\n\n```java\ninterface Transport {\n void deliver();\n}\n\nclass Truck implements Transport {\n @Override\n public void deliver() {\n System.out.println(\"在陆地上运输\");\n }\n}\n\nclass Ship implements Transport {\n @Override\n public void deliver() {\n System.out.println(\"在海上运输\");\n }\n}\n\ninterface TransportFactory {\n Transport createTransport();\n}\n\nclass TruckFactory implements TransportFactory {\n @Override\n public Transport createTransport() {\n return new Truck();\n }\n}\n\nclass ShipFactory implements TransportFactory {\n @Override\n public Transport createTransport() {\n return new Ship();\n }\n}\n\npublic class FactoryMethodPatternDemo {\n public static void main(String[] args) {\n TransportFactory truckFactory = new TruckFactory();\n Transport truck = truckFactory.createTransport();\n truck.deliver();\n\n TransportFactory shipFactory = new ShipFactory();\n Transport ship = shipFactory.createTransport();\n ship.deliver();\n }\n}\n```"
+ },
+ {
+ "id": 593,
+ "question": "应用场景",
+ "answer": "1. **数据库访问层（DAL）组件**：工厂方法模式适用于数据库访问层，其中需要根据不同的数据库（如MySQL、PostgreSQL、Oracle）创建不同的数据库连接。工厂方法可以隐藏这些实例化逻辑，只提供一个统一的接口来获取数据库连接。\n2. **日志记录**：当应用程序需要实现多种日志记录方式（如向文件记录、数据库记录或远程服务记录）时，可以使用工厂模式来设计一个灵活的日志系统，根据配置或环境动态决定具体使用哪种日志记录方式。"
+ }
+ ]
+ },
+ {
+ "id": 95,
+ "categoryName": "什么是单例模式？",
+ "questions": [
+ {
+ "id": 594,
+ "question": "实现单例模式的关键点？",
+ "answer": "1. **私有构造方法**：确保外部代码不能通过构造器创建类的实例。\n2. **私有静态实例变量**：持有类的唯一实例。\n3. **公有静态方法**：提供全局访问点以获取实例，如果实例不存在，则在内部创建。"
+ },
+ {
+ "id": 595,
+ "question": "常见的单例模式实现？",
+ "answer": "#### [①、饿汉式如何实现单例？](#_1、饿汉式如何实现单例)\n\n饿汉式单例（Eager Initialization）在类加载时就急切地创建实例，不管你后续用不用得到，这也是饿汉式的来源，简单但不支持延迟加载实例。\n\n\n```java\npublic class Singleton {\n private static final Singleton instance = new Singleton();\n\n private Singleton() {}\n\n public static Singleton getInstance() {\n return instance;\n }\n}\n```\n\n\n#### [②、懒汉式如何实现单例？](#_2、懒汉式如何实现单例)\n\n懒汉式单例（Lazy Initialization）在实际使用时才创建实例，“确实懒”（😂）。这种实现方式需要考虑线程安全问题，因此一般会带上 。\n\n\n```java\npublic class Singleton {\n private static Singleton instance;\n\n private Singleton() {}\n\n public static synchronized Singleton getInstance() {\n if (instance == null) {\n instance = new Singleton();\n }\n return instance;\n }\n}\n```\n\n\n#### [③、双重检查锁如何实现单例？](#_3、双重检查锁如何实现单例)\n\n双重检查锁用 synchronized 同步代码块替代了 synchronized 同步方法。并且在 instance 前加上 ，防止指令重排，因为 `instance = new Singleton()` 并不是一个原子操作，可能会被重排序，导致其他线程获取到未初始化完成的实例。\n\n\n```java\nclass Singleton {\n private static volatile Singleton instance;\n\n private Singleton() {}\n\n public static Singleton getInstance() {\n if (instance == null) {\n synchronized (Singleton.class) {\n if (instance == null) {\n instance = new Singleton();\n }\n }\n }\n return instance;\n }\n}\n```\n\n\n当 instance 创建后，再次调用 getInstance 方法时，不会进入同步代码块，从而提高了性能。\n\n#### [④、静态内部类如何实现单例？](#_4、静态内部类如何实现单例)\n\n利用 Java 的（Static Nested Class）和来实现线程安全的延迟初始化。\n\n\n```java\npublic class Singleton {\n private Singleton() {}\n\n private static class SingletonHolder {\n private static final Singleton INSTANCE = new Singleton();\n }\n\n public static Singleton getInstance() {\n return SingletonHolder.INSTANCE;\n }\n}\n```\n\n\n当第一次加载 Singleton 类时并不会初始化 SingletonHolder，只有在第一次调用 getInstance 方法时才会导致 SingletonHolder 被加载，从而实例化 instance。\n\n#### [⑤、枚举如何实现单例？](#_5、枚举如何实现单例)\n\n使用实现单例是最简单的方式，不仅不需要考虑线程同步问题，还能防止反射攻击和序列化问题。\n\n\n```java\npublic enum Singleton {\n INSTANCE;\n // 可以添加实例方法\n}\n```"
+ },
+ {
+ "id": 596,
+ "question": "单例模式的好处有哪些？",
+ "answer": "单例模式能确保一个类仅有一个实例，并提供一个全局访问点来访问这个实例。\n\n这对于需要控制资源使用或需要共享资源的情况非常有用，比如数据库连接池，通过单例模式，可以避免对资源的重复创建和销毁，从而提高资源利用率和系统性能。"
+ },
+ {
+ "id": 597,
+ "question": "单例模式有几种实现方式？",
+ "answer": "单例模式有 5 种实现方式，常见的有饿汉式、懒汉式、双重检查锁定、静态内部类和枚举。"
+ }
+ ]
+ },
+ {
+ "id": 96,
+ "categoryName": "了解哪些设计模式？",
+ "questions": [
+ {
+ "id": 598,
+ "question": "了解哪些设计模式？",
+ "answer": "单例模式、策略模式和工厂模式。\n\n在需要控制资源访问，如配置管理、连接池管理时经常使用单例模式。它确保了全局只有一个实例，并提供了一个全局访问点。\n\n在有多种算法或策略可以切换使用的情况下，我会使用策略模式。像中，我就使用策略模式对接了讯飞星火、OpenAI、智谱 AI 等多家大模型，实现了一个可以自由切换大模型基座的智能助手服务。\n\n策略模式的好处是，不用在代码中写 if/else 判断，而是将不同的 AI 服务封装成不同的策略类，通过工厂模式创建不同的 AI 服务实例，从而实现 AI 服务的动态切换。\n\n后面想添加新的 AI 服务，只需要增加一个新的策略类，不需要修改原有代码，这样就提高了代码的可扩展性。"
+ }
+ ]
+ },
+ {
+ "id": 97,
+ "categoryName": "什么是策略模式？",
+ "questions": [
+ {
+ "id": 599,
+ "question": "什么是策略模式？",
+ "answer": "策略模式是一种行为型设计模式，它定义了一系列的算法，将每个算法封装起来，使得它们可以相互替换。这种模式通常用于实现不同的业务规则，其中每种策略封装了特定的行为或算法。\n\n\n\n特别适合优化程序中的复杂条件分支语句（if-else）。\n\n在策略模式中，有三个角色：上下文、策略接口和具体策略。\n\n* **策略接口**：定义所有支持算法的公共接口。\n* **具体策略**：实现策略接口的类，提供具体的算法实现。\n* **上下文**：使用策略的类。通常包含一个引用指向策略接口，可以在运行时改变其具体策略。\n\n比如说在技术派中，用户可以自由切换 AI 服务，服务端可以通过 if/esle 进行判断，但如果后续需要增加新的 AI 服务，就需要修改代码，这样不够灵活。\n\n因此，我们使用了策略模式，将不同的 AI 服务封装成不同的策略类，通过工厂模式创建不同的 AI 服务实例，从而实现 AI 服务的动态切换。\n\n\n```java\n@Service\npublic class PaiAiDemoServiceImpl extends AbsChatService {\n\n @Override\n public AISourceEnum source() {\n return AISourceEnum.PAI_AI;\n }\n}\n\n@Slf4j\n@Service\npublic class ChatGptAiServiceImpl extends AbsChatService {\n @Override\n public AISourceEnum source() {\n return AISourceEnum.CHAT_GPT_3_5;\n }\n}\n\n@Slf4j\n@Service\npublic class XunFeiAiServiceImpl extends AbsChatService {\n @Override\n public AISourceEnum source() {\n return AISourceEnum.XUN_FEI_AI;\n }\n}\n```\n\n\n---\n\n*没有什么使我停留——除了目的，纵然岸旁有玫瑰、有绿荫、有宁静的港湾，我是不系之舟*。\n\n**系列内容**：\n\n\n\n---\n\n> 图文详解 5 道设计模式面试高频题，这次吊打面试官，我觉得稳了（手动 dog）。"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 15,
+ "topicName": "Linux",
+ "categories": [
+ {
+ "id": 98,
+ "categoryName": "Linux 常用命令",
+ "questions": [
+ {
+ "id": 600,
+ "question": "文件操作的命令有哪些？",
+ "answer": "* `ls`：列出目录内容。`ls -l`显示详细信息，`ls -a`显示隐藏文件。\n* `cd`：更改当前目录。`cd ..`回到上级目录，`cd ~`回到用户的主目录。\n* `pwd`：显示当前工作目录的完整路径。\n* `cp`：复制文件或目录。`cp source_file target_file`复制文件，`cp -r source_directory target_directory`复制目录。\n* `mv`：移动或重命名文件或目录。\n* `rm`：删除文件或目录。`rm -r`递归删除目录及其内容。\n* `mkdir`：创建新目录。\n* `cat`：查看文件内容。`cat file1 file2`合并文件内容显示。\n\n#### [Windows下如何创建空文件](#windows下如何创建空文件)\n\nWindows 下我还是比较习惯使用右键菜单新建一个文件，然后重命名。\n\n#### [如何查看系统的日志文件？](#如何查看系统的日志文件)\n\n在 Linux 中，可以通过 cat、more、less、tail、head 等命令查看系统日志文件。\n\n也可以直接通过 vim 打开日志文件，然后按照关键字去搜查对应的日志信息。\n\n常见的系统日志文件包括：\n\n* `/var/log/syslog`：包含系统范围内的消息和错误日志，包括启动日志、内核日志等，是排查系统问题的首选日志文件之一。\n* `/var/log/messages`：类似于 syslog，但通常更多关注系统级别的消息和错误。"
+ },
+ {
+ "id": 601,
+ "question": "系统管理的命令有哪些？",
+ "answer": "* `ps`：显示当前运行的进程。`ps aux`显示所有进程。\n* `top`：实时显示进程动态。\n* `kill`：终止进程。`kill -9 PID`强制终止。\n* `df`：显示磁盘空间使用情况。`df -h`以易读格式显示。\n* `du`：显示目录或文件的磁盘使用情况。\n* `free`：显示内存和交换空间的使用情况。\n* `chmod`：更改文件或目录的权限。\n* `chown`：更改文件或目录的所有者和所属组。\n\n#### [如何查看Linux进程或CPU使用情况？](#如何查看linux进程或cpu使用情况)\n\ntop 命令可以实时查看所有进程的 CPU 和内存使用情况。\n\n\n\n`ps aux --sort=-%cpu | head -5`可以查看 CPU 使用率最高的 5 个进程。\n\n\n\n#### [如何查看Linux内存使用情况？](#如何查看linux内存使用情况)\n\n可以使用 watch 配合 free 命令实时监控内存使用情况。如 `watch -n 1 free -m`每秒刷新一次内存使用情况。\n\n\n\n#### [如何查看系统负载？](#如何查看系统负载)\n\ntop 命令是实时查看系统性能的常用工具，系统负载信息通常显示在 top 命令输出的顶部。它还显示了系统运行的进程、内存使用情况等。\n\n\n\n#### [Load Average 是什么？](#load-average-是什么)\n\nload average 是一个反映系统负载的指标，表示在一段时间内系统正在处理的平均进程数量。通常，它包含三个数值，分别对应过去 1 分钟、5 分钟和 15 分钟的平均负载。\n\n比如说上图中出现的 `load average: 1.80, 1.74, 1.83` 表示：\n\n* 1.80：表示过去 1 分钟内，系统平均有 1.80 个进程在等待处理（包括 CPU 正在处理和等待被调度的进程）。\n* 1.74：表示过去 5 分钟内的平均负载。\n* 1.83：表示过去 15 分钟内的平均负载。\n\nload average 的数值可以看作是系统的工作队列长度（等待处理的任务数量）。如果这个数值接近或等于 CPU 核心数，说明系统的负载是合理的。\n\n如果 load average 大于 CPU 核心数，表示系统的进程比 CPU 能处理的多，系统可能处于过载状态。\n\n在单核系统中，load average 数值超过 1 通常意味着系统繁忙（有任务在等待 CPU）。\n\n在多核系统中，假设有 N 个 CPU 核心，load average 接近 N 时表示系统正处于高负载状态，但还在可接受范围内。如果 load average 超过 N，则意味着系统可能过载。\n\nmacOS 上可以通过 `sysctl -a | grep machdep.cpu.core_count` 查看 CPU 核心数，我本机目前是 16 核。\n\n\n\n#### [chmod 的参数讲一下？](#chmod-的参数讲一下)\n\nchmod 命令在 Linux 中用来改变文件或目录的访问权限。这个命令的使用可以基于符号表示法（也称为文本方法）或者八进制数表示法。\n\n像 `chmod 777 file` 赋予文件所有权限，就属于八进制数表示法。`7=4+2+1`，分别代表读、写、执行权限。\n\nLinux 中的权限可以应用于三种类别的用户：\n\n* 文件所有者（u）\n* 与文件所有者同组的用户（g）\n* 其他用户（o）\n\n\n\n①、符号模式\n\n符号模式使用字母来表示权限，如下：\n\n* 读（r）\n* 写（w）\n* 执行（x）\n* 所有（a）\n\n例如：\n\n* `chmod u+w file`：给文件所有者添加写权限。\n* `chmod g-r file`：移除组用户的读权限。\n* `chmod o+x file`：给其他用户添加执行权限。\n* `chmod u=rwx,g=rx,o=r file`：设置文件所有者具有读写执行权限，组用户具有读执行权限，其他用户具有读权限。\n\n②、数字模式\n\n数字模式使用三位八进制数来表示权限，每位数字代表不同的用户类别（所有者、组、其他用户），数字是其各自权限值的总和：\n\n* 读（r）= 4\n* 写（w）= 2\n* 执行（x）= 1\n\n\n\n因此，权限模式可以是从 0（无权限）到 7（读写执行权限）的任何值。\n\n* chmod 755 file：使得文件所有者有读写执行（7）权限，组用户和其他用户有读和执行（5）权限。\n* chmod 644 file：使得文件所有者有读写（6）权限，而组用户和其他用户只有读（4）权限。\n\n#### [`kill -9` 中的 9 是什么意思？](#kill-9-中的-9-是什么意思)\n\n`kill -9 PID` 是一种强制终止进程的方式，其中的 9 表示信号编号，代表 SIGKILL 信号。"
+ },
+ {
+ "id": 602,
+ "question": "网络管理的命令有哪些？",
+ "answer": "* `ping`：检查与远程服务器的连接。\n* `wget`：从网络上下载文件。\n* `ifconfig`：显示网络接口的配置信息。\n* `netstat`：显示网络连接、路由表和网络接口信息。\n\n#### [如何查看8080端口的连接数？](#如何查看8080端口的连接数)\n\n可以通过 netstat 命令查看，如`netstat -an | grep ':8080' | grep 'tcp' | wc -l`。\n\n\n\n* `-a`：显示所有网络连接和监听端口。\n* `-n`：以数字形式显示地址和端口。\n* `grep ':8080'`：过滤出 8080 端口的连接。\n* `grep 'tcp'`：仅显示 TCP 连接。\n* `wc -l`：统计匹配到的行数，即连接数。\n\n也可以使用 `ss` 命令，它是 netstat 的替代工具；还可以使用 `lsof` 命令，它可以列出当前系统打开的文件和套接字。"
+ },
+ {
+ "id": 603,
+ "question": "压缩和解压的命令有哪些？",
+ "answer": "* `tar`：打包或解包`.tar`文件。`tar cvf archive.tar files`打包，`tar xvf archive.tar`解包。\n* `gzip` / `gunzip`：压缩或解压`.gz`文件。\n* `zip` / `unzip`：压缩或解压`.zip`文件。"
+ },
+ {
+ "id": 604,
+ "question": "查找文件的命令有哪些？",
+ "answer": "* `find`：在目录树中查找文件。`find /directory/ -name filename`。\n\n#### [Liunx 下查找一个文件怎么做？](#liunx-下查找一个文件怎么做)\n\n在 Linux 环境下查找文件，有多种命令和方法可以使用。find 命令是最常用的文件查找工具之一，它可以在指定目录下递归查找符合条件的文件和目录。\n\n例如：在当前目录及其子目录中查找名为 \"example.txt\" 的文件\n\n\n```shell\nfind . -name \"example.txt\"\n```\n\n\n例如：查找 `/home` 目录中所有 `.txt` 结尾的文件：\n\n\n```shell\nfind /home -name \"*.txt\"\n```\n\n\n例如：查找 `/var/log` 目录中修改时间在 7 天以前的 `.log` 文件\n\n\n```shell\nfind /var/log -name \"*.log\" -mtime +7\n```"
+ }
+ ]
+ },
+ {
+ "id": 99,
+ "categoryName": "Linux 系统管理",
+ "questions": [
+ {
+ "id": 605,
+ "question": "用户和用户组有什么区别？",
+ "answer": "在 Linux 中，用户和用户组是系统权限管理的核心概念。\n\n每个用户在 Linux 中都有一个独立的账户，用于标识该用户并控制其对系统资源的访问。用户包括普通用户和超级用户（root）。普通用户的权限有限，只能访问和修改自己拥有的文件和目录，而超级用户拥有系统的最高权限，能够执行任何操作。\n\n每个用户在系统中都有一个唯一的用户 ID（UID），以及一个关联的用户名（login name）。\n\n用户组是用户的集合，用于简化权限管理。每个用户可以属于一个或多个用户组，而每个用户组都有一个唯一的组 ID（GID）。通过将用户分配到不同的组，系统可以更方便地管理对文件和目录的访问权限。\n\n一个文件或目录可以由一个用户和一个用户组拥有，系统根据文件或目录的所有者和所属组来确定其他用户对它的访问权限。\n\n可以使用 groupadd 命令来创建新的用户组。例如：\n\n\n```shell\nsudo groupadd developers\n```\n\n\n可以使用 useradd 命令来创建新的用户。创建用户时可以指定该用户的默认用户组、主目录等。例如，创建一个名为 johndoe 的用户，并将其添加到 developers 组：\n\n\n```shell\nsudo useradd -m -g developers johndoe\n```\n\n\n* `-m`：表示创建用户的同时创建用户的主目录（通常在`/home/username`）。\n* `-g`：指定用户的初始用户组。"
+ },
+ {
+ "id": 606,
+ "question": "如何用linux命令去查找某个qps?",
+ "answer": "如果服务通过网络提供访问，可以使用 netstat 或 ss 命令统计特定端口的连接数，并结合 watch 命令来监控实时的连接速率。\n\n例如，统计 HTTPS 服务（通常运行在端口 443）每秒的请求数：\n\n\n```shell\nwatch -n 1 \"netstat -an | grep ':443 ' | grep ESTABLISHED | wc -l\"\n```\n\n\n解释一下：\n\n* `netstat -an`：显示所有连接和监听端口。\n* `grep ':443 '`：过滤出端口 443 的连接。\n* `grep ESTABLISHED`：过滤出已经建立的连接。\n* `wc -l`：统计连接数。\n* `watch -n 1`：每秒刷新一次命令的输出。\n\n观察连接数的变化，可以大致估算出每秒的请求数。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 100,
+ "categoryName": "Git 常用命令",
+ "questions": [
+ {
+ "id": 607,
+ "question": "Git 常用命令有哪些？",
+ "answer": "* `git clone `：克隆远程仓库。\n* `git status`：查看工作区和暂存区的状态。\n* `git add `：将文件添加到暂存区。\n* `git commit -m \"message\"`：提交暂存区的文件到本地仓库。\n* `git log`：查看提交历史。\n* `git merge `：合并指定分支到当前分支。\n* `git checkout `：切换分支。\n* `git pull`：拉取远程仓库的更新。\n\n---\n\n图文详解 2 道 Linux 面试高频题，这次吊打面试官，我觉得稳了（手动 dog）。整理：练习伴侣二。\n\n*没有什么使我停留——除了目的，纵然岸旁有玫瑰、有绿荫、有宁静的港湾，我是不系之舟*。\n\n**系列内容**：\n\n\n\n---"
+ }
+ ]
+ }
+ ]
+ }
+]
\ No newline at end of file
diff --git a/public/result.json b/public/result.json
new file mode 100644
index 0000000..eeffd32
--- /dev/null
+++ b/public/result.json
@@ -0,0 +1,4171 @@
+[
+ {
+ "id": 1,
+ "topicName": "Java SE",
+ "categories": [
+ {
+ "id": 1,
+ "categoryName": "Java 概述",
+ "questions": [
+ {
+ "id": 1,
+ "question": "什么是 Java？",
+ "answer": "\n\nJava 是一门面向对象的编程语言，由 Sun 公司的詹姆斯·高斯林团队于 1995 年推出。吸收了 C++ 语言中大量的优点，但又抛弃了 C++ 中容易出错的地方，如垃圾回收、指针。\n\n同时，Java 又是一门平台无关的编程语言，即一次编译，处处运行。\n\n只需要在对应的平台上安装 JDK，就可以实现跨平台，在 Windows、macOS、Linux 操作系统上运行。\n\n#### [多久开始学 Java 的？](#多久开始学-java-的)\n\n我是从大一下学期开始学习 Java 的，当时已经学完了 C 语言，但苦于 C 语言没有很好的应用方向，就开始学习 Java 了，因为我了解到，绝大多数的互联网公司，包括银行、国企，后端服务都是用 Java 开发的，另外就是，Java 的学习资料非常丰富，就业岗位和薪资待遇都比较理想。\n\n于是就一边学，一边实战，先做了前后端分离的社区项目，接触到了 Spring Boot、MyBatis-Plus、MySQL、Redis、ElasticSearch、MongoDB、Docker、RabbitMQ 等一系列的 Java 技术栈。\n\n后面又做了微服务项目 ，接触到了 Spring Cloud、Nacos、Sentinel、Seata、SkyWalking 等相关技术栈。\n\n\n\n#### [平常用什么编程语言？](#平常用什么编程语言)\n\n大一上先学习的 C 语言，大一下半学期开始学习 Java，中间还学过一些 Python 和 JavaScript，但整体的感受上来说还是更喜欢 Java。\n\n因为它可以做的事情太多了，既可以用它来写 Web 后端服务，也可以用它来造一些轮子，比如 [MYDB](https://t.zsxq.com/0bhcI0Gs6) 这个轮子，就是用 Java 完成的，不进加深了我对 MySQL索引、事务、MVCC 的理解，还让我对 Java 的 NIO、多线程、JVM 有了更深的了解。\n\n\n\n#### [平时是怎么学 Java 的？](#平时是怎么学-java-的)\n\n一开始，主要是跟着学校的课程走，入门后感觉课程已经满足不了我的求知欲了，于是就开始在 B 站和 GitHub 上找一些优质的视频资源和开源知识库来学习。\n\n比如说《[Java 进阶之路](https://github.com/itwanger/toBeBetterJavaer)》就很适合我的口味，从 Java 的语法、数组&字符串、OOP、集合框架、Java IO、异常处理、网络编程、NIO、并发编程、JVM 等，都有详细的讲解，还有很多手绘图和代码实例，我都跟着动手一步步实现了，感觉收获很大。\n\n后来又读了一遍《Java 编程思想》、《Effective Java》，周志明老师的《深入理解 Java 虚拟机》，以及 JDK 的一些源码，比如说 String、HashMap，还有字节码方面的知识。\n\n再后来就开始做实战项目 [MYDB](https://t.zsxq.com/0bhcI0Gs6)、、，算是彻底掌握 Java 项目的开发流程了。\n\n#### [Java 语言和 C 语言有哪些区别？](#java-语言和-c-语言有哪些区别)\n\nJava 是一种跨平台的编程语言，通过在不同操作系统上安装对应版本的 JVM 以实现“一次编译，处处运行”的目的。而 C 语言需要在不同的操作系统上重新编译。\n\nJava 实现了内存的自动管理，而 C 语言需要使用 malloc 和 free 来手动管理内存。"
+ },
+ {
+ "id": 2,
+ "question": "Java 语言有哪些特点？",
+ "answer": "\n\nJava 语言的特点有：\n\n①、面向对象，主要是封装，继承，多态。\n\n②、平台无关性，“一次编写，到处运行”，因此采用 Java 语言编写的程序具有很好的可移植性。\n\n③、支持多线程。C++ 语言没有内置的多线程机制，因此必须调用操作系统的 API 来完成多线程程序设计，而 Java 却提供了封装好多线程支持；\n\n④、支持 JIT 编译，也就是即时编译器，它可以在程序运行时将字节码转换为热点机器码来提高程序的运行速度。"
+ },
+ {
+ "id": 3,
+ "question": "JVM、JDK 和 JRE 有什么区别？",
+ "answer": "\n\n**JVM**：也就是 Java 虚拟机，是 Java 实现跨平台的关键所在，不同的操作系统有不同的 JVM 实现。JVM 负责将 Java 字节码转换为特定平台的机器码，并执行。\n\n**JRE**：也就是 Java 运行时环境，包含了运行 Java 程序所必需的库，以及 JVM。\n\n**JDK**：一套完整的 Java SDK，包括 JRE，编译器 javac、Java 文档生成工具 javadoc、Java 字节码工具 javap 等。为开发者提供了开发、编译、调试 Java 程序的一整套环境。\n\n简单来说，JDK 包含 JRE，JRE 包含 JVM。"
+ },
+ {
+ "id": 4,
+ "question": "说说什么是跨平台？原理是什么",
+ "answer": "所谓的跨平台，是指 Java 语言编写的程序，一次编译后，可以在多个操作系统上运行。\n\n原理是增加了一个中间件 JVM，JVM 负责将 Java 字节码转换为特定平台的机器码，并执行。"
+ },
+ {
+ "id": 5,
+ "question": "什么是字节码？采用字节码的好处是什么?",
+ "answer": "所谓的字节码，就是 Java 程序经过编译后产生的 .class 文件。\n\n**Java** 程序从源代码到运行需要经过三步：\n\n* **编译**：将源代码文件 .java 编译成 JVM 可以识别的字节码文件 .class\n* **解释**：JVM 执行字节码文件，将字节码翻译成操作系统能识别的机器码\n* **执行**：操作系统执行二进制的机器码\n\n"
+ },
+ {
+ "id": 6,
+ "question": "为什么有人说 Java 是“编译与解释并存”的语言？",
+ "answer": "编译型语言是指编译器针对特定的操作系统，将源代码一次性翻译成可被该平台执行的机器码。\n\n解释型语言是指解释器对源代码进行逐行解释，解释成特定平台的机器码并执行。\n\n举个例子，我想读一本国外的小说，我有两种选择：\n\n* 找个翻译，等翻译将小说全部都翻译成汉语，一次性读完。\n* 找个翻译，翻译一段我读一段，慢慢把书读完。\n\n之所以有人说 Java 是“编译与解释并存”的语言，是因为 Java 程序需要先将 Java 源代码文件编译字节码文件，再解释执行。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 2,
+ "categoryName": "基础语法",
+ "questions": [
+ {
+ "id": 7,
+ "question": "Java 有哪些数据类型？",
+ "answer": "Java 的数据类型可以分为两种：**基本数据类型**和**引用数据类型**。\n\n\n\n基本数据类型有：\n\n①、数值型\n\n* 整数类型（byte、short、int、long）\n* 浮点类型（float、double）\n\n②、字符型（char）\n\n③、布尔型（boolean）\n\n它们的默认值和占用大小如下所示：\n\n| 数据类型 | 默认值 | 大小 |\n| --- | --- | --- |\n| boolean | false | 1 字节或 4 字节 |\n| char | '\\u0000' | 2 字节 |\n| byte | 0 | 1 字节 |\n| short | 0 | 2 字节 |\n| int | 0 | 4 字节 |\n| long | 0L | 8 字节 |\n| float | 0.0f | 4 字节 |\n| double | 0.0 | 8 字节 |\n\n引用数据类型有：\n\n* （class）\n* （interface）\n* （`[]`）\n\n#### [boolean 类型实际占用几个字节？](#boolean-类型实际占用几个字节)\n\n这要依据具体的 JVM 实现细节。Java 虚拟机规范中，并没有明确规定 boolean 类型的大小，只规定了 boolean 类型的取值 true 或 false。\n\n> boolean: The boolean data type has only two possible values: true and false. Use this data type for simple flags that track true/false conditions. This data type represents one bit of information, but its \"size\" isn't something that's precisely defined.\n\n我本机的 64 位 JDK 中，通过 JOL 工具查看单独的 boolean 类型，以及 boolean 数组，所占用的空间都是 1 个字节。\n\n#### [给Integer最大值+1，是什么结果？](#给integer最大值-1-是什么结果)\n\n当给 Integer.MAX\\_VALUE 加 1 时，会发生溢出，变成 Integer.MIN\\_VALUE。\n\n\n```java\nint maxValue = Integer.MAX_VALUE;\nSystem.out.println(\"Integer.MAX_VALUE = \" + maxValue); // Integer.MAX_VALUE = 2147483647\nSystem.out.println(\"Integer.MAX_VALUE + 1 = \" + (maxValue + 1)); // Integer.MAX_VALUE + 1 = -2147483648\n\n// 用二进制来表示最大值和最小值\nSystem.out.println(\"Integer.MAX_VALUE in binary: \" + Integer.toBinaryString(maxValue)); // Integer.MAX_VALUE in binary: 1111111111111111111111111111111\nSystem.out.println(\"Integer.MIN_VALUE in binary: \" + Integer.toBinaryString(Integer.MIN_VALUE)); // Integer.MIN_VALUE in binary: 10000000000000000000000000000000\n```\n\n\n这是因为 Java 的整数类型采用的是二进制补码表示法，溢出时值会变成最小值。\n\n* Integer.MAX\\_VALUE 的二进制表示是 01111111 11111111 11111111 11111111（32 位）。\n* 加 1 后结果变成 10000000 00000000 00000000 00000000，即 -2147483648（Integer.MIN\\_VALUE）。"
+ },
+ {
+ "id": 8,
+ "question": "自动类型转换、强制类型转换了解吗？",
+ "answer": "当把一个范围较小的数值或变量赋给另外一个范围较大的变量时，会进行自动类型转换；反之，需要强制转换。\n\n\n\n这就好像，小杯里的水倒进大杯没问题，但大杯的水倒进小杯就可能会溢出。\n\n①、`float f=3.4`，对吗？\n\n不正确。3.4 默认是双精度，将双精度赋值给浮点型属于下转型（down-casting，也称窄化）会造成精度丢失，因此需要强制类型转换`float f =(float)3.4;`或者写成`float f =3.4F`\n\n②、`short s1 = 1; s1 = s1 + 1；`对吗？`short s1 = 1; s1 += 1;`对吗？\n\n`short s1 = 1; s1 = s1 + 1;` 会编译出错，由于 1 是 int 类型，因此 s1+1 运算结果也是 int 型，需要强制转换类型才能赋值给 short 型。\n\n而 `short s1 = 1; s1 += 1;`可以正确编译，因为 `s1+= 1;`相当于 `s1 = (short(s1 + 1);` 其中有隐含的强制类型转换。"
+ },
+ {
+ "id": 9,
+ "question": "什么是自动拆箱/装箱？",
+ "answer": "* **装箱**：将基本数据类型转换为包装类型，例如 int 转换为 Integer。\n* **拆箱**：将包装类型转换为基本数据类型。\n\n\n\n举例：\n\n\n```java\nInteger i = 10; //装箱\nint n = i; //拆箱\n```\n\n\n再换句话说，i 是 Integer 类型，n 是 int 类型；变量 i 是包装器类，变量 n 是基本数据类型。"
+ },
+ {
+ "id": 10,
+ "question": "&和&&有什么区别？",
+ "answer": "`&` 是 `逻辑与`。\n\n`&&`是短路与运算。逻辑与跟短路与的差别是非常大的，虽然二者都要求运算符左右两端的布尔值都是 true，整个表达式的值才是 true。\n\n`&&`之所以称为短路运算是因为，如果`&&`左边的表达式的值是 false，右边的表达式会直接短路掉，不会进行运算。\n\n例如在验证用户登录时判定用户名不是 null 而且不是空字符串，应当写为`username != null && !username.equals(\"\")`，二者的顺序不能交换，更不能用 `&` 运算符，因为第一个条件如果不成立，根本不能进行字符串的 equals 比较，会抛出 。\n\n**注意**：逻辑或运算符（`|`）和短路或运算符（`||`）的差别也是类似。\n\n> 2024 年 12 月 23 日 更新到这里。"
+ },
+ {
+ "id": 11,
+ "question": "switch 语句能否用在 byte/long/String 类型上？",
+ "answer": "Java 5 以前 `switch(expr)` 中，expr 只能是 byte、short、char、int。\n\n从 Java 5 开始，Java 中引入了枚举类型， expr 也可以是 enum 类型。\n\n从 Java 7 开始，expr 还可以是字符串，但是长整型在目前所有的版本中都是不可以的。"
+ },
+ {
+ "id": 12,
+ "question": "break,continue,return 的区别及作用？",
+ "answer": "* break 跳出整个循环，不再执行循环(**结束当前的循环体**)\n* continue 跳出本次循环，继续执行下次循环(**结束正在执行的循环 进入下一个循环条件**)\n* return 程序返回，不再执行下面的代码(**结束当前的方法 直接返回**)\n\n"
+ },
+ {
+ "id": 13,
+ "question": "用效率最高的方法计算 2 乘以 8？",
+ "answer": "`2 << 3`。**位运算**，数字的二进制位左移三位相当于乘以 2 的三次方。"
+ },
+ {
+ "id": 14,
+ "question": "说说自增自减运算？",
+ "answer": "在写代码的过程中，常见的一种情况是需要某个整数类型变量增加 1 或减少 1，Java 提供了一种特殊的运算符，用于这种表达式，叫做自增运算符（++）和自减运算符（--）。\n\n++和--运算符可以放在变量之前，也可以放在变量之后。\n\n当运算符放在变量之前时(前缀)，先自增/减，再赋值；当运算符放在变量之后时(后缀)，先赋值，再自增/减。\n\n例如，当 `b = ++a` 时，先自增（自己增加 1），再赋值（赋值给 b）；当 `b = a++` 时，先赋值(赋值给 b)，再自增（自己增加 1）。也就是，++a 输出的是 a+1 的值，a++输出的是 a 值。\n\n用一句口诀就是：“符号在前就先加/减，符号在后就后加/减”。\n\n#### [看一下这段代码运行结果？](#看一下这段代码运行结果)\n\n\n```java\nint i = 1;\ni = i++;\nSystem.out.println(i);\n```\n\n\n答案是 1。有点离谱对不对。\n\n对于 JVM 而言，它对自增运算的处理，是会先定义一个临时变量来接收 i 的值，然后进行自增运算，最后又将临时变量赋给了值为 2 的 i，所以最后的结果为 1。\n\n相当于这样的代码：\n\n\n```java\nint i = 1；\nint temp = i;\ni++；\ni = temp;\nSystem.out.println(i);\n```\n\n\n#### [这段代码会输出什么？](#这段代码会输出什么)\n\n\n```java\nint count = 0;\nfor(int i = 0;i < 100;i++)\n{\n count = count++;\n}\nSystem.out.println(\"count = \"+count);\n```\n\n\n答案是 0。\n\n和上面的题目一样的道理，同样是用了临时变量，count 实际是等于临时变量的值。\n\n\n```java\nint autoAdd(int count)\n{\n int temp = count;\n count = count + 1;\n return temp;\n}\n```"
+ },
+ {
+ "id": 15,
+ "question": "float 是怎么表示小数的？（补充）",
+ "answer": "> 2024 年 04 月 21 日增补\n\n`float`类型的小数在计算机中是通过 IEEE 754 标准的单精度浮点数格式来表示的。\n\nV=(−1)S×M×2E\n\n* S：符号位，0 代表正数，1 代表负数；\n* M：尾数部分，用于表示数值的精度；比如说 1.25∗22；1.25 就是尾数；\n* R：基数，十进制中的基数是 10，二进制中的基数是 2；\n* E：指数部分，例如 10−1 中的 -1 就是指数。\n\n这种表示方法可以将非常大或非常小的数值用有限的位数表示出来，但这也意味着可能会有精度上的损失。\n\n单精度浮点数占用 4 字节（32 位），这 32 位被分为三个部分：符号位、指数部分和尾数部分。\n\n\n\n1. **符号位（Sign bit）**：1 位\n2. **指数部分（Exponent）**：10 位\n3. **尾数部分（Mantissa，或 Fraction）**：21 位\n\n按照这个规则，将十进制数 25.125 转换为浮点数，转换过程是这样的：\n\n1. 整数部分：25 转换为二进制是 11001；\n2. 小数部分：0.125 转换为二进制是 0.001；\n3. 用二进制科学计数法表示：25.125 = 1.001001×24\n\n符号位 S 是 0，表示正数；指数部分 E 是 4，转换为二进制是 100；尾数部分 M 是 1.001001。\n\n\n\n使用浮点数时需要注意，由于精度的限制，进行数学运算时可能会遇到舍入误差，特别是连续运算累积误差可能会变得显著。\n\n对于需要高精度计算的场景（如金融计算），可能需要考虑使用`BigDecimal`类来避免这种误差。"
+ },
+ {
+ "id": 16,
+ "question": "讲一下数据准确性高是怎么保证的？（补充）",
+ "answer": "> 2024 年 04 月 21 日增补\n\n在金融计算中，保证数据准确性有两种方案，一种使用 `BigDecimal`，一种将浮点数转换为整数 int 进行计算。\n\n肯定不能使用 `float` 和 `double` 类型，它们无法避免浮点数运算中常见的精度问题，因为这些数据类型采用二进制浮点数来表示，无法准确地表示，例如 `0.1`。\n\n\n```java\nBigDecimal num1 = new BigDecimal(\"0.1\");\nBigDecimal num2 = new BigDecimal(\"0.2\");\nBigDecimal sum = num1.add(num2);\nSystem.out.println(\"Sum of 0.1 and 0.2 using BigDecimal: \" + sum); // 输出 0.3，精确计算\n```\n\n\n在处理小额支付或计算时，通过转换为较小的货币单位（如分），这样不仅提高了运算速度，还保证了计算的准确性。\n\n\n```java\nint priceInCents = 199; // 商品价格199分\nint quantity = 3;\nint totalInCents = priceInCents * quantity; // 计算总价\nSystem.out.println(\"Total price in cents: \" + totalInCents); // 输出597分\n```"
+ }
+ ]
+ },
+ {
+ "id": 3,
+ "categoryName": "面向对象",
+ "questions": [
+ {
+ "id": 17,
+ "question": "⾯向对象和⾯向过程的区别?",
+ "answer": "面向过程是以过程为核心，通过函数完成任务，程序结构是函数+步骤组成的顺序流程。\n\n面向对象是以对象为核心，通过对象交互完成任务，程序结构是类和对象组成的模块化结构，代码可以通过继承、组合、多态等方式复用。\n\n\n\n在中，像 VO、DTO 都是业务抽象后的对象实体类，而 Service、Controller 则是业务逻辑的实现，这其实就是面向对象的思想。"
+ },
+ {
+ "id": 18,
+ "question": "面向对象编程有哪些特性？",
+ "answer": "面向对象编程有三大特性：封装、继承、多态。\n\n\n\n#### [封装是什么？](#封装是什么)\n\n封装是指将数据（属性，或者叫字段）和操作数据的方法（行为）捆绑在一起，形成一个独立的对象（类的实例）。\n\n\n```java\nclass Nvshen {\n private String name;\n private int age;\n\n public void setName(String name) {\n this.name = name;\n }\n\n public String getName() {\n return name;\n }\n\n public void setAge(int age) {\n this.age = age;\n }\n}\n```\n\n\n可以看得出，女神类对外没有提供 age 的 getter 方法，因为女神的年龄要保密。\n\n所以，封装是把一个对象的属性私有化，同时提供一些可以被外界访问的方法。\n\n#### [继承是什么？](#继承是什么)\n\n继承允许一个类（子类）继承现有类（父类或者基类）的属性和方法。以提高代码的复用性，建立类之间的层次关系。\n\n同时，子类还可以重写或者扩展从父类继承来的属性和方法，从而实现多态。\n\n\n```java\nclass Person {\n protected String name;\n protected int age;\n\n public void eat() {\n System.out.println(\"吃饭\");\n }\n}\n\nclass Student extends Person {\n private String school;\n\n public void study() {\n System.out.println(\"学习\");\n }\n}\n```\n\n\nStudent 类继承了 Person 类的属性（name、age）和方法（eat），同时还有自己的属性（school）和方法（study）。\n\n#### [什么是多态？](#什么是多态)\n\n多态允许不同类的对象对同一消息做出响应，但表现出不同的行为（即方法的多样性）。\n\n多态其实是一种能力——同一个行为具有不同的表现形式；换句话说就是，执行一段代码，Java 在运行时能根据对象类型的不同产生不同的结果。\n\n多态的前置条件有三个：\n\n* 子类继承父类\n* 子类重写父类的方法\n* 父类引用指向子类的对象\n\n\n```java\n//子类继承父类\nclass Wangxiaoer extends Wanger {\n public void write() { // 子类重写父类方法\n System.out.println(\"记住仇恨，表明我们要奋发图强的心智\");\n }\n\n public static void main(String[] args) {\n // 父类引用指向子类对象\n Wanger wanger = new Wangxiaoer();\n wanger.write();\n }\n}\n\nclass Wanger {\n public void write() {\n System.out.println(\"练习伴侣二是沙雕\");\n }\n}\n```\n\n\n#### [为什么Java里面要多组合少继承？](#为什么java里面要多组合少继承)\n\n继承适合描述“is-a”的关系，但继承容易导致类之间的强耦合，一旦父类发生改变，子类也要随之改变，违背了开闭原则（尽量不修改现有代码，而是添加新的代码来实现）。\n\n组合适合描述“has-a”或“can-do”的关系，通过在类中组合其他类，能够更灵活地扩展功能。组合避免了复杂的类继承体系，同时遵循了开闭原则和松耦合的设计原则。\n\n举个例子，假设我们采用继承，每种形状和样式的组合都会导致类的急剧增加：\n\n\n```java\n// 基类\nclass Shape {\n public void draw() {\n System.out.println(\"Drawing a shape\");\n }\n}\n\n// 圆形\nclass Circle extends Shape {\n @Override\n public void draw() {\n System.out.println(\"Drawing a circle\");\n }\n}\n\n// 带红色的圆形\nclass RedCircle extends Circle {\n @Override\n public void draw() {\n System.out.println(\"Drawing a red circle\");\n }\n}\n\n// 带绿色的圆形\nclass GreenCircle extends Circle {\n @Override\n public void draw() {\n System.out.println(\"Drawing a green circle\");\n }\n}\n\n// 类似的，对于矩形也要创建多个类\nclass Rectangle extends Shape {\n @Override\n public void draw() {\n System.out.println(\"Drawing a rectangle\");\n }\n}\n\nclass RedRectangle extends Rectangle {\n @Override\n public void draw() {\n System.out.println(\"Drawing a red rectangle\");\n }\n}\n```\n\n\n组合模式更加灵活，可以将形状和颜色分开，松耦合。\n\n\n```java\n// 形状接口\ninterface Shape {\n void draw();\n}\n\n// 颜色接口\ninterface Color {\n void applyColor();\n}\n```\n\n\n形状干形状的事情。\n\n\n```java\n// 圆形的实现\nclass Circle implements Shape {\n private Color color; // 通过组合的方式持有颜色对象\n\n public Circle(Color color) {\n this.color = color;\n }\n\n @Override\n public void draw() {\n System.out.print(\"Drawing a circle with \");\n color.applyColor(); // 调用颜色的逻辑\n }\n}\n\n// 矩形的实现\nclass Rectangle implements Shape {\n private Color color;\n\n public Rectangle(Color color) {\n this.color = color;\n }\n\n @Override\n public void draw() {\n System.out.print(\"Drawing a rectangle with \");\n color.applyColor();\n }\n}\n```\n\n\n颜色干颜色的事情。\n\n\n```java\n// 红色的实现\nclass RedColor implements Color {\n @Override\n public void applyColor() {\n System.out.println(\"red color\");\n }\n}\n\n// 绿色的实现\nclass GreenColor implements Color {\n @Override\n public void applyColor() {\n System.out.println(\"green color\");\n }\n}\n```"
+ },
+ {
+ "id": 19,
+ "question": "多态解决了什么问题？（补充）",
+ "answer": "> 2024 年 03 月 26 日增补\n\n多态指同一个接口或方法在不同的类中有不同的实现，比如说动态绑定，父类引用指向子类对象，方法的具体调用会延迟到运行时决定。\n\n举例，现在有一个父类 Wanger，一个子类 Wangxiaoer，都有一个 write 方法。现在有一个父类 Wanger 类型的变量 wanger，它在执行 `wanger.write()` 时，究竟调用父类 Wanger 的 `write()` 方法，还是子类 Wangxiaoer 的 `write()` 方法呢？\n\n\n```java\n//子类继承父类\nclass Wangxiaoer extends Wanger {\n public void write() { // 子类覆盖父类方法\n System.out.println(\"记住仇恨，表明我们要奋发图强的心智\");\n }\n\n public static void main(String[] args) {\n // 父类引用指向子类对象\n Wanger[] wangers = { new Wanger(), new Wangxiaoer() };\n\n for (Wanger wanger : wangers) {\n // 对象是练习伴侣二的时候输出：勿忘国耻\n // 对象是练习伴侣小二的时候输出：记住仇恨，表明我们要奋发图强的心智\n wanger.write();\n }\n }\n}\n\nclass Wanger {\n public void write() {\n System.out.println(\"勿忘国耻\");\n }\n}\n```\n\n\n答案是在运行时根据对象的类型进行后期绑定，编译器在编译阶段并不知道对象的类型，但是 Java 的方法调用机制能找到正确的方法体，然后执行，得到正确的结果，这就是多态的作用。\n\n#### [多态的实现原理是什么？](#多态的实现原理是什么)\n\n多态通过动态绑定实现，Java 使用虚方法表存储方法指针，方法调用时根据对象实际类型从虚方法表查找具体实现。\n\n"
+ },
+ {
+ "id": 20,
+ "question": "重载和重写的区别？",
+ "answer": "如果一个类有多个名字相同但参数个数不同的方法，我们通常称这些方法为方法重载（overload）。如果方法的功能是一样的，但参数不同，使用相同的名字可以提高程序的可读性。\n\n如果子类具有和父类一样的方法（参数相同、返回类型相同、方法名相同，但方法体可能不同），我们称之为方法重写（override）。方法重写用于提供父类已经声明的方法的特殊实现，是实现多态的基础条件。\n\n\n\n* 方法重载发生在同一个类中，同名的方法如果有不同的参数（参数类型不同、参数个数不同或者二者都不同）。\n* 方法重写发生在子类与父类之间，要求子类与父类具有相同的返回类型，方法名和参数列表，并且不能比父类的方法声明更多的异常，遵守里氏代换原则。\n\n#### [什么是里氏代换原则？](#什么是里氏代换原则)\n\n里氏代换原则也被称为李氏替换原则（Liskov Substitution Principle, LSP），其规定任何父类可以出现的地方，子类也一定可以出现。\n\n\n\nLSP 是继承复用的基石，只有当子类可以替换掉父类，并且单位功能不受到影响时，父类才能真正被复用，而子类也能够在父类的基础上增加新的行为。\n\n这意味着子类在扩展父类时，不应改变父类原有的行为。例如，如果有一个方法接受一个父类对象作为参数，那么传入该方法的任何子类对象也应该能正常工作。\n\n\n```java\nclass Bird {\n void fly() {\n System.out.println(\"鸟正在飞\");\n }\n}\n\nclass Duck extends Bird {\n @Override\n void fly() {\n System.out.println(\"鸭子正在飞\");\n }\n}\n\nclass Ostrich extends Bird {\n // Ostrich违反了LSP，因为鸵鸟不会飞，但却继承了会飞的鸟类\n @Override\n void fly() {\n throw new UnsupportedOperationException(\"鸵鸟不会飞\");\n }\n}\n```\n\n\n在这个例子中，Ostrich（鸵鸟）类违反了 LSP 原则，因为它改变了父类 Bird 的行为（即飞行）。设计时应该更加谨慎地使用继承关系，确保遵守 LSP 原则。\n\n除了李氏替换原则外，还有其他几个重要的面向对象设计原则，它们共同构成了 SOLID 原则，分别是：\n\n①、单一职责原则（Single Responsibility Principle, SRP），指一个类应该只有一个引起它变化的原因，即一个类只负责一项职责。这样做的目的是使类更加清晰，更容易理解和维护。\n\n②、开闭原则（Open-Closed Principle, OCP），指软件实体应该对扩展开放，对修改关闭。这意味着一个类应该通过扩展来实现新的功能，而不是通过修改已有的代码来实现。\n\n举个例子，在不遵守开闭原则的情况下，有一个需要处理不同形状的绘图功能类。\n\n\n```java\nclass ShapeDrawer {\n public void draw(Shape shape) {\n if (shape instanceof Circle) {\n drawCircle((Circle) shape);\n } else if (shape instanceof Rectangle) {\n drawRectangle((Rectangle) shape);\n }\n }\n \n private void drawCircle(Circle circle) {\n // 画圆形\n }\n \n private void drawRectangle(Rectangle rectangle) {\n // 画矩形\n }\n}\n```\n\n\n每增加一种形状，就需要修改一次 draw 方法，这违反了开闭原则。正确的做法是通过继承和多态来实现新的形状类，然后在 ShapeDrawer 中添加新的 draw 方法。\n\n\n```java\n// 抽象的 Shape 类\nabstract class Shape {\n public abstract void draw();\n}\n\n// 具体的 Circle 类\nclass Circle extends Shape {\n @Override\n public void draw() {\n // 画圆形\n }\n}\n\n// 具体的 Rectangle 类\nclass Rectangle extends Shape {\n @Override\n public void draw() {\n // 画矩形\n }\n}\n\n// 使用开闭原则的 ShapeDrawer 类\nclass ShapeDrawer {\n public void draw(Shape shape) {\n shape.draw(); // 调用多态的 draw 方法\n }\n}\n```\n\n\n③、接口隔离原则（Interface Segregation Principle, ISP），指客户端不应该依赖它不需要的接口。这意味着设计接口时应该尽量精简，不应该设计臃肿庞大的接口。\n\n④、依赖倒置原则（Dependency Inversion Principle, DIP），指高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。这意味着设计时应该尽量依赖接口或抽象类，而不是实现类。"
+ },
+ {
+ "id": 21,
+ "question": "访问修饰符 public、private、protected、以及默认时的区别？",
+ "answer": "Java 中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。\n\n* **default** （即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。可以修饰在类、接口、变量、方法。\n* **private** : 在同一类内可见。可以修饰变量、方法。**注意：不能修饰类（外部类）**\n* **public** : 对所有类可见。可以修饰类、接口、变量、方法\n* **protected** : 对同一包内的类和所有子类可见。可以修饰变量、方法。**注意：不能修饰类（外部类）**。\n\n"
+ },
+ {
+ "id": 22,
+ "question": "this 关键字有什么作用？",
+ "answer": "this 是自身的一个对象，代表对象本身，可以理解为：**指向对象本身的一个指针**。\n\nthis 的用法在 Java 中大体可以分为 3 种：\n\n1. 普通的直接引用，this 相当于是指向当前对象本身\n2. 形参与成员变量名字重名，用 this 来区分：\n\n\n```java\npublic Person(String name,int age){\n this.name=name;\n this.age=age;\n}\n```\n\n\n3. 引用本类的构造方法"
+ },
+ {
+ "id": 23,
+ "question": "抽象类和接口有什么区别？",
+ "answer": "一个类只能继承一个抽象类；但一个类可以实现多个接口。所以我们在新建线程类的时候一般推荐使用实现 Runnable 接口的方式，这样线程类还可以继承其他类，而不单单是 Thread 类。\n\n抽象类符合 is-a 的关系，而接口更像是 has-a 的关系，比如说一个类可以序列化的时候，它只需要实现 Serializable 接口就可以了，不需要去继承一个序列化类。\n\n抽象类更多地是用来为多个相关的类提供一个共同的基础框架，包括状态的初始化，而接口则是定义一套行为标准，让不同的类可以实现同一接口，提供行为的多样化实现。\n\n#### [抽象类可以定义构造方法吗？](#抽象类可以定义构造方法吗)\n\n可以，抽象类可以有构造方法。\n\n\n```java\nabstract class Animal {\n protected String name;\n\n public Animal(String name) {\n this.name = name;\n }\n\n public abstract void makeSound();\n}\n\npublic class Dog extends Animal {\n private int age;\n\n public Dog(String name, int age) {\n super(name); // 调用抽象类的构造函数\n this.age = age;\n }\n\n @Override\n public void makeSound() {\n System.out.println(name + \" says: Bark\");\n }\n}\n```\n\n\n#### [接口可以定义构造方法吗？](#接口可以定义构造方法吗)\n\n不能，接口主要用于定义一组方法规范，没有具体的实现细节。\n\n\n\n#### [Java支持多继承吗？](#java支持多继承吗)\n\nJava 不支持多继承，一个类只能继承一个类，多继承会引发菱形继承问题。\n\n\n```java\nclass A {\n void show() { System.out.println(\"A\"); }\n}\n\nclass B extends A {\n void show() { System.out.println(\"B\"); }\n}\n\nclass C extends A {\n void show() { System.out.println(\"C\"); }\n}\n\n// 如果 Java 支持多继承\nclass D extends B, C {\n // 调用 show() 方法时，D 应该调用 B 的 show() 还是 C 的 show()？\n}\n```\n\n\n#### [接口可以多继承吗？](#接口可以多继承吗)\n\n接口可以多继承，一个接口可以继承多个接口，使用逗号分隔。\n\n\n```java\ninterface InterfaceA {\n void methodA();\n}\n\ninterface InterfaceB {\n void methodB();\n}\n\ninterface InterfaceC extends InterfaceA, InterfaceB {\n void methodC();\n}\n\nclass MyClass implements InterfaceC {\n public void methodA() {\n System.out.println(\"Method A\");\n }\n\n public void methodB() {\n System.out.println(\"Method B\");\n }\n\n public void methodC() {\n System.out.println(\"Method C\");\n }\n\n public static void main(String[] args) {\n MyClass myClass = new MyClass();\n myClass.methodA();\n myClass.methodB();\n myClass.methodC();\n }\n}\n```\n\n\n在上面的例子中，InterfaceA 和 InterfaceB 是两个独立的接口。\n\nInterfaceC 继承了 InterfaceA 和 InterfaceB，并且定义了自己的方法 methodC。\n\nMyClass 实现了 InterfaceC，因此需要实现 InterfaceA 和 InterfaceB 中的方法 methodA 和 methodB，以及 InterfaceC 中的方法 methodC。\n\n#### [继承和抽象的区别？](#继承和抽象的区别)\n\n继承是一种允许子类继承父类属性和方法的机制。通过继承，子类可以重用父类的代码。\n\n抽象是一种隐藏复杂性和只显示必要部分的技术。在面向对象编程中，抽象可以通过抽象类和接口实现。\n\n#### [抽象类和普通类的区别？](#抽象类和普通类的区别)\n\n抽象类使用 abstract 关键字定义，不能被实例化，只能作为其他类的父类。普通类没有 abstract 关键字，可以直接实例化。\n\n抽象类可以包含抽象方法和非抽象方法。抽象方法没有方法体，必须由子类实现。普通类只能包含非抽象方法。\n\n\n```java\nabstract class Animal {\n // 抽象方法\n public abstract void makeSound();\n\n // 非抽象方法\n public void eat() {\n System.out.println(\"This animal is eating.\");\n }\n}\n\nclass Dog extends Animal {\n // 实现抽象方法\n @Override\n public void makeSound() {\n System.out.println(\"Woof\");\n }\n}\n\npublic class Test {\n public static void main(String[] args) {\n Dog dog = new Dog();\n dog.makeSound(); // 输出 \"Woof\"\n dog.eat(); // 输出 \"This animal is eating.\"\n }\n}\n```"
+ },
+ {
+ "id": 24,
+ "question": "成员变量与局部变量的区别有哪些？",
+ "answer": "1. **从语法形式上看**：成员变量是属于类的，⽽局部变量是在⽅法中定义的变量或是⽅法的参数；成员变量可以被 public , private , static 等修饰符所修饰，⽽局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。\n2. **从变量在内存中的存储⽅式来看**：如果成员变量是使⽤ static 修饰的，那么这个成员变量是属于类的，如果没有使⽤ static 修饰，这个成员变量是属于实例的。对象存于堆内存，如果局部变量类型为基本数据类型，那么存储在栈内存，如果为引⽤数据类型，那存放的是指向堆内存对象的引⽤或者是指向常量池中的地址。\n3. **从变量在内存中的⽣存时间上看**：成员变量是对象的⼀部分，它随着对象的创建⽽存在，⽽局部变量随着⽅法的调⽤⽽⾃动消失。\n4. **成员变量如果没有被赋初值**：则会⾃动以类型的默认值⽽赋值（⼀种情况例外:被 final 修饰的成员变量也必须显式地赋值），⽽局部变量则不会⾃动赋值。"
+ },
+ {
+ "id": 25,
+ "question": "static 关键字了解吗？",
+ "answer": "static 关键字可以用来修饰变量、方法、代码块和内部类，以及导入包。\n\n| 修饰对象 | 作用 |\n| --- | --- |\n| 变量 | 静态变量，类级别变量，所有实例共享同一份数据。 |\n| 方法 | 静态方法，类级别方法，与实例无关。 |\n| 代码块 | 在类加载时初始化一些数据，只执行一次。 |\n| 内部类 | 与外部类绑定但独立于外部类实例。 |\n| 导入 | 可以直接访问静态成员，无需通过类名引用，简化代码书写，但会降低代码可读性。 |\n\n#### [静态变量和实例变量的区别？](#静态变量和实例变量的区别)\n\n**静态变量:** 是被 static 修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多少个对象，静态变量在内存中有且仅有一个副本。\n\n**实例变量:** 必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。\n\n#### [静态⽅法和实例⽅法有何不同?](#静态方法和实例方法有何不同)\n\n类似地。\n\n**静态方法**：static 修饰的方法，也被称为类方法。在外部调⽤静态⽅法时，可以使⽤\"**类名.⽅法名**\"的⽅式，也可以使⽤\"**对象名.⽅法名**\"的⽅式。静态方法里不能访问类的非静态成员变量和方法。\n\n**实例⽅法**：依存于类的实例，需要使用\"**对象名.⽅法名**\"的⽅式调用；可以访问类的所有成员变量和方法。"
+ },
+ {
+ "id": 26,
+ "question": "final 关键字有什么作用？",
+ "answer": "①、当 final 修饰一个类时，表明这个类不能被继承。比如，String 类、Integer 类和其他包装类都是用 final 修饰的。\n\n\n\n②、当 final 修饰一个方法时，表明这个方法不能被重写（Override）。也就是说，如果一个类继承了某个类，并且想要改变父类中被 final 修饰的方法的行为，是不被允许的。\n\n③、当 final 修饰一个变量时，表明这个变量的值一旦被初始化就不能被修改。\n\n如果是基本数据类型的变量，其数值一旦在初始化之后就不能更改；如果是引用类型的变量，在对其初始化之后就不能再让其指向另一个对象。\n\n\n\n但是引用指向的对象内容可以改变。\n\n"
+ },
+ {
+ "id": 27,
+ "question": "final、finally、finalize 的区别？",
+ "answer": "①、，可以修饰类、方法和变量。当 final 修饰一个类时，表明这个类不能被继承；当 final 修饰一个方法时，表明这个方法不能被重写；当 final 修饰一个变量时，表明这个变量是个常量，一旦赋值后，就不能再被修改了。\n\n②、finally 是 Java 中异常处理的一部分，用来创建 try 块后面的 finally 块。无论 try 块中的代码是否抛出异常，finally 块中的代码总是会被执行。通常，finally 块被用来释放资源，如关闭文件、数据库连接等。\n\n③、finalize 是的一个方法，用于在垃圾回收器将对象从内存中清除出去之前做一些必要的清理工作。\n\n这个方法在垃圾回收器准备释放对象占用的内存之前被自动调用。我们不能显式地调用 finalize 方法，因为它总是由垃圾回收器在适当的时间自动调用。\n\n"
+ },
+ {
+ "id": 28,
+ "question": "==和 equals 的区别？",
+ "answer": "在 Java 中，`==` 操作符和 `equals()` 方法用于比较两个对象：\n\n①、==：用于比较两个对象的引用，即它们是否指向同一个对象实例。\n\n如果两个变量引用同一个对象实例，`==` 返回 `true`，否则返回 `false`。\n\n对于基本数据类型（如 `int`, `double`, `char` 等），`==` 比较的是值是否相等。\n\n②、**equals() 方法**：用于比较两个对象的内容是否相等。默认情况下，`equals()` 方法的行为与 `==` 相同，即比较对象引用，如在超类 Object 中：\n\n\n```java\npublic boolean equals(Object obj) {\n return (this == obj);\n}\n```\n\n\n然而，`equals()` 方法通常被各种类重写。例如，`String` 类重写了 `equals()` 方法，以便它可以比较两个字符串的字符内容是否完全一样。\n\n\n\n举个例子：\n\n\n```java\nString a = new String(\"练习伴侣二\");\nString b = new String(\"练习伴侣二\");\n\n// 使用 == 比较\nSystem.out.println(a == b); // 输出 false，因为 a 和 b 引用不同的对象\n\n// 使用 equals() 比较\nSystem.out.println(a.equals(b)); // 输出 true，因为 a 和 b 的内容相同\n```"
+ },
+ {
+ "id": 29,
+ "question": "为什么重写 equals 时必须重写 hashCode ⽅法？",
+ "answer": "因为基于哈希的集合类（如 HashMap）需要基于这一点来正确存储和查找对象。\n\n具体地说，HashMap 通过对象的哈希码将其存储在不同的“桶”中，当查找对象时，它需要使用 key 的哈希码来确定对象在哪个桶中，然后再通过 `equals()` 方法找到对应的对象。\n\n如果重写了 `equals()`方法而没有重写 `hashCode()`方法，那么被认为相等的对象可能会有不同的哈希码，从而导致无法在 HashMap 中正确处理这些对象。\n\n#### [什么是 hashCode 方法？](#什么是-hashcode-方法)\n\n`hashCode()` 方法的作⽤是获取哈希码，它会返回⼀个 int 整数，定义在 中， 是一个本地⽅法。\n\n\n```java\npublic native int hashCode();\n```\n\n\n#### [为什么要有 hashCode 方法？](#为什么要有-hashcode-方法)\n\nhashCode 方法主要用来获取对象的哈希码，哈希码是由对象的内存地址或者对象的属性计算出来的，它是⼀个 int 类型的整数，通常是不会重复的，因此可以用来作为键值对的建，以提高查询效率。\n\n例如 中的 key 就是通过 hashCode 来实现的，通过调用 hashCode 方法获取键的哈希码，并将其与右移 16 位的哈希码进行异或运算。\n\n\n```java\nstatic final int hash(Object key) {\n int h;\n return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```\n\n\n#### [为什么两个对象有相同的 hashcode 值，它们也不⼀定相等？](#为什么两个对象有相同的-hashcode-值-它们也不一定相等)\n\n这主要是由于哈希码（hashCode）的本质和目的所决定的。\n\n哈希码是通过哈希函数将对象中映射成一个整数值，其主要目的是在哈希表中快速定位对象的存储位置。\n\n由于哈希函数将一个较大的输入域映射到一个较小的输出域，不同的输入值（即不同的对象）可能会产生相同的输出值（即相同的哈希码）。\n\n这种情况被称为哈希冲突。当两个不相等的对象发生哈希冲突时，它们会有相同的 hashCode。\n\n为了解决哈希冲突的问题，哈希表在处理键时，不仅会比较键对象的哈希码，还会使用 equals 方法来检查键对象是否真正相等。如果两个对象的哈希码相同，但通过 equals 方法比较结果为 false，那么这两个对象就不被视为相等。\n\n\n```java\nif (p.hash == hash &&\n ((k = p.key) == key || (key != null && key.equals(k))))\n e = p;\n```\n\n\n#### [hashCode 和 equals 方法的关系？](#hashcode-和-equals-方法的关系)\n\n如果两个对象通过 equals 相等，它们的 hashCode 必须相等。否则会导致哈希表类数据结构（如 HashMap、HashSet）的行为异常。\n\n在哈希表中，如果 equals 相等但 hashCode 不相等，哈希表可能无法正确处理这些对象，导致重复元素或键值冲突等问题。"
+ },
+ {
+ "id": 30,
+ "question": "Java 是值传递，还是引用传递？",
+ "answer": "Java 是值传递，不是引用传递。\n\n当一个对象被作为参数传递到方法中时，参数的值就是该对象的引用。引用的值是对象在堆中的地址。\n\n对象是存储在堆中的，所以传递对象的时候，可以理解为把变量存储的对象地址给传递过去。\n\n\n\n#### [引用类型的变量有什么特点？](#引用类型的变量有什么特点)\n\n引用类型的变量存储的是对象的地址，而不是对象本身。因此，引用类型的变量在传递时，传递的是对象的地址，也就是说，传递的是引用的值。"
+ },
+ {
+ "id": 31,
+ "question": "说说深拷贝和浅拷贝的区别?",
+ "answer": "在 Java 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两种拷贝对象的方式，它们在拷贝对象的方式上有很大不同。\n\n\n\n浅拷贝会创建一个新对象，但这个新对象的属性（字段）和原对象的属性完全相同。如果属性是基本数据类型，拷贝的是基本数据类型的值；如果属性是引用类型，拷贝的是引用地址，因此新旧对象共享同一个引用对象。\n\n浅拷贝的实现方式为：实现 Cloneable 接口并重写 `clone()` 方法。\n\n\n```java\nclass Person implements Cloneable {\n String name;\n int age;\n Address address;\n\n public Person(String name, int age, Address address) {\n this.name = name;\n this.age = age;\n this.address = address;\n }\n\n @Override\n protected Object clone() throws CloneNotSupportedException {\n return super.clone();\n }\n}\n\nclass Address {\n String city;\n\n public Address(String city) {\n this.city = city;\n }\n}\n\npublic class Main {\n public static void main(String[] args) throws CloneNotSupportedException {\n Address address = new Address(\"河南省洛阳市\");\n Person person1 = new Person(\"练习伴侣二\", 18, address);\n Person person2 = (Person) person1.clone();\n\n System.out.println(person1.address == person2.address); // true\n }\n}\n```\n\n\n深拷贝也会创建一个新对象，但会递归地复制所有的引用对象，确保新对象和原对象完全独立。新对象与原对象的任何更改都不会相互影响。\n\n深拷贝的实现方式有：手动复制所有的引用对象，或者使用序列化与反序列化。\n\n①、手动拷贝\n\n\n```java\nclass Person {\n String name;\n int age;\n Address address;\n\n public Person(String name, int age, Address address) {\n this.name = name;\n this.age = age;\n this.address = address;\n }\n\n public Person(Person person) {\n this.name = person.name;\n this.age = person.age;\n this.address = new Address(person.address.city);\n }\n}\n\nclass Address {\n String city;\n\n public Address(String city) {\n this.city = city;\n }\n}\n\npublic class Main {\n public static void main(String[] args) {\n Address address = new Address(\"河南省洛阳市\");\n Person person1 = new Person(\"练习伴侣二\", 18, address);\n Person person2 = new Person(person1);\n\n System.out.println(person1.address == person2.address); // false\n }\n}\n```\n\n\n②、序列化与反序列化\n\n\n```java\nimport java.io.*;\n\nclass Person implements Serializable {\n String name;\n int age;\n Address address;\n\n public Person(String name, int age, Address address) {\n this.name = name;\n this.age = age;\n this.address = address;\n }\n\n public Person deepClone() throws IOException, ClassNotFoundException {\n ByteArrayOutputStream bos = new ByteArrayOutputStream();\n ObjectOutputStream oos = new ObjectOutputStream(bos);\n oos.writeObject(this);\n\n ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());\n ObjectInputStream ois = new ObjectInputStream(bis);\n return (Person) ois.readObject();\n }\n}\n\nclass Address implements Serializable {\n String city;\n\n public Address(String city) {\n this.city = city;\n }\n}\n\npublic class Main {\n public static void main(String[] args) throws IOException, ClassNotFoundException {\n Address address = new Address(\"河南省洛阳市\");\n Person person1 = new Person(\"练习伴侣二\", 18, address);\n Person person2 = person1.deepClone();\n\n System.out.println(person1.address == person2.address); // false\n }\n}\n```"
+ },
+ {
+ "id": 32,
+ "question": "Java 创建对象有哪几种方式？",
+ "answer": "\n\nJava 有四种创建对象的方式：\n\n①、new 关键字创建，这是最常见和直接的方式，通过调用类的构造方法来创建对象。\n\n\n```java\nPerson person = new Person();\n```\n\n\n②、反射机制创建，反射机制允许在运行时创建对象，并且可以访问类的私有成员，在框架和工具类中比较常见。\n\n\n```java\nClass clazz = Class.forName(\"Person\");\nPerson person = (Person) clazz.newInstance();\n```\n\n\n③、clone 拷贝创建，通过 clone 方法创建对象，需要实现 Cloneable 接口并重写 clone 方法。\n\n\n```java\nPerson person = new Person();\nPerson person2 = (Person) person.clone();\n```\n\n\n④、序列化机制创建，通过序列化将对象转换为字节流，再通过反序列化从字节流中恢复对象。需要实现 Serializable 接口。\n\n\n```java\nPerson person = new Person();\nObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(\"person.txt\"));\noos.writeObject(person);\nObjectInputStream ois = new ObjectInputStream(new FileInputStream(\"person.txt\"));\nPerson person2 = (Person) ois.readObject();\n```\n\n\n#### [new 子类的时候，子类和父类静态代码块，构造方法的执行顺序](#new-子类的时候-子类和父类静态代码块-构造方法的执行顺序)\n\n在 Java 中，当创建一个子类对象时，子类和父类的静态代码块、构造方法的执行顺序遵循一定的规则。这些规则主要包括以下几个步骤：\n\n1. 首先执行父类的静态代码块（仅在类第一次加载时执行）。\n2. 接着执行子类的静态代码块（仅在类第一次加载时执行）。\n3. 再执行父类的构造方法。\n4. 最后执行子类的构造方法。\n\n下面是一个详细的代码示例：\n\n\n```java\nclass Parent {\n // 父类静态代码块\n static {\n System.out.println(\"父类静态代码块\");\n }\n\n // 父类构造方法\n public Parent() {\n System.out.println(\"父类构造方法\");\n }\n}\n\nclass Child extends Parent {\n // 子类静态代码块\n static {\n System.out.println(\"子类静态代码块\");\n }\n\n // 子类构造方法\n public Child() {\n System.out.println(\"子类构造方法\");\n }\n}\n\npublic class Main {\n public static void main(String[] args) {\n new Child();\n }\n}\n```\n\n\n执行上述代码时，输出结果如下：\n\n\n```text\n父类静态代码块\n子类静态代码块\n父类构造方法\n子类构造方法\n```\n\n\n* 静态代码块：在类加载时执行，仅执行一次，按父类-子类的顺序执行。\n* 构造方法：在每次创建对象时执行，按父类-子类的顺序执行，先初始化块后构造方法。"
+ }
+ ]
+ },
+ {
+ "id": 4,
+ "categoryName": "String",
+ "questions": [
+ {
+ "id": 33,
+ "question": "String 是 Java 基本数据类型吗？可以被继承吗？",
+ "answer": "不是，`String` 是一个类，属于引用数据类型。Java 的基本数据类型包括八种：四种整型（`byte`、`short`、`int`、`long`）、两种浮点型（`float`、`double`）、一种字符型（`char`）和一种布尔型（`boolean`）。\n\n#### [String 类可以继承吗？](#string-类可以继承吗)\n\n不行。String 类使用 final 修饰，是所谓的不可变类，无法被继承。\n\n#### [String 有哪些常用方法？](#string-有哪些常用方法)\n\n我自己常用的有：\n\n1. `length()` - 返回字符串的长度。\n2. `charAt(int index)` - 返回指定位置的字符。\n3. `substring(int beginIndex, int endIndex)` - 返回字符串的一个子串，从 `beginIndex` 到 `endIndex-1`。\n4. `contains(CharSequence s)` - 检查字符串是否包含指定的字符序列。\n5. `equals(Object anotherObject)` - 比较两个字符串的内容是否相等。\n6. `indexOf(int ch)` 和 `indexOf(String str)` - 返回指定字符或字符串首次出现的位置。\n7. `replace(char oldChar, char newChar)` 和 `replace(CharSequence target, CharSequence replacement)` - 替换字符串中的字符或字符序列。\n8. `trim()` - 去除字符串两端的空白字符。\n9. `split(String regex)` - 根据给定正则表达式的匹配拆分此字符串。"
+ },
+ {
+ "id": 34,
+ "question": "String 和 StringBuilder、StringBuffer 的区别？",
+ "answer": "`String`、`StringBuilder`和`StringBuffer`在 Java 中都是用于处理字符串的，它们之间的区别是，String 是不可变的，平常开发用得最多，当遇到大量字符串连接时，就用 StringBuilder，它不会生成很多新的对象，StringBuffer 和 StringBuilder 类似，但每个方法上都加了 synchronized 关键字，所以是线程安全的。\n\n#### [请说说 String 的特点](#请说说-string-的特点)\n\n* `String`类的对象是。也就是说，一旦一个`String`对象被创建，它所包含的字符串内容是不可改变的。\n* 每次对`String`对象进行修改操作（如拼接、替换等）实际上都会生成一个新的`String`对象，而不是修改原有对象。这可能会导致内存和性能开销，尤其是在大量字符串操作的情况下。\n\n#### [请说说 StringBuilder 的特点](#请说说-stringbuilder-的特点)\n\n* `StringBuilder`提供了一系列的方法来进行字符串的增删改查操作，这些操作都是直接在原有字符串对象的底层数组上进行的，而不是生成新的 String 对象。\n* `StringBuilder`不是线程安全的。这意味着在没有外部同步的情况下，它不适用于多线程环境。\n* 相比于`String`，在进行频繁的字符串修改操作时，`StringBuilder`能提供更好的性能。 Java 中的字符串连`+`操作其实就是通过`StringBuilder`实现的。\n\n#### [请说说 StringBuffer 的特点](#请说说-stringbuffer-的特点)\n\n`StringBuffer`和`StringBuilder`类似，但`StringBuffer`是线程安全的，方法前面都加了`synchronized`关键字。\n\n#### [请总结一下使用场景](#请总结一下使用场景)\n\n* **String**：适用于字符串内容不会改变的场景，比如说作为 HashMap 的 key。\n* **StringBuilder**：适用于单线程环境下需要频繁修改字符串内容的场景，比如在循环中拼接或修改字符串，是 String 的完美替代品。\n* **StringBuffer**：现在已经不怎么用了，因为一般不会在多线程场景下去频繁的修改字符串内容。"
+ },
+ {
+ "id": 35,
+ "question": "String str1 = new String(\"abc\") 和 String str2 = \"abc\" 的区别？",
+ "answer": "直接使用双引号为字符串变量赋值时，Java 首先会检查字符串常量池中是否已经存在相同内容的字符串。\n\n如果存在，Java 就会让新的变量引用池中的那个字符串；如果不存在，它会创建一个新的字符串，放入池中，并让变量引用它。\n\n使用 `new String(\"abc\")` 的方式创建字符串时，实际分为两步：\n\n* 第一步，先检查字符串字面量 \"abc\" 是否在字符串常量池中，如果没有则创建一个；如果已经存在，则引用它。\n* 第二步，在堆中再创建一个新的字符串对象，并将其初始化为字符串常量池中 \"abc\" 的一个副本。\n\n\n\n也就是说：\n\n\n```java\nString s1 = \"练习伴侣二\";\nString s2 = \"练习伴侣二\";\nString s3 = new String(\"练习伴侣二\");\n\nSystem.out.println(s1 == s2); // 输出 true，因为 s1 和 s2 引用的是字符串常量池中同一个对象。\nSystem.out.println(s1 == s3); // 输出 false，因为 s3 是通过 new 关键字显式创建的，指向堆上不同的对象。\n```\n\n\n#### [String s = new String(\"abc\")创建了几个对象？](#string-s-new-string-abc-创建了几个对象)\n\n字符串常量池中如果之前已经有一个，则不再创建新的，直接引用；如果没有，则创建一个。\n\n堆中肯定有一个，因为只要使用了 new 关键字，肯定会在堆中创建一个。"
+ },
+ {
+ "id": 36,
+ "question": "String 是不可变类吗？字符串拼接是如何实现的？",
+ "answer": "String 是不可变的，这意味着一旦一个 String 对象被创建，其存储的文本内容就不能被改变。这是因为：\n\n①、不可变性使得 String 对象在使用中更加安全。因为字符串经常用作参数传递给其他 Java 方法，例如网络连接、打开文件等。\n\n如果 String 是可变的，这些方法调用的参数值就可能在不知不觉中被改变，从而导致网络连接被篡改、文件被莫名其妙地修改等问题。\n\n②、不可变的对象因为状态不会改变，所以更容易进行缓存和重用。字符串常量池的出现正是基于这个原因。\n\n当代码中出现相同的字符串字面量时，JVM 会确保所有的引用都指向常量池中的同一个对象，从而节约内存。\n\n③、因为 String 的内容不会改变，所以它的哈希值也就固定不变。这使得 String 对象特别适合作为 HashMap 或 HashSet 等集合的键，因为计算哈希值只需要进行一次，提高了哈希表操作的效率。\n\n#### [字符串拼接是如何实现的？](#字符串拼接是如何实现的)\n\n因为 String 是不可变的，因此通过“**+**”操作符进行的字符串拼接，会生成新的字符串对象。\n\n例如：\n\n\n```java\nString a = \"hello \";\nString b = \"world!\";\nString ab = a + b;\n```\n\n\na 和 b 是通过双引号定义的，所以会在字符串常量池中，而 ab 是通过“+”操作符拼接的，所以会在堆中生成一个新的对象。\n\n\n\nJava 8 时，JDK 对“+”号的字符串拼接进行了优化，Java 会在编译期基于 StringBuilder 的 append 方法进行拼接。\n\n下面是通过 `javap -verbose` 命令反编译后的字节码，能清楚的看到 StringBuilder 的创建和 append 方法的调用。\n\n\n```java\nstack=2, locals=4, args_size=1\n 0: ldc #2 // String hello\n 2: astore_1\n 3: ldc #3 // String world!\n 5: astore_2\n 6: new #4 // class java/lang/StringBuilder\n 9: dup\n 10: invokespecial #5 // Method java/lang/StringBuilder.\"\":()V\n 13: aload_1\n 14: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;\n 17: aload_2\n 18: invokevirtual #6 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;\n 21: invokevirtual #7 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;\n 24: astore_3\n 25: return\n```\n\n\n也就是说，上面的代码相当于：\n\n\n```java\nString a = \"hello \";\nString b = \"world!\";\nStringBuilder sb = new StringBuilder();\nsb.append(a);\nsb.append(b);\nString ab = sb.toString();\n```\n\n\n因此，如果笼统地讲，通过加号拼接字符串时会创建多个 String 对象是不准确的。因为加号拼接在编译期还会创建一个 StringBuilder 对象，最终调用 `toString()` 方法的时候再返回一个新的 String 对象。\n\n\n```java\n@Override\npublic String toString() {\n // Create a copy, don't share the array\n return new String(value, 0, count);\n}\n```\n\n\n那除了使用 `+` 号来拼接字符串，还有 `StringBuilder.append()`、`String.join()` 等方式。\n\n#### [如何保证 String 不可变？](#如何保证-string-不可变)\n\n第一，String 类内部使用一个私有的字符数组来存储字符串数据。这个字符数组在创建字符串时被初始化，之后不允许被改变。\n\n\n```java\nprivate final char value[];\n```\n\n\n第二，String 类没有提供任何可以修改其内容的公共方法，像 concat 这些看似修改字符串的操作，实际上都是返回一个新创建的字符串对象，而原始字符串对象保持不变。\n\n\n```java\npublic String concat(String str) {\n if (str.isEmpty()) {\n return this;\n }\n int len = value.length;\n int otherLen = str.length();\n char buf[] = Arrays.copyOf(value, len + otherLen);\n str.getChars(buf, len);\n return new String(buf, true);\n}\n```\n\n\n第三，String 类本身被声明为 final，这意味着它不能被继承。这防止了子类可能通过添加修改方法来改变字符串内容的可能性。\n\n\n```java\npublic final class String\n```"
+ },
+ {
+ "id": 37,
+ "question": "intern 方法有什么作用？",
+ "answer": "JDK 源码里已经对这个方法进行了说明：\n\n\n```java\n* \n* When the intern method is invoked, if the pool already contains a\n* string equal to this {@code String} object as determined by\n* the {@link #equals(Object)} method, then the string from the pool is\n* returned. Otherwise, this {@code String} object is added to the\n* pool and a reference to this {@code String} object is returned.\n*
\n```\n\n\n意思也很好懂：\n\n* 如果当前字符串内容存在于字符串常量池（即 equals()方法为 true，也就是内容一样），直接返回字符串常量池中的字符串\n* 否则，将此 String 对象添加到池中，并返回 String 对象的引用"
+ }
+ ]
+ },
+ {
+ "id": 5,
+ "categoryName": "Integer",
+ "questions": [
+ {
+ "id": 38,
+ "question": "Integer a= 127，Integer b = 127；Integer c= 128，Integer d = 128；相等吗?",
+ "answer": "a 和 b 相等，c 和 d 不相等。\n\n这个问题涉及到 Java 的自动装箱机制以及`Integer`类的缓存机制。\n\n对于第一对：\n\n\n```java\nInteger a = 127;\nInteger b = 127;\n```\n\n\n`a`和`b`是相等的。这是因为 Java 在自动装箱过程中，会使用`Integer.valueOf()`方法来创建`Integer`对象。\n\n`Integer.valueOf()`方法会针对数值在-128 到 127 之间的`Integer`对象使用缓存。因此，`a`和`b`实际上引用了常量池中相同的`Integer`对象。\n\n对于第二对：\n\n\n```java\nInteger c = 128;\nInteger d = 128;\n```\n\n\n`c`和`d`不相等。这是因为 128 超出了`Integer`缓存的范围(-128 到 127)。\n\n因此，自动装箱过程会为`c`和`d`创建两个不同的`Integer`对象，它们有不同的引用地址。\n\n可以通过`==`运算符来检查它们是否相等：\n\n\n```java\nSystem.out.println(a == b); // 输出true\nSystem.out.println(c == d); // 输出false\n```\n\n\n要比较`Integer`对象的数值是否相等，应该使用`equals`方法，而不是`==`运算符：\n\n\n```java\nSystem.out.println(a.equals(b)); // 输出true\nSystem.out.println(c.equals(d)); // 输出true\n```\n\n\n使用`equals`方法时，`c`和`d`的比较结果为`true`，因为`equals`比较的是对象的数值，而不是引用地址。\n\n#### [什么是 Integer 缓存？](#什么是-integer-缓存)\n\n就拿 Integer 的缓存吃来说吧。根据实践发现，大部分的数据操作都集中在值比较小的范围，因此 Integer 搞了个缓存池，默认范围是 -128 到 127。\n\n\n\n当我们使用自动装箱来创建这个范围内的 Integer 对象时，Java 会直接从缓存中返回一个已存在的对象，而不是每次都创建一个新的对象。这意味着，对于这个值范围内的所有 Integer 对象，它们实际上是引用相同的对象实例。\n\nInteger 缓存的主要目的是优化性能和内存使用。对于小整数的频繁操作，使用缓存可以显著减少对象创建的数量。\n\n可以在运行的时候添加 `-Djava.lang.Integer.IntegerCache.high=1000` 来调整缓存池的最大值。\n\n\n\n引用是 Integer 类型，= 右侧是 int 基本类型时，会进行自动装箱，调用的其实是 `Integer.valueOf()`方法，它会调用 IntegerCache。\n\n\n```java\npublic static Integer valueOf(int i) {\n if (i >= IntegerCache.low && i <= IntegerCache.high)\n return IntegerCache.cache[i + (-IntegerCache.low)];\n return new Integer(i);\n}\n```\n\n\nIntegerCache 是一个静态内部类，在静态代码块中会初始化好缓存的值。\n\n\n```java\nprivate static class IntegerCache {\n ……\n static {\n //创建Integer对象存储\n for(int k = 0; k < cache.length; k++)\n cache[k] = new Integer(j++);\n ……\n }\n}\n```\n\n\n#### [new Integer(10) == new Integer(10) 相等吗](#new-integer-10-new-integer-10-相等吗)\n\n在 Java 中，使用`new Integer(10) == new Integer(10)`进行比较时，结果是 false。\n\n这是因为 new 关键字会在堆（Heap）上为每个 Integer 对象分配新的内存空间，所以这里创建了两个不同的 Integer 对象，它们有不同的内存地址。\n\n当使用==运算符比较这两个对象时，实际上比较的是它们的内存地址，而不是它们的值，因此即使两个对象代表相同的数值（10），结果也是 false。"
+ },
+ {
+ "id": 39,
+ "question": "String 怎么转成 Integer 的？原理？",
+ "answer": "PS:这道题印象中在一些面经中出场过几次。\n\nString 转成 Integer，主要有两个方法：\n\n* Integer.parseInt(String s)\n* Integer.valueOf(String s)\n\n不管哪一种，最终还是会调用 Integer 类内中的`parseInt(String s, int radix)`方法。\n\n抛去一些边界之类的看看核心代码：\n\n\n```java\npublic static int parseInt(String s, int radix)\n throws NumberFormatException\n {\n\n int result = 0;\n //是否是负数\n boolean negative = false;\n //char字符数组下标和长度\n int i = 0, len = s.length();\n ……\n int digit;\n //判断字符长度是否大于0，否则抛出异常\n if (len > 0) {\n ……\n while (i < len) {\n // Accumulating negatively avoids surprises near MAX_VALUE\n //返回指定基数中字符表示的数值。（此处是十进制数值）\n digit = Character.digit(s.charAt(i++),radix);\n //进制位乘以数值\n result *= radix;\n result -= digit;\n }\n }\n //根据上面得到的是否负数，返回相应的值\n return negative ? result : -result;\n }\n```\n\n\n去掉枝枝蔓蔓（当然这些枝枝蔓蔓可以去看看，源码 cover 了很多情况），其实剩下的就是一个简单的字符串遍历计算，不过计算方式有点反常规，是用负的值累减。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 6,
+ "categoryName": "Object",
+ "questions": [
+ {
+ "id": 40,
+ "question": "Object 类的常见方法？",
+ "answer": "在 Java 中，经常提到一个词“万物皆对象”，其中的“万物”指的是 Java 中的所有类，而这些类都是 Object 类的子类。\n\nObject 主要提供了 11 个方法，大致可以分为六类：\n\n\n\n#### [对象比较：](#对象比较)\n\n①、`public native int hashCode()` ：，用于返回对象的哈希码。\n\n\n```java\npublic native int hashCode();\n```\n\n\n按照约定，相等的对象必须具有相等的哈希码。如果重写了 equals 方法，就应该重写 hashCode 方法。可以使用 方法来生成哈希码。\n\n\n```java\npublic int hashCode() {\n return Objects.hash(name, age);\n}\n```\n\n\n②、`public boolean equals(Object obj)`：用于比较 2 个对象的内存地址是否相等。\n\n\n```java\npublic boolean equals(Object obj) {\n return (this == obj);\n}\n```\n\n\n如果比较的是两个对象的值是否相等，就要重写该方法，比如 、Integer 类等都重写了该方法。举个例子，假如有一个 Person 类，我们认为只要年龄和名字相同，就是同一个人，那么就可以这样重写 equals 方法：\n\n\n```java\nclass Person1 {\n private String name;\n private int age;\n\n // 省略 gettter 和 setter 方法\n\n public boolean equals(Object obj) {\n if (this == obj) {\n return true;\n }\n if (obj instanceof Person1) {\n Person1 p = (Person1) obj;\n return this.name.equals(p.getName()) && this.age == p.getAge();\n }\n return false;\n }\n}\n```\n\n\n#### [对象拷贝：](#对象拷贝)\n\n`protected native Object clone() throws CloneNotSupportedException`：naitive 方法，返回此对象的一个副本。默认实现只做，且类必须实现 Cloneable 接口。\n\nObject 本身没有实现 Cloneable 接口，所以在不重写 clone 方法的情况下直接直接调用该方法会发生 CloneNotSupportedException 异常。\n\n#### [对象转字符串：](#对象转字符串)\n\n`public String toString()`：返回对象的字符串表示。默认实现返回类名@哈希码的十六进制表示，但通常会被重写以返回更有意义的信息。\n\n\n```java\npublic String toString() {\n return getClass().getName() + \"@\" + Integer.toHexString(hashCode());\n}\n```\n\n\n比如说一个 Person 类，我们可以重写 toString 方法，返回一个有意义的字符串：\n\n\n```java\npublic String toString() {\n return \"Person{\" +\n \"name='\" + name + '\\'' +\n \", age=\" + age +\n '}';\n}\n```\n\n\n当然了，这项工作也可以直接交给 IDE，比如 IntelliJ IDEA，直接右键选择 Generate，然后选择 toString 方法，就会自动生成一个 toString 方法。\n\n也可以交给 ，使用 @Data 注解，它会自动生成 toString 方法。\n\n数组也是一个对象，所以通常我们打印数组的时候，会看到诸如 `[I@1b6d3586` 这样的字符串，这个就是 int 数组的哈希码。\n\n#### [多线程调度：](#多线程调度)\n\n每个对象都可以调用 Object 的 wait/notify 方法来实现等待/通知机制。我们来写一个例子：\n\n\n```java\npublic class WaitNotifyDemo {\n public static void main(String[] args) {\n Object lock = new Object();\n new Thread(() -> {\n synchronized (lock) {\n System.out.println(\"线程1：我要等待\");\n try {\n lock.wait();\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.println(\"线程1：我被唤醒了\");\n }\n }).start();\n new Thread(() -> {\n synchronized (lock) {\n System.out.println(\"线程2：我要唤醒\");\n lock.notify();\n System.out.println(\"线程2：我已经唤醒了\");\n }\n }).start();\n }\n}\n```\n\n\n解释一下：\n\n* 线程 1 先执行，它调用了 `lock.wait()` 方法，然后进入了等待状态。\n* 线程 2 后执行，它调用了 `lock.notify()` 方法，然后线程 1 被唤醒了。\n\n①、`public final void wait() throws InterruptedException`：调用该方法会导致当前线程等待，直到另一个线程调用此对象的`notify()`方法或`notifyAll()`方法。\n\n②、`public final native void notify()`：唤醒在此对象监视器上等待的单个线程。如果有多个线程等待，选择一个线程被唤醒。\n\n③、`public final native void notifyAll()`：唤醒在此对象监视器上等待的所有线程。\n\n④、`public final native void wait(long timeout) throws InterruptedException`：等待 timeout 毫秒，如果在 timeout 毫秒内没有被唤醒，会自动唤醒。\n\n⑥、`public final void wait(long timeout, int nanos) throws InterruptedException`：更加精确了，等待 timeout 毫秒和 nanos 纳秒，如果在 timeout 毫秒和 nanos 纳秒内没有被唤醒，会自动唤醒。\n\n#### [反射：](#反射)\n\n`public final native Class getClass()`：用于获取对象的类信息，如类名。比如说：\n\n\n```java\npublic class GetClassDemo {\n public static void main(String[] args) {\n Person p = new Person();\n Class aClass = p.getClass();\n System.out.println(aClass.getName());\n }\n}\n```\n\n\n输出结果：\n\n\n```text\ncom.itwanger.Person\n```\n\n\n#### [垃圾回收：](#垃圾回收)\n\n`protected void finalize() throws Throwable`：当垃圾回收器决定回收对象占用的内存时调用此方法。用于清理资源，但 Java 不推荐使用，因为它不可预测且容易导致问题，Java 9 开始已被弃用。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 7,
+ "categoryName": "异常处理",
+ "questions": [
+ {
+ "id": 41,
+ "question": "Java 中异常处理体系?",
+ "answer": "Java 中的异常处理机制用于处理程序运行过程中可能发生的各种异常情况，通常通过 try-catch-finally 语句和 throw 关键字来实现。\n\n\n\n`Throwable` 是 Java 语言中所有错误和异常的基类。它有两个主要的子类：Error 和 Exception，这两个类分别代表了 Java 异常处理体系中的两个分支。\n\nError 类代表那些严重的错误，这类错误通常是程序无法处理的。比如，OutOfMemoryError 表示内存不足，StackOverflowError 表示栈溢出。这些错误通常与 JVM 的运行状态有关，一旦发生，应用程序通常无法恢复。\n\nException 类代表程序可以处理的异常。它分为两大类：编译时异常（Checked Exception）和运行时异常（Runtime Exception）。\n\n①、编译时异常（Checked Exception）：这类异常在编译时必须被显式处理（捕获或声明抛出）。\n\n如果方法可能抛出某种编译时异常，但没有捕获它（try-catch）或没有在方法声明中用 throws 子句声明它，那么编译将不会通过。例如：IOException、SQLException 等。\n\n②、运行时异常（Runtime Exception）：这类异常在运行时抛出，它们都是 RuntimeException 的子类。对于运行时异常，Java 编译器不要求必须处理它们（即不需要捕获也不需要声明抛出）。\n\n运行时异常通常是由程序逻辑错误导致的，如 NullPointerException、IndexOutOfBoundsException 等。"
+ },
+ {
+ "id": 42,
+ "question": "异常的处理方式？",
+ "answer": "\n\n①、遇到异常时可以不处理，直接通过throw 和 throws 抛出异常，交给上层调用者处理。\n\nthrows 关键字用于声明可能会抛出的异常，而 throw 关键字用于抛出异常。\n\n\n```java\npublic void test() throws Exception {\n throw new Exception(\"抛出异常\");\n}\n```\n\n\n②、使用 try-catch 捕获异常，处理异常。\n\n\n```java\ntry {\n //包含可能会出现异常的代码以及声明异常的方法\n}catch(Exception e) {\n //捕获异常并进行处理\n}finally {\n //可选，必执行的代码\n}\n```\n\n\n#### [catch和finally的异常可以同时抛出吗？](#catch和finally的异常可以同时抛出吗)\n\n如果 catch 块抛出一个异常，而 finally 块中也抛出异常，那么最终抛出的将是 finally 块中的异常。catch 块中的异常会被丢弃，而 finally 块中的异常会覆盖并向上传递。\n\n\n```java\npublic class Example {\n public static void main(String[] args) {\n try {\n throw new Exception(\"Exception in try\");\n } catch (Exception e) {\n throw new RuntimeException(\"Exception in catch\");\n } finally {\n throw new IllegalArgumentException(\"Exception in finally\");\n }\n }\n}\n```\n\n\n* try 块首先抛出一个 Exception。\n* 控制流进入 catch 块，catch 块中又抛出了一个 RuntimeException。\n* 但是在 finally 块中，抛出了一个 IllegalArgumentException，最终程序抛出的异常是 finally 块中的 IllegalArgumentException。\n\n虽然 catch 和 finally 中的异常不能同时抛出，但可以手动捕获 finally 块中的异常，并将 catch 块中的异常保留下来，避免被覆盖。常见的做法是使用一个变量临时存储 catch 中的异常，然后在 finally 中处理该异常：\n\n\n```java\npublic class Example {\n public static void main(String[] args) {\n Exception catchException = null;\n try {\n throw new Exception(\"Exception in try\");\n } catch (Exception e) {\n catchException = e;\n throw new RuntimeException(\"Exception in catch\");\n } finally {\n try {\n throw new IllegalArgumentException(\"Exception in finally\");\n } catch (IllegalArgumentException e) {\n if (catchException != null) {\n System.out.println(\"Catch exception: \" + catchException.getMessage());\n }\n System.out.println(\"Finally exception: \" + e.getMessage());\n }\n }\n }\n}\n```\n"
+ },
+ {
+ "id": 43,
+ "question": "三道经典异常处理代码题",
+ "answer": "#### [题目 1](#题目-1)\n\n\n```java\npublic class TryDemo {\n public static void main(String[] args) {\n System.out.println(test());\n }\n public static int test() {\n try {\n return 1;\n } catch (Exception e) {\n return 2;\n } finally {\n System.out.print(\"3\");\n }\n }\n}\n```\n\n\n在`test()`方法中，首先有一个`try`块，接着是一个`catch`块（用于捕获异常），最后是一个`finally`块（无论是否捕获到异常，`finally`块总会执行）。\n\n①、`try`块中包含一条`return 1;`语句。正常情况下，如果`try`块中的代码能够顺利执行，那么方法将返回数字`1`。在这个例子中，`try`块中没有任何可能抛出异常的操作，因此它会正常执行完毕，并准备返回`1`。\n\n②、由于`try`块中没有异常发生，所以`catch`块中的代码不会执行。\n\n③、无论前面的代码是否发生异常，`finally`块总是会执行。在这个例子中，`finally`块包含一条`System.out.print(\"3\");`语句，意味着在方法结束前，会在控制台打印出`3`。\n\n当执行`main`方法时，控制台的输出将会是：\n\n\n```text\n31\n```\n\n\n这是因为`finally`块确保了它包含的`System.out.print(\"3\");`会执行并打印`3`，随后`test()`方法返回`try`块中的值`1`，最终结果就是`31`。\n\n#### [题目 2](#题目-2)\n\n\n```java\npublic class TryDemo {\n public static void main(String[] args) {\n System.out.println(test1());\n }\n public static int test1() {\n try {\n return 2;\n } finally {\n return 3;\n }\n }\n}\n```\n\n\n执行结果：3。\n\ntry 返回前先执行 finally，结果 finally 里不按套路出牌，直接 return 了，自然也就走不到 try 里面的 return 了。\n\n注意：finally 里面使用 return 仅存在于面试题中，实际开发这么写要挨吊的（😂）。\n\n#### [题目 3](#题目-3)\n\n\n```java\npublic class TryDemo {\n public static void main(String[] args) {\n System.out.println(test1());\n }\n public static int test1() {\n int i = 0;\n try {\n i = 2;\n return i;\n } finally {\n i = 3;\n }\n }\n}\n```\n\n\n执行结果：2。\n\n大家可能会以为结果应该是 3，因为在 return 前会执行 finally，而 i 在 finally 中被修改为 3 了，那最终返回 i 不是应该为 3 吗？\n\n但其实，在执行 finally 之前，JVM 会先将 i 的结果暂存起来，然后 finally 执行完毕后，会返回之前暂存的结果，而不是返回 i，所以即使 i 已经被修改为 3，最终返回的还是之前暂存起来的结果 2。"
+ }
+ ]
+ },
+ {
+ "id": 8,
+ "categoryName": "I/O",
+ "questions": [
+ {
+ "id": 44,
+ "question": "Java 中 IO 流分为几种?",
+ "answer": "Java IO 流的划分可以根据多个维度进行，包括数据流的方向（输入或输出）、处理的数据单位（字节或字符）、流的功能以及流是否支持随机访问等。\n\n#### [按照数据流方向如何划分？](#按照数据流方向如何划分)\n\n* 输入流（Input Stream）：从源（如文件、网络等）读取数据到程序。\n* 输出流（Output Stream）：将数据从程序写出到目的地（如文件、网络、控制台等）。\n\n#### [按处理数据单位如何划分？](#按处理数据单位如何划分)\n\n* 字节流（Byte Streams）：以字节为单位读写数据，主要用于处理二进制数据，如音频、图像文件等。\n* 字符流（Character Streams）：以字符为单位读写数据，主要用于处理文本数据。\n\n\n\n#### [按功能如何划分？](#按功能如何划分)\n\n* 节点流（Node Streams）：直接与数据源或目的地相连，如 FileInputStream、FileOutputStream。\n* 处理流（Processing Streams）：对一个已存在的流进行包装，如缓冲流 BufferedInputStream、BufferedOutputStream。\n* 管道流（Piped Streams）：用于线程之间的数据传输，如 PipedInputStream、PipedOutputStream。\n\n#### [IO 流用到了什么设计模式？](#io-流用到了什么设计模式)\n\n其实，Java 的 IO 流体系还用到了一个设计模式——**装饰器模式**。\n\n\n\n#### [Java 缓冲区溢出，如何预防](#java-缓冲区溢出-如何预防)\n\nJava 缓冲区溢出主要是由于向缓冲区写入的数据超过其能够存储的数据量。可以采用这些措施来避免：\n\n①、**合理设置缓冲区大小**：在创建缓冲区时，应根据实际需求合理设置缓冲区的大小，避免创建过大或过小的缓冲区。\n\n②、**控制写入数据量**：在向缓冲区写入数据时，应该控制写入的数据量，确保不会超过缓冲区的容量。Java 的 ByteBuffer 类提供了`remaining()`方法，可以获取缓冲区中剩余的可写入数据量。\n\n\n```java\nimport java.nio.ByteBuffer;\n\npublic class ByteBufferExample {\n\n public static void main(String[] args) {\n // 模拟接收到的数据\n byte[] receivedData = {1, 2, 3, 4, 5};\n int bufferSize = 1024; // 设置一个合理的缓冲区大小\n\n // 创建ByteBuffer\n ByteBuffer buffer = ByteBuffer.allocate(bufferSize);\n\n // 写入数据之前检查容量是否足够\n if (buffer.remaining() >= receivedData.length) {\n buffer.put(receivedData);\n } else {\n System.out.println(\"Not enough space in buffer to write data.\");\n }\n\n // 准备读取数据：将limit设置为当前位置，position设回0\n buffer.flip();\n\n // 读取数据\n while (buffer.hasRemaining()) {\n byte data = buffer.get();\n System.out.println(\"Read data: \" + data);\n }\n\n // 清空缓冲区以便再次使用\n buffer.clear();\n }\n}\n```"
+ },
+ {
+ "id": 45,
+ "question": "既然有了字节流,为什么还要有字符流?",
+ "answer": "其实字符流是由 Java 虚拟机将字节转换得到的，问题就出在这个过程还比较耗时，并且，如果我们不知道编码类型就很容易出现乱码问题。\n\n所以， I/O 流就干脆提供了一个直接操作字符的接口，方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好，如果涉及到字符的话使用字符流比较好。\n\n#### [文本存储是字节流还是字符流，视频文件呢？](#文本存储是字节流还是字符流-视频文件呢)\n\n在计算机中，文本和视频都是按照字节存储的，只是如果是文本文件的话，我们可以通过字符流的形式去读取，这样更方面的我们进行直接处理。\n\n比如说我们需要在一个大文本文件中查找某个字符串，可以直接通过字符流来读取判断。\n\n处理视频文件时，通常使用字节流（如 Java 中的`FileInputStream`、`FileOutputStream`）来读取或写入数据，并且会尽量使用缓冲流（如`BufferedInputStream`、`BufferedOutputStream`）来提高读写效率。\n\n在项目中，对于文本，比如说文章和教程内容，是直接存储在数据库中的，而对于视频和图片等大文件，是存储在 OSS 中的。\n\n因此，无论是文本文件还是视频文件，它们在物理存储层面都是以字节流的形式存在。区别在于，我们如何通过 Java 代码来解释和处理这些字节流：作为编码后的字符还是作为二进制数据。"
+ },
+ {
+ "id": 46,
+ "question": "BIO、NIO、AIO 之间的区别？",
+ "answer": "Java 常见的 IO 模型有三种：BIO、NIO 和 AIO。\n\n\n\nBIO：采用阻塞式 I/O 模型，线程在执行 I/O 操作时被阻塞，无法处理其他任务，适用于连接数较少的场景。\n\nNIO：采用非阻塞 I/O 模型，线程在等待 I/O 时可执行其他任务，通过 Selector 监控多个 Channel 上的事件，适用于连接数多但连接时间短的场景。\n\nAIO：使用异步 I/O 模型，线程发起 I/O 请求后立即返回，当 I/O 操作完成时通过回调函数通知线程，适用于连接数多且连接时间长的场景。\n\n#### [简单说一下 BIO？](#简单说一下-bio)\n\nBIO，也就是传统的 IO，基于字节流或字符流（如 FileInputStream、BufferedReader 等）进行文件读写，基于 Socket 和 ServerSocket 进行网络通信。\n\n对于每个连接，都需要创建一个独立的线程来处理读写操作。\n\n\n\n#### [简单说下 NIO？](#简单说下-nio)\n\nNIO，JDK 1.4 时引入，放在 java.nio 包下，提供了 Channel、Buffer、Selector 等新的抽象，基于 RandomAccessFile、FileChannel、ByteBuffer 进行文件读写，基于 SocketChannel 和 ServerSocketChannel 进行网络通信。\n\n实际上，“旧”的 I/O 包已经使用 NIO 重新实现过，所以在进行文件读写时，NIO 并无法体现出比 BIO 更可靠的性能。\n\nNIO 的魅力主要体现在网络编程中，服务器可以用一个线程处理多个客户端连接，通过 Selector 监听多个 Channel 来实现多路复用，极大地提高了网络编程的性能。\n\n\n\n缓冲区 Buffer 也能极大提升一次 IO 操作的效率。\n\n\n\n#### [简单说下 AIO？](#简单说下-aio)\n\nAIO 是 Java 7 引入的，放在 java.nio.channels 包下，提供了 AsynchronousFileChannel、AsynchronousSocketChannel 等异步 Channel。\n\n它引入了异步通道的概念，使得 I/O 操作可以异步进行。这意味着线程发起一个读写操作后不必等待其完成，可以立即进行其他任务，并且当读写操作真正完成时，线程会被异步地通知。\n\n\n```java\nAsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(Paths.get(\"test.txt\"), StandardOpenOption.READ);\nByteBuffer buffer = ByteBuffer.allocate(1024);\nFuture result = fileChannel.read(buffer, 0);\nwhile (!result.isDone()) {\n // do something\n}\n```"
+ }
+ ]
+ },
+ {
+ "id": 9,
+ "categoryName": "序列化",
+ "questions": [
+ {
+ "id": 47,
+ "question": "什么是序列化？什么是反序列化？",
+ "answer": "序列化（Serialization）是指将对象转换为字节流的过程，以便能够将该对象保存到文件、数据库，或者进行网络传输。\n\n反序列化（Deserialization）就是将字节流转换回对象的过程，以便构建原始对象。\n\n\n\n#### [Serializable 接口有什么用？](#serializable-接口有什么用)\n\n`Serializable`接口用于标记一个类可以被序列化。\n\n\n```java\npublic class Person implements Serializable {\n private String name;\n private int age;\n // 省略 getter 和 setter 方法\n}\n```\n\n\n#### [serialVersionUID 有什么用？](#serialversionuid-有什么用)\n\nserialVersionUID 是 Java 序列化机制中用于标识类版本的唯一标识符。它的作用是确保在序列化和反序列化过程中，类的版本是兼容的。\n\n\n```java\nimport java.io.Serializable;\n\npublic class MyClass implements Serializable {\n private static final long serialVersionUID = 1L;\n private String name;\n private int age;\n\n // getters and setters\n}\n```\n\n\nserialVersionUID 被设置为 1L 是一种比较省事的做法，也可以使用 Intellij IDEA 进行自动生成。\n\n但只要 serialVersionUID 在序列化和反序列化过程中保持一致，就不会出现问题。\n\n如果不显式声明 serialVersionUID，Java 运行时会根据类的详细信息自动生成一个 serialVersionUID。那么当类的结构发生变化时，自动生成的 serialVersionUID 就会发生变化，导致反序列化失败。\n\n#### [Java 序列化不包含静态变量吗？](#java-序列化不包含静态变量吗)\n\n是的，序列化机制只会保存对象的状态，而静态变量属于类的状态，不属于对象的状态。\n\n#### [如果有些变量不想序列化，怎么办？](#如果有些变量不想序列化-怎么办)\n\n可以使用`transient`关键字修饰不想序列化的变量。\n\n\n```java\npublic class Person implements Serializable {\n private String name;\n private transient int age;\n // 省略 getter 和 setter 方法\n}\n```\n\n\n#### [能解释一下序列化的过程和作用吗？](#能解释一下序列化的过程和作用吗)\n\n序列化过程通常涉及到以下几个步骤：\n\n第一步，实现 Serializable 接口。\n\n\n```java\npublic class Person implements Serializable {\n private String name;\n private int age;\n\n // 省略构造方法、getters和setters\n}\n```\n\n\n第二步，使用 ObjectOutputStream 来将对象写入到输出流中。\n\n\n```java\nObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(\"person.ser\"));\n```\n\n\n第三步，调用 ObjectOutputStream 的 writeObject 方法，将对象序列化并写入到输出流中。\n\n\n```java\nPerson person = new Person(\"练习伴侣二\", 18);\nout.writeObject(person);\n```"
+ },
+ {
+ "id": 48,
+ "question": "说说有几种序列化方式？",
+ "answer": "Java 序列化方式有很多，常见的有三种：\n\n\n\n* Java 对象序列化 ：Java 原生序列化方法即通过 Java 原生流(InputStream 和 OutputStream 之间的转化)的方式进行转化，一般是对象输出流 `ObjectOutputStream`和对象输入流`ObjectInputStream`。\n* Json 序列化：这个可能是我们最常用的序列化方式，Json 序列化的选择很多，一般会使用 jackson 包，通过 ObjectMapper 类来进行一些操作，比如将对象转化为 byte 数组或者将 json 串转化为对象。\n* ProtoBuff 序列化：ProtocolBuffer 是一种轻便高效的结构化数据存储格式，ProtoBuff 序列化对象可以很大程度上将其压缩，可以大大减少数据传输大小，提高系统性能。"
+ }
+ ]
+ },
+ {
+ "id": 10,
+ "categoryName": "网络编程",
+ "questions": [
+ {
+ "id": 49,
+ "question": "了解过Socket网络套接字吗？（补充）",
+ "answer": "> 2024 年 11 月 28 日 增补\n\nSocket 是网络通信的基础，表示两台设备之间通信的一个端点。Socket 通常用于建立 TCP 或 UDP 连接，实现进程间的网络通信。\n\n\n\n一个简单的 TCP 客户端：\n\n\n```java\nclass TcpClient {\n public static void main(String[] args) throws IOException {\n Socket socket = new Socket(\"127.0.0.1\", 8080); // 连接服务器\n BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));\n PrintWriter out = new PrintWriter(socket.getOutputStream(), true);\n\n out.println(\"Hello, Server!\"); // 发送消息\n System.out.println(\"Server response: \" + in.readLine()); // 接收服务器响应\n\n socket.close();\n }\n}\n```\n\n\nTCP 服务端：\n\n\n```java\nclass TcpServer {\n public static void main(String[] args) throws IOException {\n ServerSocket serverSocket = new ServerSocket(8080); // 创建服务器端Socket\n System.out.println(\"Server started, waiting for connection...\");\n Socket socket = serverSocket.accept(); // 等待客户端连接\n System.out.println(\"Client connected: \" + socket.getInetAddress());\n\n BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));\n PrintWriter out = new PrintWriter(socket.getOutputStream(), true);\n\n String message;\n while ((message = in.readLine()) != null) {\n System.out.println(\"Received: \" + message);\n out.println(\"Echo: \" + message); // 回送消息\n }\n\n socket.close();\n serverSocket.close();\n }\n}\n```\n\n\n#### [RPC框架了解吗？](#rpc框架了解吗)\n\nRPC是一种协议，允许程序调用位于远程服务器上的方法，就像调用本地方法一样。RPC 通常基于 Socket 通信实现。\n\n> RPC，Remote Procedure Call，远程过程调用\n\nRPC 框架支持高效的序列化（如 Protocol Buffers）和通信协议（如 HTTP/2），屏蔽了底层网络通信的细节，开发者只需关注业务逻辑即可。\n\n\n\n常见的 RPC 框架包括：\n\n1. gRPC：基于 HTTP/2 和 Protocol Buffers。\n2. Dubbo：阿里开源的分布式 RPC 框架，适合微服务场景。\n3. Spring Cloud OpenFeign：基于 REST 的轻量级 RPC 框架。\n4. Thrift：Apache 的跨语言 RPC 框架，支持多语言代码生成。"
+ }
+ ]
+ },
+ {
+ "id": 11,
+ "categoryName": "泛型",
+ "questions": [
+ {
+ "id": 50,
+ "question": "Java 泛型了解么？",
+ "answer": "泛型主要用于提高代码的类型安全，它允许在定义类、接口和方法时使用类型参数，这样可以在编译时检查类型一致性，避免不必要的类型转换和类型错误。\n\n没有泛型的时候，像 List 这样的集合类存储的是 Object 类型，导致从集合中读取数据时，必须进行强制类型转换，否则会引发 ClassCastException。\n\n\n```java\nList list = new ArrayList();\nlist.add(\"hello\");\nString str = (String) list.get(0); // 必须强制类型转换\n```\n\n\n泛型一般有三种使用方式:**泛型类**、**泛型接口**、**泛型方法**。\n\n\n\n**1.泛型类**：\n\n\n```java\n//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型\n//在实例化泛型类时，必须指定T的具体类型\npublic class Generic{\n\n private T key;\n\n public Generic(T key) {\n this.key = key;\n }\n\n public T getKey(){\n return key;\n }\n}\n```\n\n\n如何实例化泛型类：\n\n\n```java\nGeneric genericInteger = new Generic(123456);\n```\n\n\n**2.泛型接口** ：\n\n\n```java\npublic interface Generator {\n public T method();\n}\n```\n\n\n实现泛型接口，指定类型：\n\n\n```java\nclass GeneratorImpl implements Generator{\n @Override\n public String method() {\n return \"hello\";\n }\n}\n```\n\n\n**3.泛型方法** ：\n\n\n```java\n public static < E > void printArray( E[] inputArray )\n {\n for ( E element : inputArray ){\n System.out.printf( \"%s \", element );\n }\n System.out.println();\n }\n```\n\n\n使用：\n\n\n```java\n// 创建不同类型数组： Integer, Double 和 Character\nInteger[] intArray = { 1, 2, 3 };\nString[] stringArray = { \"Hello\", \"World\" };\nprintArray( intArray );\nprintArray( stringArray );\n```\n\n\n#### [泛型常用的通配符有哪些？](#泛型常用的通配符有哪些)\n\n**常用的通配符为： T，E，K，V，？**\n\n* ？ 表示不确定的 java 类型\n* T (type) 表示具体的一个 java 类型\n* K V (key value) 分别代表 java 键值中的 Key Value\n* E (element) 代表 Element\n\n#### [什么是泛型擦除？](#什么是泛型擦除)\n\n所谓的泛型擦除，官方名叫“类型擦除”。\n\nJava 的泛型是伪泛型，这是因为 Java 在编译期间，所有的类型信息都会被擦掉。\n\n也就是说，在运行的时候是没有泛型的。\n\n例如这段代码，往一群猫里放条狗：\n\n\n```java\nLinkedList cats = new LinkedList();\nLinkedList list = cats; // 注意我在这里把范型去掉了，但是list和cats是同一个链表！\nlist.add(new Dog()); // 完全没问题！\n```\n\n\n因为 Java 的范型只存在于源码里，编译的时候给你静态地检查一下范型类型是否正确，而到了运行时就不检查了。上面这段代码在 JRE（Java**运行**环境）看来和下面这段没区别：\n\n\n```java\nLinkedList cats = new LinkedList(); // 注意：没有范型！\nLinkedList list = cats;\nlist.add(new Dog());\n```\n\n\n#### [为什么要类型擦除呢？](#为什么要类型擦除呢)\n\n主要是为了向下兼容，因为 JDK5 之前是没有泛型的，为了让 JVM 保持向下兼容，就出了类型擦除这个策略。"
+ }
+ ]
+ },
+ {
+ "id": 12,
+ "categoryName": "注解",
+ "questions": [
+ {
+ "id": 51,
+ "question": "说一下你对注解的理解？",
+ "answer": "**Java 注解本质上是一个标记**，可以理解成生活中的一个人的一些小装扮，比如戴什么什么帽子，戴什么眼镜。\n\n\n\n注解可以标记在类上、方法上、属性上等，标记自身也可以设置一些值，比如帽子颜色是绿色。\n\n有了标记之后，我们就可以在编译或者运行阶段去识别这些标记，然后搞一些事情，这就是注解的用处。\n\n例如我们常见的 AOP，使用注解作为切点就是运行期注解的应用；比如 lombok，就是注解在编译期的运行。\n\n注解生命周期有三大类，分别是：\n\n* RetentionPolicy.SOURCE：给编译器用的，不会写入 class 文件\n* RetentionPolicy.CLASS：会写入 class 文件，在类加载阶段丢弃，也就是运行的时候就没这个信息了\n* RetentionPolicy.RUNTIME：会写入 class 文件，永久保存，可以通过反射获取注解信息\n\n所以我上文写的是解析的时候，没写具体是解析啥，因为不同的生命周期的解析动作是不同的。\n\n像常见的：\n\n\n\n就是给编译器用的，编译器编译的时候检查没问题就 over 了，class 文件里面不会有 Override 这个标记。\n\n再比如 Spring 常见的 Autowired ，就是 RUNTIME 的，所以**在运行的时候可以通过反射得到注解的信息**，还能拿到标记的值 required 。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 13,
+ "categoryName": "反射",
+ "questions": [
+ {
+ "id": 52,
+ "question": "什么是反射？应用？原理？",
+ "answer": "反射允许 Java 在运行时检查和操作类的方法和字段。通过反射，可以动态地获取类的字段、方法、构造方法等信息，并在运行时调用方法或访问字段。\n\n比如创建一个对象是通过 new 关键字来实现的：\n\n\n```java\nPerson person = new Person();\n```\n\n\nPerson 类的信息在编译时就确定了，那假如在编译期无法确定类的信息，但又想在运行时获取类的信息、创建类的实例、调用类的方法，这时候就要用到反射。\n\n反射功能主要通过 `java.lang.Class` 类及 `java.lang.reflect` 包中的类如 Method, Field, Constructor 等来实现。\n\n\n\n比如说我们可以装来动态加载类并创建对象：\n\n\n```java\nString className = \"java.util.Date\";\nClass cls = Class.forName(className);\nObject obj = cls.newInstance();\nSystem.out.println(obj.getClass().getName());\n```\n\n\n比如说我们可以这样来访问字段和方法：\n\n\n```java\n// 加载并实例化类\nClass cls = Class.forName(\"java.util.Date\");\nObject obj = cls.newInstance();\n\n// 获取并调用方法\nMethod method = cls.getMethod(\"getTime\");\nObject result = method.invoke(obj);\nSystem.out.println(\"Time: \" + result);\n\n// 访问字段\nField field = cls.getDeclaredField(\"fastTime\");\nfield.setAccessible(true); // 对于私有字段需要这样做\nSystem.out.println(\"fastTime: \" + field.getLong(obj));\n```\n\n\n#### [反射有哪些应用场景？](#反射有哪些应用场景)\n\n①、Spring 框架就大量使用了反射来动态加载和管理 Bean。\n\n\n```java\nClass clazz = Class.forName(\"com.example.MyClass\");\nObject instance = clazz.newInstance();\n```\n\n\n②、Java 的动态代理（Dynamic Proxy）机制就使用了反射来创建代理类。代理类可以在运行时动态处理方法调用，这在实现 AOP 和拦截器时非常有用。\n\n\n```java\nInvocationHandler handler = new MyInvocationHandler();\nMyInterface proxyInstance = (MyInterface) Proxy.newProxyInstance(\n MyInterface.class.getClassLoader(),\n new Class[] { MyInterface.class },\n handler\n);\n```\n\n\n③、JUnit 和 TestNG 等测试框架使用反射机制来发现和执行测试方法。反射允许框架扫描类，查找带有特定注解（如 `@Test`）的方法，并在运行时调用它们。\n\n\n```java\nMethod testMethod = testClass.getMethod(\"testSomething\");\ntestMethod.invoke(testInstance);\n```\n\n\n#### [反射的原理是什么？](#反射的原理是什么)\n\nJava 程序的执行分为编译和运行两步，编译之后会生成字节码(.class)文件，JVM 进行类加载的时候，会加载字节码文件，将类型相关的所有信息加载进方法区，反射就是去获取这些信息，然后进行各种操作。"
+ }
+ ]
+ },
+ {
+ "id": 14,
+ "categoryName": "JDK1.8 新特性",
+ "questions": [
+ {
+ "id": 53,
+ "question": "JDK 1.8 都有哪些新特性？",
+ "answer": "JDK 1.8 新增了不少新的特性，如 Lambda 表达式、接口默认方法、Stream API、日期时间 API、Optional 类等。\n\n\n\n①、Java 8 允许在接口中添加默认方法和静态方法。\n\n\n```java\npublic interface MyInterface {\n default void myDefaultMethod() {\n System.out.println(\"My default method\");\n }\n\n static void myStaticMethod() {\n System.out.println(\"My static method\");\n }\n}\n```\n\n\n②、Lambda 表达式描述了一个代码块（或者叫匿名方法），可以将其作为参数传递给构造方法或者普通方法以便后续执行。\n\n\n```java\npublic class LamadaTest {\n public static void main(String[] args) {\n new Thread(() -> System.out.println(\"练习伴侣二\")).start();\n }\n}\n```\n\n\n《Effective Java》的作者 Josh Bloch 建议使用 Lambda 表达式时，最好不要超过 3 行。否则代码可读性会变得很差。\n\n③、Stream 是对 Java 集合框架的增强，它提供了一种高效且易于使用的数据处理方式。\n\n\n```java\nList list = new ArrayList<>();\nlist.add(\"中国加油\");\nlist.add(\"世界加油\");\nlist.add(\"世界加油\");\n\nlong count = list.stream().distinct().count();\nSystem.out.println(count);\n```\n\n\n④、Java 8 引入了一个全新的日期和时间 API，位于`java.time`包中。这个新的 API 纠正了旧版`java.util.Date`类中的许多缺陷。\n\n\n```java\nLocalDate today = LocalDate.now();\nSystem.out.println(\"Today's Local date : \" + today);\n\nLocalTime time = LocalTime.now();\nSystem.out.println(\"Local time : \" + time);\n\nLocalDateTime now = LocalDateTime.now();\nSystem.out.println(\"Current DateTime : \" + now);\n```\n\n\n⑤、引入 Optional 是为了减少空指针异常。\n\n\n```java\nOptional optional = Optional.of(\"练习伴侣二\");\noptional.isPresent(); // true\noptional.get(); // \"练习伴侣二\"\noptional.orElse(\"练习伴侣三\"); // \"bam\"\noptional.ifPresent((s) -> System.out.println(s.charAt(0))); // \"沉\"\n```"
+ },
+ {
+ "id": 54,
+ "question": "Lambda 表达式了解多少？",
+ "answer": "Lambda 表达式主要用于提供一种简洁的方式来表示匿名方法，使 Java 具备了函数式编程的特性。\n\n比如说我们可以使用 Lambda 表达式来简化线程的创建：\n\n\n```java\nnew Thread(() -> System.out.println(\"Hello World\")).start();\n```\n\n\n这比以前的匿名内部类要简洁很多。\n\n所谓的函数式编程，就是把函数作为参数传递给方法，或者作为方法的结果返回。比如说我们可以配合 Stream 流进行数据过滤：\n\n\n```java\nList numbers = Arrays.asList(1, 2, 3, 4, 5, 6);\nList evenNumbers = numbers.stream()\n .filter(n -> n % 2 == 0)\n .collect(Collectors.toList());\n```\n\n\n其中 `n -> n % 2 == 0` 就是一个 Lambda 表达式。表示传入一个参数 n，返回 `n % 2 == 0` 的结果。\n\n#### [Java8 有哪些内置函数式接口？](#java8-有哪些内置函数式接口)\n\nJDK 1.8 API 包含了很多内置的函数式接口。其中就包括我们在老版本中经常见到的 **Comparator** 和 **Runnable**，Java 8 为他们都添加了 @FunctionalInterface 注解，以用来支持 Lambda 表达式。\n\n除了这两个之外，还有 Callable、Predicate、Function、Supplier、Consumer 等等。"
+ },
+ {
+ "id": 55,
+ "question": "Optional 了解吗？",
+ "answer": "`Optional`是用于防范`NullPointerException`。\n\n可以将 `Optional` 看做是包装对象（可能是 `null`, 也有可能非 `null`）的容器。当我们定义了 一个方法，这个方法返回的对象可能是空，也有可能非空的时候，我们就可以考虑用 `Optional` 来包装它，这也是在 Java 8 被推荐使用的做法。\n\n\n```java\nOptional optional = Optional.of(\"bam\");\n\noptional.isPresent(); // true\noptional.get(); // \"bam\"\noptional.orElse(\"fallback\"); // \"bam\"\n\noptional.ifPresent((s) -> System.out.println(s.charAt(0))); // \"b\"\n```"
+ },
+ {
+ "id": 56,
+ "question": "Stream 流用过吗？",
+ "answer": "`Stream` 流，简单来说，使用 `java.util.Stream` 对一个包含一个或多个元素的集合做各种操作。这些操作可能是 *中间操作* 亦或是 *终端操作*。 终端操作会返回一个结果，而中间操作会返回一个 `Stream` 流。\n\nStream 流一般用于集合，我们对一个集合做几个常见操作：\n\n\n```java\nList stringCollection = new ArrayList<>();\nstringCollection.add(\"ddd2\");\nstringCollection.add(\"aaa2\");\nstringCollection.add(\"bbb1\");\nstringCollection.add(\"aaa1\");\nstringCollection.add(\"bbb3\");\nstringCollection.add(\"ccc\");\nstringCollection.add(\"bbb2\");\nstringCollection.add(\"ddd1\");\n```\n\n\n* **Filter 过滤**\n\n\n```java\nstringCollection\n .stream()\n .filter((s) -> s.startsWith(\"a\"))\n .forEach(System.out::println);\n\n// \"aaa2\", \"aaa1\"\n```\n\n\n* **Sorted 排序**\n\n\n```java\nstringCollection\n .stream()\n .sorted()\n .filter((s) -> s.startsWith(\"a\"))\n .forEach(System.out::println);\n\n// \"aaa1\", \"aaa2\"\n```\n\n\n* **Map 转换**\n\n\n```java\nstringCollection\n .stream()\n .map(String::toUpperCase)\n .sorted((a, b) -> b.compareTo(a))\n .forEach(System.out::println);\n\n// \"DDD2\", \"DDD1\", \"CCC\", \"BBB3\", \"BBB2\", \"AAA2\", \"AAA1\"\n```\n\n\n* **Match 匹配**\n\n\n```java\n// 验证 list 中 string 是否有以 a 开头的, 匹配到第一个，即返回 true\nboolean anyStartsWithA =\n stringCollection\n .stream()\n .anyMatch((s) -> s.startsWith(\"a\"));\n\nSystem.out.println(anyStartsWithA); // true\n\n// 验证 list 中 string 是否都是以 a 开头的\nboolean allStartsWithA =\n stringCollection\n .stream()\n .allMatch((s) -> s.startsWith(\"a\"));\n\nSystem.out.println(allStartsWithA); // false\n\n// 验证 list 中 string 是否都不是以 z 开头的,\nboolean noneStartsWithZ =\n stringCollection\n .stream()\n .noneMatch((s) -> s.startsWith(\"z\"));\n\nSystem.out.println(noneStartsWithZ); // true\n```\n\n\n* **Count 计数**\n\n`count` 是一个终端操作，它能够统计 `stream` 流中的元素总数，返回值是 `long` 类型。\n\n\n```java\n// 先对 list 中字符串开头为 b 进行过滤，让后统计数量\nlong startsWithB =\n stringCollection\n .stream()\n .filter((s) -> s.startsWith(\"b\"))\n .count();\n\nSystem.out.println(startsWithB); // 3\n```\n\n\n* **Reduce**\n\n`Reduce` 中文翻译为：*减少、缩小*。通过入参的 `Function`，我们能够将 `list` 归约成一个值。它的返回类型是 `Optional` 类型。\n\n\n```java\nOptional reduced =\n stringCollection\n .stream()\n .sorted()\n .reduce((s1, s2) -> s1 + \"#\" + s2);\n\nreduced.ifPresent(System.out::println);\n// \"aaa1#aaa2#bbb1#bbb2#bbb3#ccc#ddd1#ddd2\"\n```\n\n\n以上是常见的几种流式操作，还有其它的一些流式操作，可以帮助我们更便捷地处理集合数据。\n\n\n> 2024 年 12 月 30 日第二版优化结束。"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 2,
+ "topicName": "Java集合",
+ "categories": [
+ {
+ "id": 15,
+ "categoryName": "引言",
+ "questions": [
+ {
+ "id": 57,
+ "question": "说说有哪些常见的集合框架？",
+ "answer": "\n\n集合框架可以分为两条大的支线：\n\n①、第一条支线 Collection，主要由 List、Set、Queue 组成：\n\n* List 代表有序、可重复的集合，典型代表就是封装了动态数组的 和封装了链表的 ；\n* Set 代表无序、不可重复的集合，典型代表就是 HashSet 和 TreeSet；\n* Queue 代表队列，典型代表就是双端队列 ，以及优先级队列 。\n\n②、第二条支线 Map，代表键值对的集合，典型代表就是 。\n\n另外一个回答版本：\n\n①、Collection 接口：最基本的集合框架表示方式，提供了添加、删除、清空等基本操作，它主要有三个子接口：\n\n* `List`：一个有序的集合，可以包含重复的元素。实现类包括 ArrayList、LinkedList 等。\n* `Set`：一个不包含重复元素的集合。实现类包括 HashSet、LinkedHashSet、TreeSet 等。\n* `Queue`：一个用于保持元素队列的集合。实现类包括 PriorityQueue、ArrayDeque 等。\n\n②、`Map` 接口：表示键值对的集合，一个键映射到一个值。键不能重复，每个键只能对应一个值。Map 接口的实现类包括 HashMap、LinkedHashMap、TreeMap 等。\n\n#### [集合框架有哪几个常用工具类？](#集合框架有哪几个常用工具类)\n\n集合框架位于 java.util 包下，提供了两个常用的工具类：\n\n* ：提供了一些对集合进行排序、二分查找、同步的静态方法。\n* ：提供了一些对数组进行排序、打印、和 List 进行转换的静态方法。\n\n#### [简单介绍一下队列](#简单介绍一下队列)\n\nJava 中的队列主要通过 Queue 接口和并发包下的 BlockingQueue 两个接口来实现。\n\n优先级队列 PriorityQueue 实现了 Queue 接口，是一个无界队列，它的元素按照自然顺序排序或者 Comparator 比较器进行排序。\n\n\n\n双端队列 ArrayDeque 也实现了 Queue 接口，是一个基于数组的，可以在两端插入和删除元素的队列。\n\n\n\nLinkedList 实现了 Queue 接口的子类 Deque，所以也可以当做双端队列来使用。\n\n\n\n#### [用过哪些集合类，它们的优劣？](#用过哪些集合类-它们的优劣)\n\n我常用的集合类有 ArrayList、LinkedList、HashMap、LinkedHashMap。\n\n1. ArrayList 可以看作是一个动态数组，可以在需要时动态扩容数组的容量，只不过需要复制元素到新的数组。优点是访问速度快，可以通过索引直接查找到元素。缺点是插入和删除元素可能需要移动或者复制元素。\n2. LinkedList 是一个双向链表，适合频繁的插入和删除操作。优点是插入和删除元素的时候只需要改变节点的前后指针，缺点是访问元素时需要遍历链表。\n3. HashMap 是一个基于哈希表的键值对集合。优点是可以根据键的哈希值快速查找到值，但有可能会发生哈希冲突，并且不保留键值对的插入顺序。\n4. LinkedHashMap 在 HashMap 的基础上增加了一个双向链表来保持键值对的插入顺序。\n\n#### [队列和栈的区别了解吗？](#队列和栈的区别了解吗)\n\n队列是一种先进先出（FIFO, First-In-First-Out）的数据结构，第一个加入队列的元素会成为第一个被移除的元素。\n\n\n\n栈是一种后进先出（LIFO, Last-In-First-Out）的数据结构，最后一个加入栈的元素会成为第一个被移除的元素。\n\n\n\n#### [哪些是线程安全的容器？](#哪些是线程安全的容器)\n\n像 Vector、Hashtable、ConcurrentHashMap、CopyOnWriteArrayList、ConcurrentLinkedQueue、ArrayBlockingQueue、LinkedBlockingQueue 都是线程安全的。\n\n#### [Collection 继承了哪些接口？](#collection-继承了哪些接口)\n\nCollection 继承了 Iterable 接口，这意味着所有实现 Collection 接口的类都必须实现 `iterator()` 方法，之后就可以使用增强型 for 循环遍历集合中的元素了。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 16,
+ "categoryName": "List",
+ "questions": [
+ {
+ "id": 58,
+ "question": "ArrayList 和 LinkedList 有什么区别？",
+ "answer": "ArrayList 是基于数组实现的，LinkedList 是基于链表实现的。\n\n\n\n#### [ArrayList 和 LinkedList 的用途有什么不同？](#arraylist-和-linkedlist-的用途有什么不同)\n\n多数情况下，ArrayList 更利于查找，LinkedList 更利于增删。\n\n①、由于 ArrayList 是基于数组实现的，所以 `get(int index)` 可以直接通过数组下标获取，时间复杂度是 O(1)；LinkedList 是基于链表实现的，`get(int index)` 需要遍历链表，时间复杂度是 O(n)。\n\n当然，`get(E element)` 这种查找，两种集合都需要遍历通过 equals 比较获取元素，所以时间复杂度都是 O(n)。\n\n②、ArrayList 如果增删的是数组的尾部，时间复杂度是 O(1)；如果 add 的时候涉及到扩容，时间复杂度会上升到 O(n)。\n\n但如果插入的是中间的位置，就需要把插入位置后的元素向前或者向后移动，甚至还有可能触发扩容，效率就会低很多，变成 O(n)。\n\n\n\nLinkedList 因为是链表结构，插入和删除只需要改变前置节点、后置节点和插入节点的引用，因此不需要移动元素。\n\n如果是在链表的头部插入或者删除，时间复杂度是 O(1)；如果是在链表的中间插入或者删除，时间复杂度是 O(n)，因为需要遍历链表找到插入位置；如果是在链表的尾部插入或者删除，时间复杂度是 O(1)。\n\n\n\n#### [ArrayList 和 LinkedList 是否支持随机访问？](#arraylist-和-linkedlist-是否支持随机访问)\n\n①、ArrayList 是基于数组的，也实现了 RandomAccess 接口，所以它支持随机访问，可以通过下标直接获取元素。\n\n\n\n②、LinkedList 是基于链表的，所以它没法根据下标直接获取元素，不支持随机访问。\n\n\n\n#### [ArrayList 和 LinkedList 内存占用有何不同？](#arraylist-和-linkedlist-内存占用有何不同)\n\nArrayList 是基于数组的，是一块连续的内存空间，所以它的内存占用是比较紧凑的；但如果涉及到扩容，就会重新分配内存，空间是原来的 1.5 倍。\n\n\n\nLinkedList 是基于链表的，每个节点都有一个指向下一个节点和上一个节点的引用，于是每个节点占用的内存空间比 ArrayList 稍微大一点。\n\n#### [ArrayList 和 LinkedList 的使用场景有什么不同？](#arraylist-和-linkedlist-的使用场景有什么不同)\n\nArrayList 适用于：\n\n* 随机访问频繁：需要频繁通过索引访问元素的场景。\n* 读取操作远多于写入操作：如存储不经常改变的列表。\n* 末尾添加元素：需要频繁在列表末尾添加元素的场景。\n\nLinkedList 适用于：\n\n* 频繁插入和删除：在列表中间频繁插入和删除元素的场景。\n* 不需要快速随机访问：顺序访问多于随机访问的场景。\n* 队列和栈：由于其双向链表的特性，LinkedList 可以实现队列（FIFO）和栈（LIFO）。\n\n#### [链表和数组有什么区别？](#链表和数组有什么区别)\n\n* 数组在内存中占用的是一块连续的存储空间，因此我们可以通过数组下标快速访问任意元素。数组在创建时必须指定大小，一旦分配内存，数组的大小就固定了。\n* 链表的元素存储在于内存中的任意位置，每个节点通过指针指向下一个节点。\n\n"
+ },
+ {
+ "id": 59,
+ "question": "ArrayList 的扩容机制了解吗？",
+ "answer": "了解。当往 ArrayList 中添加元素时，会先检查是否需要扩容，如果当前容量+1 超过数组长度，就会进行扩容。\n\n\n\n扩容后的新数组长度是原来的 1.5 倍，然后再把原数组的值拷贝到新数组中。\n\n\n```java\nprivate void grow(int minCapacity) {\n // overflow-conscious code\n int oldCapacity = elementData.length;\n int newCapacity = oldCapacity + (oldCapacity >> 1);\n if (newCapacity - minCapacity < 0)\n newCapacity = minCapacity;\n if (newCapacity - MAX_ARRAY_SIZE > 0)\n newCapacity = hugeCapacity(minCapacity);\n // minCapacity is usually close to size, so this is a win:\n elementData = Arrays.copyOf(elementData, newCapacity);\n}\n```"
+ },
+ {
+ "id": 60,
+ "question": "ArrayList 怎么序列化的知道吗？",
+ "answer": "在 ArrayList 中，writeObject 方法被重写了，用于自定义序列化逻辑：只序列化有效数据，因为 elementData 数组的容量一般大于实际的元素数量，声明的时候也加了 transient 关键字。\n\n\n\n#### [为什么 ArrayList 不直接序列化元素数组呢？](#为什么-arraylist-不直接序列化元素数组呢)\n\n出于效率的考虑，数组可能长度 100，但实际只用了 50，剩下的 50 没用到，也就不需要序列化。\n\n\n```java\nprivate void writeObject(java.io.ObjectOutputStream s)\n throws java.io.IOException {\n // 将当前 ArrayList 的结构进行序列化\n int expectedModCount = modCount;\n s.defaultWriteObject(); // 序列化非 transient 字段\n // 序列化数组的大小\n s.writeInt(size);\n // 序列化每个元素\n for (int i = 0; i < size; i++) {\n s.writeObject(elementData[i]);\n }\n // 检查是否在序列化期间发生了并发修改\n if (modCount != expectedModCount) {\n throw new ConcurrentModificationException();\n }\n}\n```"
+ },
+ {
+ "id": 61,
+ "question": "快速失败fail-fast了解吗？",
+ "answer": "fail—fast 是 Java 集合的一种错误检测机制。\n\n在用迭代器遍历集合对象时，如果线程 A 遍历过程中，线程 B 对集合对象的内容进行了修改，就会抛出 Concurrent Modification Exception。\n\n迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 `modCount` 变量。集合在被遍历期间如果内容发生变化，就会改变`modCount`的值。每当迭代器使用 `hashNext()/next()`遍历下一个元素之前，都会检测 modCount 变量是否为 expectedmodCount 值，是的话就返回遍历；否则抛出异常，终止遍历。\n\n异常的抛出条件是检测到 `modCount！=expectedmodCount` 这个条件。如果集合发生变化时修改 modCount 值刚好又设置为了 expectedmodCount 值，则异常不会抛出。因此，不能依赖于这个异常是否抛出而进行并发操作的编程，这个异常只建议用于检测并发修改的 bug。\n\njava.util 包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改），比如 ArrayList 类。\n\n#### [什么是安全失败（fail—safe）呢？](#什么是安全失败-fail—safe-呢)\n\n采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。\n\n原理：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发 Concurrent Modification Exception。\n\n缺点：基于拷贝内容的优点是避免了 Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。\n\n场景：java.util.concurrent 包下的容器都是安全失败，可以在多线程下并发使用，并发修改，比如 CopyOnWriteArrayList 类。"
+ },
+ {
+ "id": 62,
+ "question": "有哪几种实现 ArrayList 线程安全的方法？",
+ "answer": "常用的有两种。\n\n可以使用 `Collections.synchronizedList()` 方法，它可以返回一个线程安全的 List。\n\n\n```java\nSynchronizedList list = Collections.synchronizedList(new ArrayList());\n```\n\n\n内部是通过 加锁来实现的。\n\n也可以直接使用 ，它是线程安全的 ArrayList，遵循写时复制的原则，每当对列表进行修改时，都会创建一个新副本，这个新副本会替换旧的列表，而对旧列表的所有读取操作仍然在原有的列表上进行。\n\n\n```java\nCopyOnWriteArrayList list = new CopyOnWriteArrayList();\n```\n\n\n通俗的讲，CopyOnWrite 就是当我们往一个容器添加元素的时候，不直接往容器中添加，而是先复制出一个新的容器，然后在新的容器里添加元素，添加完之后，再将原容器的引用指向新的容器。多个线程在读的时候，不需要加锁，因为当前容器不会添加任何元素。这样就实现了线程安全。\n\n#### [ArrayList 和 Vector 的区别？](#arraylist-和-vector-的区别)\n\nVector 属于 JDK 1.0 时期的遗留类，不推荐使用，仍然保留着是因为 Java 希望向后兼容。\n\nArrayList 是在 JDK 1.2 时引入的，用于替代 Vector 作为主要的非同步动态数组实现。因为 Vector 所有的方法都使用了 synchronized 关键字进行同步，所以单线程环境下效率较低。\n\n"
+ },
+ {
+ "id": 63,
+ "question": "CopyOnWriteArrayList 了解多少？",
+ "answer": "CopyOnWriteArrayList 就是线程安全版本的 ArrayList。\n\n`CopyOnWrite`——写时复制，已经明示了它的原理。\n\nCopyOnWriteArrayList 采用了一种读写分离的并发策略。CopyOnWriteArrayList 容器允许并发读，读操作是无锁的。至于写操作，比如说向容器中添加一个元素，首先将当前容器复制一份，然后在新副本上执行写操作，结束之后再将原容器的引用指向新容器。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 17,
+ "categoryName": "Map",
+ "questions": [
+ {
+ "id": 64,
+ "question": "能说一下 HashMap 的底层数据结构吗？",
+ "answer": "JDK 8 中 HashMap 的数据结构是`数组`+`链表`+`红黑树`。\n\n\n\n数组用来存储键值对，每个键值对可以通过索引直接拿到，索引是通过对键的哈希值进行进一步的 `hash()` 处理得到的。\n\n当多个键经过哈希处理后得到相同的索引时，需要通过链表来解决哈希冲突——将具有相同索引的键值对通过链表存储起来。\n\n不过，链表过长时，查询效率会比较低，于是当链表的长度超过 8 时（且数组的长度大于 64），链表就会转换为红黑树。红黑树的查询效率是 O(logn)，比链表的 O(n) 要快。\n\n`hash()` 方法的目标是尽量减少哈希冲突，保证元素能够均匀地分布在数组的每个位置上。\n\n\n```java\nstatic final int hash(Object key) {\n int h;\n return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```\n\n\n如果键的哈希值已经在数组中存在，其对应的值将被新值覆盖。\n\nHashMap 的初始容量是 16，随着元素的不断添加，HashMap 就需要进行扩容，阈值是`capacity * loadFactor`，capacity 为容量，loadFactor 为负载因子，默认为 0.75。\n\n扩容后的数组大小是原来的 2 倍，然后把原来的元素重新计算哈希值，放到新的数组中。"
+ },
+ {
+ "id": 65,
+ "question": "你对红黑树了解多少？",
+ "answer": "红黑树是一种自平衡的二叉查找树：\n\n1. 每个节点要么是红色，要么是黑色；\n2. 根节点永远是黑色；\n3. 所有的叶子节点都是是黑色的（下图中的 NULL 节点）；\n4. 红色节点的子节点一定是黑色的；\n5. 从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。\n\n\n\n#### [为什么不用二叉树？](#为什么不用二叉树)\n\n二叉树是最基本的树结构，每个节点最多有两个子节点，但是二叉树容易出现极端情况，比如插入的数据是有序的，那么二叉树就会退化成链表，查询效率就会变成 O(n)。\n\n#### [为什么不用平衡二叉树？](#为什么不用平衡二叉树)\n\n平衡二叉树比红黑树的要求更高，每个节点的左右子树的高度最多相差 1，这种高度的平衡保证了极佳的查找效率，但在进行插入和删除操作时，可能需要频繁地进行旋转来维持树的平衡，维护成本更高。\n\n#### [为什么用红黑树？](#为什么用红黑树)\n\n链表的查找时间复杂度是 `O(n)`，当链表长度较长时，查找性能会下降。红黑树是一种折中的方案，查找、插入、删除的时间复杂度都是 `O(log n)`。"
+ },
+ {
+ "id": 66,
+ "question": "红黑树怎么保持平衡的？",
+ "answer": "`旋转`和`染色`。\n\n①、通过左旋和右旋来调整树的结构，避免某一侧过深。\n\n\n\n②、染⾊，修复红黑规则，从而保证树的高度不会失衡。\n\n"
+ },
+ {
+ "id": 67,
+ "question": "HashMap 的 put 流程知道吗？",
+ "answer": "哈希寻址 → 处理哈希冲突（链表还是红黑树）→ 判断是否需要扩容 → 插入/覆盖节点。\n\n\n\n详细版：\n\n第一步，通过 hash 方法进一步扰动哈希值，以减少哈希冲突。\n\n\n```java\nstatic final int hash(Object key) {\n int h;\n return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```\n\n\n第二步，进行第一次的数组扩容；并使用哈希值和数组长度进行取模运算，确定索引位置。\n\n\n```java\nif ((tab = table) == null || (n = tab.length) == 0)\n n = (tab = resize()).length;\n\nif ((p = tab[i = (n - 1) & hash]) == null)\n tab[i] = newNode(hash, key, value, null);\n```\n\n\n如果当前位置为空，直接将键值对插入该位置；否则判断当前位置的第一个节点是否与新节点的 key 相同，如果相同直接覆盖 value，如果不同，说明发生哈希冲突。\n\n如果是链表，将新节点添加到链表的尾部；如果链表长度大于等于 8，则将链表转换为红黑树。\n\n\n```java\npublic V put(K key, V value) {\n return putVal(hash(key), key, value, false, true);\n}\n\nfinal V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {\n Node[] tab; Node p; int n, i;\n // 如果 table 为空，先进行初始化\n if ((tab = table) == null || (n = tab.length) == 0)\n n = (tab = resize()).length;\n \n // 计算索引位置，并找到对应的桶\n if ((p = tab[i = (n - 1) & hash]) == null)\n tab[i] = newNode(hash, key, value, null); // 如果桶为空，直接插入\n else {\n Node e; K k;\n // 检查第一个节点是否匹配\n if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))\n e = p; // 覆盖\n // 如果是树节点，放入树中\n else if (p instanceof TreeNode)\n e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);\n // 如果是链表，遍历插入到尾部\n else {\n for (int binCount = 0; ; ++binCount) {\n if ((e = p.next) == null) {\n p.next = newNode(hash, key, value, null);\n // 如果链表长度达到阈值，转换为红黑树\n if (binCount >= TREEIFY_THRESHOLD - 1)\n treeifyBin(tab, hash);\n break;\n }\n if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))\n break; // 覆盖\n p = e;\n }\n }\n if (e != null) { // 如果找到匹配的 key，则覆盖旧值\n V oldValue = e.value;\n if (!onlyIfAbsent || oldValue == null)\n e.value = value;\n afterNodeAccess(e);\n return oldValue;\n }\n }\n ++modCount; // 修改计数器\n if (++size > threshold)\n resize(); // 检查是否需要扩容\n afterNodeInsertion(evict);\n return null;\n}\n```\n\n\n每次插入新元素后，检查是否需要扩容，如果当前元素个数大于阈值（`capacity * loadFactor`），则进行扩容，扩容后的数组大小是原来的 2 倍；并且重新计算每个节点的索引，进行数据重新分布。\n\n#### [只重写元素的 equals 方法没重写 hashCode，put 的时候会发生什么?](#只重写元素的-equals-方法没重写-hashcode-put-的时候会发生什么)\n\n如果只重写 equals 方法，没有重写 hashCode 方法，那么会导致 equals 相等的两个对象，hashCode 不相等，这样的话，两个对象会被 put 到数组中不同的位置，导致 get 的时候，无法获取到正确的值。"
+ },
+ {
+ "id": 68,
+ "question": "HashMap 怎么查找元素的呢？",
+ "answer": "通过哈希值定位索引 → 定位桶 → 检查第一个节点 → 遍历链表或红黑树查找 → 返回结果。\n\n"
+ },
+ {
+ "id": 69,
+ "question": "HashMap 的 hash 函数是怎么设计的?",
+ "answer": "先拿到 key 的哈希值，是一个 32 位的 int 类型数值，然后再让哈希值的高 16 位和低 16 位进行异或操作，这样能保证哈希分布均匀。\n\n\n```java\nstatic final int hash(Object key) {\n int h;\n // 如果 key 为 null，返回 0；否则，使用 hashCode 并进行扰动\n return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```"
+ },
+ {
+ "id": 70,
+ "question": "为什么 hash 函数能减少哈希冲突？",
+ "answer": "快速回答：哈希表的索引是通过 `h & (n-1)` 计算的，n 是底层数组的容量；n-1 和某个哈希值做 `&` 运算，相当于截取了最低的四位。如果数组的容量很小，只取 h 的低位很容易导致哈希冲突。\n\n通过异或操作将 h 的高位引入低位，可以增加哈希值的随机性，从而减少哈希冲突。\n\n解释一下。\n\n\n\n以初始长度 16 为例，16-1=15。2 进制表示是`0000 0000 0000 0000 0000 0000 0000 1111`。只取最后 4 位相等于哈希值的高位都丢弃了。\n\n\n\n比如说 1111 1111 1111 1111 1111 1111 1111 1111，取最后 4 位，也就是 1111。\n\n1110 1111 1111 1111 1111 1111 1111 1111，取最后 4 位，也是 1111。\n\n不就发生哈希冲突了吗？\n\n这时候 hash 函数 `(h = key.hashCode()) ^ (h >>> 16)` 就派上用场了。\n\n\n\n将哈希值无符号右移 16 位，意味着原哈希值的高 16 位被移到了低 16 位的位置。这样，原始哈希值的高 16 位和低 16 位就可以参与到最终用于索引计算的低位中。\n\n选择 16 位是因为它是 32 位整数的一半，这样处理既考虑了高位的信息，又没有完全忽视低位原本的信息，从而达到了一种微妙的平衡状态。\n\n举个例子（数组长度为 16）。\n\n* 第一个键值对的键：h1 = 0001 0010 0011 0100 0101 0110 0111 1000\n* 第二个键值对的键：h2 = 0001 0010 0011 0101 0101 0110 0111 1000\n\n如果没有 hash 函数，直接取低 4 位，那么 h1 和 h2 的低 4 位都是 1000，也就是说两个键值对都会放在数组的第 8 个位置。\n\n来看一下 hash 函数的处理过程。\n\n①、对于第一个键`h1`的计算：\n\n\n```text\n原始: 0001 0010 0011 0100 0101 0110 0111 1000\n右移: 0000 0000 0000 0000 0001 0010 0011 0100\n异或: ---------------------------------------\n结果: 0001 0010 0011 0100 0100 0100 0100 1100\n```\n\n\n②、对于第二个键`h2`的计算：\n\n\n```text\n原始: 0001 0010 0011 0101 0101 0110 0111 1000\n右移: 0000 0000 0000 0000 0001 0010 0011 0101\n异或: ---------------------------------------\n结果: 0001 0010 0011 0101 0100 0100 0100 1101\n```\n\n\n通过上述计算，我们可以看到`h1`和`h2`经过`h ^ (h >>> 16)`操作后得到了不同的结果。\n\n现在，考虑数组长度为 16 时（需要最低 4 位来确定索引）：\n\n* 对于`h1`的最低 4 位是`1100`（十进制中为 12）\n* 对于`h2`的最低 4 位是`1101`（十进制中为 13）\n\n这样，`h1`和`h2`就会被分别放在数组的第 12 个位置和第 13 个位置上，从而避免了哈希冲突。"
+ },
+ {
+ "id": 71,
+ "question": "为什么 HashMap 的容量是 2 的幂次方？",
+ "answer": "是为了快速定位元素在底层数组中的下标。\n\nHashMap 是通过 `hash & (n-1)` 来定位元素下标的，n 为数组的大小，也就是 HashMap 底层数组的容量。\n\n数组长度-1 正好相当于一个“低位掩码”——掩码的低位最好全是 1，这样 & 运算才有意义，否则结果一定是 0。\n\n2 幂次方刚好是偶数，偶数-1 是奇数，奇数的二进制最后一位是 1，也就保证了 `hash &(length-1)` 的最后一位可能为 0，也可能为 1（取决于 hash 的值），这样可以保证哈希值的均匀分布。\n\n换句话说，& 操作的结果就是将哈希值的高位全部归零，只保留低位值。\n\n> a&b 的结果是：a、b 中对应位同时为 1，则结果为 1，否则为 0。例如 5&3=1，5 的二进制是 0101，3 的二进制是 0011，5&3=0001=1。\n\n假设某哈希值的二进制为 `10100101 11000100 00100101`，用它来做 & 运算，我们来看一下结果。\n\n已知 HashMap 的初始长度为 16，16-1=15，二进制是 `00000000 00000000 00001111`（高位用 0 来补齐）：\n\n\n```text\n\t 10100101 11000100 00100101\n&\t 00000000 00000000 00001111\n----------------------------------\n\t 00000000 00000000 00000101\n```\n\n\n因为 15 的高位全部是 0，所以 & 运算后的高位结果肯定也是 0，只剩下 4 个低位 `0101`，也就是十进制的 5。\n\n这样，哈希值为 `10100101 11000100 00100101` 的键就会放在数组的第 5 个位置上。\n\n#### [对数组长度取模定位数组下标，这块有没有优化策略？](#对数组长度取模定位数组下标-这块有没有优化策略)\n\n快速回答：HashMap 的策略是将取模运算 `hash % table.length` 优化为位运算 `hash & (length - 1)`。\n\n因为当数组的长度是 2 的 N 次幂时，`hash & (length - 1) = hash % length`。\n\n比如说 9 % 4 = 1，9 的二进制是 1001，4 - 1 = 3，3 的二进制是 0011，9 & 3 = 1001 & 0011 = 0001 = 1。\n\n再比如说 10 % 4 = 2，10 的二进制是 1010，4 - 1 = 3，3 的二进制是 0011，10 & 3 = 1010 & 0011 = 0010 = 2。\n\n当数组的长度不是 2 的 n 次方时，`hash % length` 和 `hash & (length - 1)` 的结果就不一致了。\n\n比如说 7 % 3 = 1，7 的二进制是 0111，3 - 1 = 2，2 的二进制是 0010，7 & 2 = 0111 & 0010 = 0010 = 2。\n\n从二进制角度来看，hash / length = hash / 2n = hash >> n，即把 hash 右移 n 位，此时得到了 hash / 2n 的商。\n\n而被移调的部分，则是 hash % 2n，也就是余数。\n\n2n 的二进制形式为 1，后面跟着 n 个 0，那 2n - 1 的二进制则是 n 个 1。例如 8 = 23，二进制是 1000，7 = 23 - 1，二进制为 0111。\n\n`hash % length`的操作是求 hash 除以 2n 的余数。在二进制中，这个操作的结果就是 hash 的二进制表示中最低 n 位的值。\n\n因为在 2n 取模的操作中，高于 2n 表示位的所有数值对结果没有贡献，只有低于这个阈值的部分才决定余数。\n\n比如说 26 的二进制是 11010，要计算 26 % 8，8 是 23，所以我们关注的是 26 的二进制表示中最低 3 位：11010 的最低 3 位是 010。\n\n010 对应于十进制中的 2，26 % 8 的结果是 2。\n\n当执行`hash & (length - 1)`时，实际上是保留 hash 二进制表示的最低 n 位，其他高位都被清零。\n\n举个例子，hash 为 14，n 为 3，也就是数组长度为 23，也就是 8。\n\n\n```text\n 1110 (hash = 14)\n& 0111 (length - 1 = 7)\n ----\n 0110 (结果 = 6)\n```\n\n\n保留 14 的最低 3 位，高位被清零。\n\n从此，两个运算 `hash % length` 和 `hash & (length - 1)` 有了完美的闭环。在计算机中，位运算的速度要远高于取余运算，因为计算机本质上就是二进制嘛。\n\n#### [说说什么是取模运算？](#说说什么是取模运算)\n\n在 Java 中，通常使用 % 运算符来表示取余，用 `Math.floorMod()` 来表示取模。\n\n当操作数都是正数的话，取模运算和取余运算的结果是一样的；只有操作数出现负数的情况下，结果才会不同。\n\n**取模运算的商向负无穷靠近；取余运算的商向 0 靠近**。这是导致它们两个在处理有负数情况下，结果不同的根本原因。\n\n当数组的长度是 2 的 n 次幂时，取模运算/取余运算可以用位运算来代替，效率更高，毕竟计算机本身只认二进制。\n\n比如说，7 对 3 取余，和 7 对 3 取模，结果都是 1。因为两者都是基于除法运算的，7 / 3 的商是 2，余数是 1。\n\n对于 HashMap 来说，它需要通过 `hash % table.length` 来确定元素在数组中的位置。\n\n比如说，数组长度是 3，hash 是 7，那么 7 % 3 的结果就是 1，也就是此时可以把元素放在下标为 1 的位置。\n\n当 hash 是 8，8 % 3 的结果就是 2，也就是可以把元素放在下标为 2 的位置。\n\n当 hash 是 9，9 % 3 的结果就是 0，也就是可以把元素放在下标为 0 的位置上。\n\n是不是很奇妙，数组的大小为 3，刚好 3 个位置都利用上了。"
+ },
+ {
+ "id": 72,
+ "question": "如果初始化 HashMap，传一个 17 的容量，它会怎么处理？",
+ "answer": "HashMap 会将容量调整到大于等于 17 的最小的 2 的幂次方，也就是 32。\n\n\n\n这是因为哈希表的大小最好是 2 的 N 次幂，这样可以通过 `(n - 1) & hash` 高效计算出索引值。\n\n解释一下。\n\n在 HashMap 的初始化构造方法中，有这样⼀段代码：\n\n\n```java\npublic HashMap(int initialCapacity, float loadFactor) {\n ...\n this.loadFactor = loadFactor;\n this.threshold = tableSizeFor(initialCapacity);\n}\n```\n\n\n阀值 threshold 会通过⽅法 `tableSizeFor()` 进⾏计算。\n\n\n```java\nstatic final int tableSizeFor(int cap) {\n int n = cap - 1;\n n |= n >>> 1;\n n |= n >>> 2;\n n |= n >>> 4;\n n |= n >>> 8;\n n |= n >>> 16;\n return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;\n}\n```\n\n\n①、`int n = cap - 1;` 避免刚好是 2 的幂次方时，容量直接翻倍。\n\n②、接下来通过不断右移（`>>>`）并与自身进行或运算（`|=`），将 n 的二进制表示中的所有低位设置为 1。\n\n* `n |= n >>> 1;` 将最高位的 1 扩展到下一位。\n* `n |= n >>> 2;` 扩展到后两位。\n* 依此类推，直到 `n |= n >>> 16;`，扩展到后十六位，这样从最高位的 1 到最低位，就都变成了 1。\n\n③、如果 n 小于 0，说明 cap 是负数，直接返回 1。\n\n如果 n 大于或等于 MAXIMUM\\_CAPACITY（通常是230），则返回 MAXIMUM\\_CAPACITY。\n\n否则，返回 n + 1，这是因为 n 的所有低位都是 1，所以 n + 1 就是大于 cap 的最小的 2 的幂次方。\n\n#### [初始化 HashMap 的时候需要传入容量吗？](#初始化-hashmap-的时候需要传入容量吗)\n\n如果预先知道 Map 将存储大量键值对，提前指定一个足够大的初始容量可以减少因扩容导致的重哈希操作。\n\n因为每次扩容时，HashMap 需要将现有的元素插入到新的数组中，这个过程相对耗时，尤其是当 Map 中已有大量数据时。\n\n当然了，过大的初始容量会浪费内存，特别是当实际存储的元素远少于初始容量时。如果不指定初始容量，HashMap 将使用默认的初始容量 16。"
+ },
+ {
+ "id": 73,
+ "question": "你还知道哪些哈希函数的构造方法呢？",
+ "answer": "①、**除留取余法**：`H(key)=key%p(p<=N)`，关键字除以一个不大于哈希表长度的正整数 p，所得余数为地址，当然 HashMap 里进行了优化改造，效率更高，散列也更均衡。\n\n除此之外，还有这几种常见的哈希函数构造方法：\n\n②、**直接定址法**：直接根据`key`来映射到对应的数组位置，例如 1232 放到下标 1232 的位置。\n\n③、**数字分析法**：取`key`的某些数字（例如十位和百位）作为映射的位置\n\n④、**平方取中法**：取`key`平方的中间几位作为映射的位置\n\n⑤、将`key`分割成位数相同的几段，然后把它们的叠加和作为映射的位置。\n\n"
+ },
+ {
+ "id": 74,
+ "question": "解决哈希冲突有哪些方法？",
+ "answer": "简版回答：我知道的有 3 种，再哈希法、开放地址法和拉链法。\n\n#### [什么是再哈希法？](#什么是再哈希法)\n\n准备两套哈希算法，当发生哈希冲突的时候，使用另外一种哈希算法，直到找到空槽为止。对哈希算法的设计要求比较高。\n\n#### [什么是开放地址法？](#什么是开放地址法)\n\n遇到哈希冲突的时候，就去寻找下一个空的槽。有 3 种方法：\n\n* 线性探测：从冲突的位置开始，依次往后找，直到找到空槽。\n* 二次探测：从冲突的位置 x 开始，第一次增加 12 个位置，第二次增加 22，直到找到空槽。\n* 双重哈希：和再哈希法类似，准备多个哈希函数，发生冲突的时候，使用另外一个哈希函数。\n\n\n\n#### [什么是拉链法？](#什么是拉链法)\n\n也就是链地址法，当发生哈希冲突的时候，使用链表将冲突的元素串起来。HashMap 采用的正是拉链法。\n\n#### [怎么判断 key 相等呢？](#怎么判断-key-相等呢)\n\n依赖于`key`的`equals()`方法和`hashCode()`方法。\n\n\n```java\nif (e.hash == hash &&\n((k = e.key) == key || (key != null && key.equals(k))))\n```\n\n\n①、**hashCode()** ：使用`key`的`hashCode()`方法计算`key`的哈希码。\n\n②、**equals()** ：当两个`key`的哈希码相同时，`HashMap`还会调用`key`的`equals()`方法进行精确比较。只有当`equals()`方法返回`true`时，两个`key`才被认为是完全相同的。\n\n如果两个`key`的引用指向了同一个对象，那么它们的`hashCode()`和`equals()`方法都会返回`true`，所以在 equals 判断之前可以先使用`==`运算符判断一次。"
+ },
+ {
+ "id": 75,
+ "question": "为什么 HashMap 链表转红黑树的阈值为 8 呢？",
+ "answer": "树化发生在 table 数组的长度大于 64，且链表的长度大于 8 的时候。\n\n为什么是 8 呢？源码的注释也给出了答案。\n\n\n\n红黑树节点的大小大概是普通节点大小的两倍，所以转红黑树，牺牲了空间换时间，更多的是一种兜底的策略，保证极端情况下的查找效率。\n\n阈值为什么要选 8 呢？和统计学有关。理想情况下，使用随机哈希码，链表里的节点符合泊松分布，出现节点个数的概率是递减的，节点个数为 8 的情况，发生概率仅为`0.00000006`。\n\n至于红黑树转回链表的阈值为什么是 6，而不是 8？是因为如果这个阈值也设置成 8，假如发生碰撞，节点增减刚好在 8 附近，会发生链表和红黑树的不断转换，导致资源浪费。"
+ },
+ {
+ "id": 76,
+ "question": "HashMap扩容发生在什么时候呢？",
+ "answer": "当键值对数量超过阈值，也就是容量 \\* 负载因子时。\n\n\n\n#### [默认的负载因子是多少？](#默认的负载因子是多少)\n\n0.75。\n\n#### [初始容量是多少？](#初始容量是多少)\n\n16。\n\n1 左移 4 位，`0000 0001 → 0001 0000`，也就是 2 的 4 次方。\n\n\n```java\nstatic final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16\n```\n\n\n#### [为什么使用 1 << 4 而不是直接写 16？](#为什么使用-1-4-而不是直接写-16)\n\n写 `1<<4` 主要是为了强调这个值是 2 的幂次方，而不是一个完全随机的选择。\n\n无论 HashMap 是否扩容，其底层的数组长度都应该是 2 的幂次方，因为这样可以通过位运算快速计算出元素的索引。\n\n#### [为什么选择 0.75 作为 HashMap 的默认负载因子呢？](#为什么选择-0-75-作为-hashmap-的默认负载因子呢)\n\n这是一个经验值。如果设置得太低，如 0.5，会浪费空间；如果设置得太高，如 0.9，会增加哈希冲突。\n\n\n\n0.75 是 JDK 作者经过大量验证后得出的最优解，能够最大限度减少 rehash 的次数。"
+ },
+ {
+ "id": 77,
+ "question": "HashMap的扩容机制了解吗？",
+ "answer": "扩容时，HashMap 会创建一个新的数组，其容量是原来的两倍。然后遍历旧哈希表中的元素，将其重新分配到新的哈希表中。\n\n如果当前桶中只有一个元素，那么直接通过键的哈希值与数组大小取模锁定新的索引位置：`e.hash & (newCap - 1)`。\n\n如果当前桶是红黑树，那么会调用 `split()` 方法分裂树节点，以保证树的平衡。\n\n如果当前桶是链表，会通过旧键的哈希值与旧的数组大小取模 `(e.hash & oldCap) == 0` 来作为判断条件，如果条件为真，元素保留在原索引的位置；否则元素移动到原索引 + 旧数组大小的位置。\n\n#### [JDK 7 扩容的时候有什么问题？](#jdk-7-扩容的时候有什么问题)\n\nJDK 7 在扩容的时候使用头插法来重新插入链表节点，这样会导致链表无法保持原有的顺序。\n\n详细解释一下。\n\nJDK 7 是通过哈希值与数组大小-1 进行与运算确定元素下标的。\n\n\n```java\nstatic int indexFor(int h, int length) {\n return h & (length-1);\n}\n```\n\n\n我们来假设：\n\n* 数组 table 的长度为 2\n* 键的哈希值为 3、7、5\n\n取模运算后，键发生了哈希冲突，它们都需要放到 `table[1]` 的桶上。那么扩容前就是这个样子：\n\n\n\n假设负载因子 loadFactor 为 1，也就是当元素的个数大于 table 的长度时进行扩容。\n\n扩容后的数组容量为 4。\n\n* key 3 取模（3%4）后是 3，放在 `table[3]` 上。\n* key 7 取模（7%4）后是 3，放在 `table[3]` 上的链表头部。\n* key 5 取模（5%4）后是 1，放在 `table[1]` 上。\n\n\n\n可以看到，由于 JDK 采用的是头插法，7 跑到 3 的前面了，原来的顺序是 3、7、5，7 在 3 的后面。\n\n\n```java\nfor (Entry e : oldTable) {\n while (null != e) {\n Entry next = e.next;\n int i = indexFor(e.hash, newCapacity);\n e.next = newTable[i];\n newTable[i] = e;\n e = next;\n }\n}\n```\n\n\n最好的情况就是，扩容后的 7 还在 3 的后面，保持原来的顺序。\n\n#### [JDK 8 是怎么解决这个问题的？](#jdk-8-是怎么解决这个问题的)\n\nJDK 8 改用了尾插法，并且当 `(e.hash & oldCap) == 0` 时，元素保留在原索引的位置；否则元素移动到原索引 + 旧数组大小的位置。\n\n\n```java\nNode loHead = null, loTail = null;\nNode hiHead = null, hiTail = null;\nNode next;\ndo {\n next = e.next;\n if ((e.hash & oldCap) == 0) {\n if (loTail == null)\n loHead = e;\n else\n loTail.next = e;\n loTail = e;\n }\n else {\n if (hiTail == null)\n hiHead = e;\n else\n hiTail.next = e;\n hiTail = e;\n }\n} while ((e = next) != null);\nif (loHead != null)\n newTab[j] = loHead;\nif (hiHead != null)\n newTab[j + oldCap] = hiHead;\n```\n\n\n由于扩容时，数组长度会翻倍，例如：16 → 32， 因此，新数组的索引范围是原索引范围的两倍。\n\n原索引 `index = (n - 1) & hash`，扩容后的新索引就是 `index = (2n - 1) & hash`。\n\n也就是说，如果 `(e.hash & oldCap) == 0`，元素在新数组中的位置与旧位置相同；否则，元素在新数组中的位置是旧位置 + 旧数组大小。\n\n假设扩容前的数组长度为 16（n-1 也就是二进制的 0000 1111，1X20+1X21+1X22+1X23=1+2+4+8=15），key1 为 5（二进制为 0000 0101），key2 为 21（二进制为 0001 0101）。\n\n* key1 和 n-1 做 & 运算后为 0000 0101，也就是 5；\n* key2 和 n-1 做 & 运算后为 0000 0101，也就是 5。\n* 此时哈希冲突了，用拉链法来解决哈希冲突。\n\n现在，HashMap 进行了扩容，容量为原来的 2 倍，也就是 32（n-1 也就是二进制的 0001 1111，1X20+1X21+1X22+1X23+1X24=1+2+4+8+16=31）。\n\n* key1 和 n-1 做 & 运算后为 0000 0101，也就是 5；\n* key2 和 n-1 做 & 运算后为 0001 0101，也就是 21=5+16，就是数组扩容前的位置+原数组的长度。\n\n\n\n这样可以避免重新计算所有元素的哈希值，只需检查高位的某一位，就可以快速确定新位置。\n\n\n\n#### [扩容的时候每个节点都要进行位运算吗？](#扩容的时候每个节点都要进行位运算吗)\n\n不需要。HashMap 会通过 `(e.hash & oldCap)` 来判断节点是否需要移动，0 的话保留原索引；1 才需要移动到新索引（原索引 + oldCap）。\n\n这样就避免了 hashCode 的重新计算，大大提升了扩容的性能。\n\n所以，哪怕有几十万条数据，可能只有一半的数据才需要移动到新位置。另外，位运算的计算速度非常快，因此，尽管扩容操作涉及到遍历整个哈希表并对每个节点进行判断，但这部分操作的计算成本是相对较低的。"
+ },
+ {
+ "id": 78,
+ "question": "JDK 8 对 HashMap 做了哪些优化呢？",
+ "answer": "①、底层数据结构由数组 + 链表改成了数组 + 链表或红黑树的结构。\n\n如果多个键映射到了同一个哈希值，链表会变得很长，在最坏的情况下，当所有的键都映射到同一个桶中时，性能会退化到 O(n)，而红黑树的时间复杂度是 O(logn)。\n\n②、链表的插入方式由头插法改为了尾插法。头插法在扩容后容易改变原来链表的顺序。\n\n③、扩容的时机由插入时判断改为插入后判断，这样可以避免在每次插入时都进行不必要的扩容检查，因为有可能插入后仍然不需要扩容。\n\n\n\n④、哈希扰动算法也进行了优化。JDK 7 是通过多次移位和异或运算来实现的。\n\n\n\nJDK 8 让 hash 值的高 16 位和低 16 位进行了异或运算，让高位的信息也能参与到低位的计算中，这样可以极大程度上减少哈希碰撞。\n\n"
+ },
+ {
+ "id": 79,
+ "question": "你能自己设计实现一个 HashMap 吗？",
+ "answer": "> 这道题**快手**常考。红黑树版咱们多半是写不出来的，但是数组+链表版还是问题不大，详细可见： [手写 HashMap，快手面试官直呼内行！](https://mp.weixin.qq.com/s/Z9yoRZW5itrtgbS-cj0bUg)。\n\n可以，我先说一下整体的设计思路：\n\n* 第一步，实现一个 hash 函数，对键的 hashCode 进行扰动\n* 第二步，实现一个拉链法的方法来解决哈希冲突\n* 第三步，扩容后，重新计算哈希值，将元素放到新的数组中\n\n\n\n完整代码：\n\n"
+ },
+ {
+ "id": 80,
+ "question": "HashMap 是线程安全的吗？",
+ "answer": "HashMap 不是线程安全的，主要有以下几个问题：\n\n①、多线程下扩容会死循环。JDK7 中的 HashMap 使用的是头插法来处理链表，在多线程环境下扩容会出现环形链表，造成死循环。\n\n\n\n不过，JDK 8 时通过尾插法修复了这个问题，扩容时会保持链表原来的顺序。\n\n②、多线程在进行 put 元素的时候，可能会导致元素丢失。因为计算出来的位置可能会被其他线程覆盖掉，比如说一个县城 put 3 的时候，另外一个线程 put 了 7，就把 3 给弄丢了。\n\n\n\n③、put 和 get 并发时，可能导致 get 为 null。线程 1 执行 put 时，因为元素个数超出阈值而扩容，线程 2 此时执行 get，就有可能出现这个问题。\n\n\n\n因为线程 1 执行完 table = newTab 之后，线程 2 中的 table 已经发生了改变，比如说索引 3 的键值对移动到了索引 7 的位置，此时线程 2 去 get 索引 3 的元素就 get 不到了。"
+ },
+ {
+ "id": 81,
+ "question": "怎么解决 HashMap 线程不安全的问题呢？",
+ "answer": "在早期的 JDK 版本中，可以用 Hashtable 来保证线程安全。Hashtable 在方法上加了 。\n\n\n\n另外，可以通过 `Collections.synchronizedMap` 方法返回一个线程安全的 Map，内部是通过 synchronized 对象锁来保证线程安全的，比在方法上直接加 synchronized 关键字更轻量级。\n\n\n\n更优雅的解决方案是使用并发工具包下的 ，使用了+ 来保证线程安全。\n\n"
+ },
+ {
+ "id": 82,
+ "question": "HashMap 内部节点是有序的吗？",
+ "answer": "无序的，根据 hash 值随机插入。"
+ },
+ {
+ "id": 83,
+ "question": "讲讲 LinkedHashMap 怎么实现有序的？",
+ "answer": "LinkedHashMap 在 HashMap 的基础上维护了一个双向链表，通过 before 和 after 标识前置节点和后置节点。\n\n\n\n从而实现插入的顺序或访问顺序。\n\n"
+ },
+ {
+ "id": 84,
+ "question": "讲讲 TreeMap 怎么实现有序的？",
+ "answer": "TreeMap 通过 key 的比较器来决定元素的顺序，如果没有指定比较器，那么 key 必须实现 。\n\n\n\nTreeMap 的底层是红黑树，红黑树是一种自平衡的二叉查找树，每个节点都大于其左子树中的任何节点，小于其右子节点树种的任何节点。\n\n\n\n插入或者删除元素时通过旋转和染色来保持树的平衡。\n\n查找的时候从根节点开始，利用二叉查找树的特点，逐步向左子树或者右子树递归查找，直到找到目标元素。"
+ },
+ {
+ "id": 85,
+ "question": "TreeMap 和 HashMap 的区别",
+ "answer": "①、HashMap 是基于数组+链表+红黑树实现的，put 元素的时候会先计算 key 的哈希值，然后通过哈希值计算出元素在数组中的存放下标，然后将元素插入到指定的位置，如果发生哈希冲突，会使用链表来解决，如果链表长度大于 8，会转换为红黑树。\n\n②、TreeMap 是基于红黑树实现的，put 元素的时候会先判断根节点是否为空，如果为空，直接插入到根节点，如果不为空，会通过 key 的比较器来判断元素应该插入到左子树还是右子树。\n\n在没有发生哈希冲突的情况下，HashMap 的查找效率是 `O(1)`。适用于查找操作比较频繁的场景。\n\nTreeMap 的查找效率是 `O(logn)`。并且保证了元素的顺序，因此适用于需要大量范围查找或者有序遍历的场景。"
+ }
+ ]
+ },
+ {
+ "id": 18,
+ "categoryName": "Set",
+ "questions": [
+ {
+ "id": 86,
+ "question": "讲讲 HashSet 的底层实现？",
+ "answer": "HashSet 是由 HashMap 实现的，只不过值由一个固定的 Object 对象填充，而键用于操作。\n\n\n```java\npublic class HashSet\n extends AbstractSet\n implements Set, Cloneable, java.io.Serializable\n{\n static final long serialVersionUID = -5024744406713321676L;\n private transient HashMap map;\n // Dummy value to associate with an Object in the backing Map\n private static final Object PRESENT = new Object();\n // ……\n}\n```\n\n\n实际开发中，HashSet 并不常用，比如，如果我们需要按照顺序存储一组元素，那么 ArrayList 和 LinkedList 更适合；如果我们需要存储键值对并根据键进行查找，那么 HashMap 可能更适合。\n\nHashSet 主要用于去重，比如，我们需要统计一篇文章中有多少个不重复的单词，就可以使用 HashSet 来实现。\n\n\n```java\n// 创建一个 HashSet 对象\nHashSet set = new HashSet<>();\n\n// 添加元素\nset.add(\"practice-mate\");\nset.add(\"练习伴侣二\");\nset.add(\"陈清扬\");\nset.add(\"practice-mate\");\n\n// 输出 HashSet 的元素个数\nSystem.out.println(\"HashSet size: \" + set.size()); // output: 3\n\n// 遍历 HashSet\nfor (String s : set) {\n System.out.println(s);\n}\n```\n\n\nHashSet 会自动去重，因为它是用 HashMap 实现的，HashMap 的键是唯一的，相同键会覆盖掉原来的键，于是第二次 add 一个相同键的元素会直接覆盖掉第一次的键。\n\n\n\n#### [HashSet 和 ArrayList 的区别](#hashset-和-arraylist-的区别)\n\n* ArrayList 是基于动态数组实现的，HashSet 是基于 HashMap 实现的。\n* ArrayList 允许重复元素和 null 值，可以有多个相同的元素；HashSet 保证每个元素唯一，不允许重复元素，基于元素的 hashCode 和 equals 方法来确定元素的唯一性。\n* ArrayList 保持元素的插入顺序，可以通过索引访问元素；HashSet 不保证元素的顺序，元素的存储顺序依赖于哈希算法，并且可能随着元素的添加或删除而改变。\n\n#### [HashSet 怎么判断元素重复，重复了是否 put](#hashset-怎么判断元素重复-重复了是否-put)\n\nHashSet 的 add 方法是通过调用 HashMap 的 put 方法实现的：\n\n\n```java\npublic boolean add(E e) {\n return map.put(e, PRESENT)==null;\n}\n```\n\n\n所以 HashSet 判断元素重复的逻辑底层依然是 HashMap 的底层逻辑：\n\n\n\nHashMap 在插入元素时，通常需要三步：\n\n第一步，通过 hash 方法计算 key 的哈希值。\n\n\n```java\nstatic final int hash(Object key) {\n int h;\n return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```\n\n\n第二步，数组进行第一次扩容。\n\n\n```java\nif ((tab = table) == null || (n = tab.length) == 0)\n n = (tab = resize()).length;\n```\n\n\n第三步，根据哈希值计算 key 在数组中的下标，如果对应下标正好没有存放数据，则直接插入。\n\n\n```java\nif ((p = tab[i = (n - 1) & hash]) == null)\n tab[i] = newNode(hash, key, value, null);\n```\n\n\n如果对应下标已经有数据了，就需要判断是否为相同的 key，是则覆盖 value，否则需要判断是否为树节点，是则向树中插入节点，否则向链表中插入数据。\n\n\n```java\nelse {\n Node e; K k;\n if (p.hash == hash &&\n ((k = p.key) == key || (key != null && key.equals(k))))\n e = p;\n else if (p instanceof TreeNode)\n e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);\n else {\n for (int binCount = 0; ; ++binCount) {\n if ((e = p.next) == null) {\n p.next = newNode(hash, key, value, null);\n if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st\n treeifyBin(tab, hash);\n break;\n }\n if (e.hash == hash &&\n ((k = e.key) == key || (key != null && key.equals(k))))\n break;\n p = e;\n }\n }\n}\n```\n\n\n也就是说，HashSet 通过元素的哈希值来判断元素是否重复，如果重复了，会覆盖原来的值。\n\n\n```java\nif (e != null) { // existing mapping for key\n V oldValue = e.value;\n if (!onlyIfAbsent || oldValue == null)\n e.value = value;\n afterNodeAccess(e);\n return oldValue;\n}\n```"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 3,
+ "topicName": "Java并发",
+ "categories": [
+ {
+ "id": 19,
+ "categoryName": "基础",
+ "questions": [
+ {
+ "id": 87,
+ "question": "并行跟并发有什么区别？",
+ "answer": "* 并行是多核 CPU 上的多任务处理，多个任务在同一时间真正地同时执行。\n* 并发是单核 CPU 上的多任务处理，多个任务在同一时间段内交替执行，通过时间片轮转实现交替执行，用于解决 IO 密集型任务的瓶颈。\n\n\n\n举个例子，就好像我们去食堂打饭，并行就是每个人对应一个阿姨，同时打饭；而并发就是一个阿姨，轮流给每个人打饭，假如有个人磨磨唧唧，阿姨就会吆喝下一个人，这样就能提高食堂的打饭效率。\n\n\n\n#### [你是如何理解线程安全的？](#你是如何理解线程安全的)\n\n如果一段代码块或者一个方法被多个线程同时执行，还能够正确地处理共享数据，那么这段代码块或者这个方法就是线程安全的。\n\n可以从三个要素来确保线程安全：\n\n**①、原子性**：一个操作要么完全执行，要么完全不执行，不会出现中间状态。\n\n\n\n可以通过同步关键字 synchronized 或原子操作，如 AtomicInteger 来保证原子性。\n\n\n```java\nAtomicInteger count = new AtomicInteger(0);\ncount.incrementAndGet(); // 原子操作\n```\n\n\n**②、可见性**：当一个线程修改了共享变量，其他线程能够立即看到变化。\n\n\n\n可以通过 volatile 关键字来保证可见性。\n\n\n```java\nprivate volatile String itwanger = \"练习伴侣二\";\n```\n\n\n**③、有序性**：要确保线程不会因为死锁、饥饿、活锁等问题导致无法继续执行。\n\n"
+ },
+ {
+ "id": 88,
+ "question": "说说进程和线程的区别？",
+ "answer": "进程说简单点就是我们在电脑上启动的一个个应用。它是操作系统分配资源的最小单位。\n\n线程是进程中的独立执行单元。多个线程可以共享同一个进程的资源，如内存；每个线程都有自己独立的栈和寄存器。\n\n\n\n#### [如何理解协程？](#如何理解协程)\n\n协程被视为比线程更轻量级的并发单元，可以在单线程中实现并发执行，由我们开发者显式调度。\n\n协程是在用户态进行调度的，避免了线程切换时的内核态开销。\n\nJava 自身是不支持携程的，我们可以使用 Quasar、Kotlin 等框架来实现协程。\n\n\n```java\nfun main() = runBlocking {\n launch {\n delay(1000L)\n println(\"World!\")\n }\n println(\"Hello,\")\n}\n```\n\n\n#### [线程间是如何进行通信的？](#线程间是如何进行通信的)\n\n原则上可以通过消息传递和共享内存两种方法来实现。Java 采用的是共享内存的并发模型。\n\n这个模型被称为 Java 内存模型，简写为 JMM，它决定了一个线程对共享变量的写入，何时对另外一个线程可见。当然了，本地内存是 JMM 的一个抽象概念，并不真实存在。\n\n用一句话来概括就是：共享变量存储在主内存中，每个线程的私有本地内存，存储的是这个共享变量的副本。\n\n\n\n线程 A 与线程 B 之间如要通信，需要要经历 2 个步骤：\n\n* 线程 A 把本地内存 A 中的共享变量副本刷新到主内存中。\n* 线程 B 到主内存中读取线程 A 刷新过的共享变量，再同步到自己的共享变量副本中。\n\n"
+ },
+ {
+ "id": 89,
+ "question": "说说线程有几种创建方式？",
+ "answer": "有三种，分别是继承 Thread 类、实现 Runnable 接口、实现 Callable 接口。\n\n\n\n第一种需要重写父类 Thread 的 `run()` 方法，并且调用 `start()` 方法启动线程。\n\n\n```java\nclass ThreadTask extends Thread {\n public void run() {\n System.out.println(\"看完练习伴侣，上岸了!\");\n }\n\n public static void main(String[] args) {\n ThreadTask task = new ThreadTask();\n task.start();\n }\n}\n```\n\n\n这种方法的缺点是，如果 ThreadTask 已经继承了另外一个类，就不能再继承 Thread 类了，因为 Java 不支持多重继承。\n\n第二种需要重写 Runnable 接口的 `run()` 方法，并将实现类的对象作为参数传递给 Thread 对象的构造方法，最后调用 `start()` 方法启动线程。\n\n\n```java\nclass RunnableTask implements Runnable {\n public void run() {\n System.out.println(\"看完练习伴侣，上岸了!\");\n }\n\n public static void main(String[] args) {\n RunnableTask task = new RunnableTask();\n Thread thread = new Thread(task);\n thread.start();\n }\n}\n```\n\n\n这种方法的优点是可以避免 Java 的单继承限制，并且更符合面向对象的编程思想，因为 Runnable 接口将任务代码和线程控制的代码解耦了。\n\n第三种需要重写 Callable 接口的 `call()` 方法，然后创建 FutureTask 对象，参数为 Callable 实现类的对象；紧接着创建 Thread 对象，参数为 FutureTask 对象，最后调用 `start()` 方法启动线程。\n\n\n```java\nclass CallableTask implements Callable {\n public String call() {\n return \"看完练习伴侣，上岸了!\";\n }\n\n public static void main(String[] args) throws ExecutionException, InterruptedException {\n CallableTask task = new CallableTask();\n FutureTask futureTask = new FutureTask<>(task);\n Thread thread = new Thread(futureTask);\n thread.start();\n System.out.println(futureTask.get());\n }\n}\n```\n\n\n这种方法的优点是可以获取线程的执行结果。\n\n#### [一个 8G 内存的系统最多能创建多少个线程?](#一个-8g-内存的系统最多能创建多少个线程)\n\n理论上大约 8000 个。\n\n创建线程的时候，至少需要分配一个虚拟机栈，在 64 位操作系统中，默认大小为 1M，因此一个线程大约需要 1M 的内存。\n\n但 JVM、操作系统本身的运行就要占一定的内存空间，所以实际上可以创建的线程数远比 8000 少。\n\n详细解释一下。\n\n可以通过 `java -XX:+PrintFlagsFinal -version | grep ThreadStackSize` 命令查看 JVM 栈的默认大小。\n\n\n\n其中 ThreadStackSize 的单位是 KB，也就是说默认的 JVM 栈大小是 1024 KB，也就是 1M。\n\n#### [启动一个 Java 程序，你能说说里面有哪些线程吗？](#启动一个-java-程序-你能说说里面有哪些线程吗)\n\n首先是 main 线程，这是程序执行的入口。\n\n然后是垃圾回收线程，它是一个后台线程，负责回收不再使用的对象。\n\n还有编译器线程，比如 JIT，负责把一部分热点代码编译后放到 codeCache 中。\n\n\n\n可以通过下面的代码进行检测：\n\n\n```java\nclass ThreadLister {\n public static void main(String[] args) {\n // 获取所有线程的堆栈跟踪\n Map threads = Thread.getAllStackTraces();\n for (Thread thread : threads.keySet()) {\n System.out.println(\"Thread: \" + thread.getName() + \" (ID=\" + thread.getId() + \")\");\n }\n }\n}\n```\n\n\n结果如下所示：\n\n\n```text\nThread: Monitor Ctrl-Break (ID=5)\nThread: Reference Handler (ID=2)\nThread: main (ID=1)\nThread: Signal Dispatcher (ID=4)\nThread: Finalizer (ID=3)\n```\n\n\n简单解释下：\n\n* `Thread: main (ID=1)` - 主线程，Java 程序启动时由 JVM 创建。\n* `Thread: Reference Handler (ID=2)` - 这个线程是用来处理引用对象的，如软引用、弱引用和虚引用。负责清理被 JVM 回收的对象。\n* `Thread: Finalizer (ID=3)` - 终结器线程，负责调用对象的 finalize 方法。对象在垃圾回收器标记为可回收之前，由该线程执行其 finalize 方法，用于执行特定的资源释放操作。\n* `Thread: Signal Dispatcher (ID=4)` - 信号调度线程，处理来自操作系统的信号，将它们转发给 JVM 进行进一步处理，例如响应中断、停止等信号。\n* `Thread: Monitor Ctrl-Break (ID=5)` - 监视器线程，通常由一些特定的 IDE 创建，用于在开发过程中监控和管理程序执行或者处理中断。"
+ },
+ {
+ "id": 90,
+ "question": "调用 start 方法时会执行 run 方法，那怎么不直接调用 run方法？",
+ "answer": "调用 `start()` 会创建一个新的线程，并异步执行 `run()` 方法中的代码。\n\n直接调用 `run()` 方法只是一个普通的同步方法调用，所有代码都在当前线程中执行，不会创建新线程。没有新的线程创建，也就达不到多线程并发的目的。\n\n通过敲代码体验一下。\n\n\n```java\nclass MyThread extends Thread {\n public void run() {\n System.out.println(Thread.currentThread().getName());\n }\n\n public static void main(String[] args) {\n MyThread t1 = new MyThread();\n t1.start(); // 正确的方式，创建一个新线程，并在新线程中执行 run()\n t1.run(); // 仅在主线程中执行 run()，没有创建新线程\n }\n}\n```\n\n\n来看输出结果：\n\n\n```text\nmain\nThread-0\n```\n\n\n也就是说，调用 `start()` 方法会通知 JVM，去调用底层的线程调度机制来启动新线程。\n\n\n\n调用 `start()` 后，线程进入就绪状态，等待操作系统调度；一旦调度执行，线程会执行其 `run()` 方法中的代码。"
+ },
+ {
+ "id": 91,
+ "question": "线程有哪些常用的调度方法？",
+ "answer": "比如说 start 方法用于启动线程并让操作系统调度执行；sleep 方法用于让当前线程休眠一段时间；wait 方法会让当前线程等待，notify 会唤醒一个等待的线程。\n\n\n\n#### [说说wait方法和notify方法？](#说说wait方法和notify方法)\n\n当线程 A 调用共享对象的 `wait()` 方法时，线程 A 会被阻塞挂起，直到：\n\n* 线程 B 调用了共享对象的 `notify()` 方法或者 `notifyAll()` 方法；\n* 其他线程调用线程 A 的 `interrupt()` 方法，导致线程 A 抛出 InterruptedException 异常。\n\n线程 A 调用共享对象的 `wait(timeout)`方法后，没有在指定的 timeout 时间内被其它线程唤醒，那么这个方法会因为超时而返回。\n\n当线程 A 调用共享对象的 `notify()` 方法后，会唤醒一个在这个共享对象上调用 wait 系列方法被挂起的线程。\n\n共享对象上可能会有多个线程在等待，具体唤醒哪个线程是随机的。\n\n如果调用的是 notifyAll 方法，会唤醒所有在这个共享变量上调用 wait 系列方法而被挂起的线程。\n\n#### [说说 sleep 方法？](#说说-sleep-方法)\n\n当线程 A 调用了 Thread 的 sleep 方法后，线程 A 会暂时让出指定时间的执行权。\n\n指定的睡眠时间到了后该方法会正常返回，接着参与 CPU 调度，获取到 CPU 资源后可以继续执行。\n\n#### [说说yield方法？](#说说yield方法)\n\n`yield()` 方法的目的是让当前线程让出 CPU 使用权，回到就绪状态。但是线程调度器可能会忽略。\n\n#### [说说interrupt方法？](#说说interrupt方法)\n\n`interrupt()` 方法用于通知线程停止，但不会直接终止线程，需要线程自行处理中断标志。\n\n常与 `isInterrupted()` 或 `Thread.interrupted()` 配合使用。\n\n\n```java\nThread thread = new Thread(() -> {\n while (!Thread.currentThread().isInterrupted()) {\n System.out.println(\"Running\");\n }\n System.out.println(\"Interrupted\");\n});\nthread.start();\nthread.interrupt(); // 中断线程\n```\n\n\n#### [说说 stop 方法？](#说说-stop-方法)\n\nstop 方法用来强制停止线程，目前已经处于废弃状态，因为 stop 方法可能会在不一致的状态下释放锁，破坏对象的一致性。\n\n"
+ },
+ {
+ "id": 92,
+ "question": "线程有几种状态？",
+ "answer": "6 种。\n\nnew 代表线程被创建但未启动；runnable 代表线程处于就绪或正在运行状态，由操作系统调度；blocked 代表线程被阻塞，等待获取锁；waiting 代表线程等待其他线程的通知或中断；timed\\_waiting 代表线程会等待一段时间，超时后自动恢复；terminated 代表线程执行完毕，生命周期结束。\n\n\n\n也就是说，线程的生命周期可以分为五个主要阶段：新建、就绪、运行、阻塞和终止。线程在运行过程中会根据状态的变化在这些阶段之间切换。\n\n\n```java\nclass ThreadStateExample {\n public static void main(String[] args) throws InterruptedException {\n Thread thread = new Thread(() -> {\n try {\n Thread.sleep(2000); // TIMED_WAITING\n synchronized (ThreadStateExample.class) {\n ThreadStateExample.class.wait(); // WAITING\n }\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n });\n\n System.out.println(\"State after creation: \" + thread.getState()); // NEW\n\n thread.start();\n System.out.println(\"State after start: \" + thread.getState()); // RUNNABLE\n\n Thread.sleep(500);\n System.out.println(\"State while sleeping: \" + thread.getState()); // TIMED_WAITING\n\n synchronized (ThreadStateExample.class) {\n ThreadStateExample.class.notify(); // 唤醒线程\n }\n\n thread.join();\n System.out.println(\"State after termination: \" + thread.getState()); // TERMINATED\n }\n}\n```\n\n\n用一个表格来做个总结：\n\n| 状态 | 说明 |\n| --- | --- |\n| NEW | 当线程被创建后，如通过`new Thread()`，它处于新建状态。此时，线程已经被分配了必要的资源，但还没有开始执行。 |\n| RUNNABLE | 当调用线程的`start()`方法后，线程进入可运行状态。在这个状态下，线程可能正在运行也可能正在等待获取 CPU 时间片，具体取决于线程调度器的调度策略。 |\n| BLOCKED | 线程在试图获取一个锁以进入同步块/方法时，如果锁被其他线程持有，线程将进入阻塞状态，直到它获取到锁。 |\n| WAITING | 线程进入等待状态是因为调用了如下方法之一：`Object.wait()`或`LockSupport.park()`。在等待状态下，线程需要其他线程显式地唤醒，否则不会自动执行。 |\n| TIME\\_WAITING | 当线程调用带有超时参数的方法时，如`Thread.sleep(long millis)`、`Object.wait(long timeout)` 或`LockSupport.parkNanos()`，它将进入超时等待状态。线程在指定的等待时间过后会自动返回可运行状态。 |\n| TERMINATED | 当线程的`run()`方法执行完毕后，或者因为一个未捕获的异常终止了执行，线程进入终止状态。一旦线程终止，它的生命周期结束，不能再被重新启动。 |\n\n#### [如何强制终止线程？](#如何强制终止线程)\n\n第一步，调用线程的 `interrupt()` 方法，请求终止线程。\n\n第二步，在线程的 `run()` 方法中检查中断状态，如果线程被中断，就退出线程。\n\n\n```java\nclass MyTask implements Runnable {\n @Override\n public void run() {\n while (!Thread.currentThread().isInterrupted()) {\n try {\n System.out.println(\"Running...\");\n Thread.sleep(1000); // 模拟工作\n } catch (InterruptedException e) {\n // 捕获中断异常后，重置中断状态\n Thread.currentThread().interrupt();\n System.out.println(\"Thread interrupted, exiting...\");\n break;\n }\n }\n }\n}\n\npublic class Main {\n public static void main(String[] args) throws InterruptedException {\n Thread thread = new Thread(new MyTask());\n thread.start();\n Thread.sleep(3000); // 主线程等待3秒\n thread.interrupt(); // 请求终止线程\n }\n}\n```\n\n\n中断结果：\n\n"
+ },
+ {
+ "id": 93,
+ "question": "什么是线程上下文切换？",
+ "answer": "线程上下文切换是指 CPU 从一个线程切换到另一个线程执行时的过程。\n\n在线程切换的过程中，CPU 需要保存当前线程的执行状态，并加载下一个线程的上下文。\n\n之所以要这样，是因为 CPU 在同一时刻只能执行一个线程，为了实现多线程并发执行，需要不断地在多个线程之间切换。\n\n\n\n为了让用户感觉多个线程是在同时执行的， CPU 资源的分配采用了时间片轮转的方式，线程在时间片内占用 CPU 执行任务。当线程使用完时间片后，就会让出 CPU 让其他线程占用。\n\n\n\n#### [线程可以被多核调度吗？](#线程可以被多核调度吗)\n\n多核处理器提供了并行执行多个线程的能力。每个核心可以独立执行一个或多个线程，操作系统的任务调度器会根据策略和算法，如优先级调度、轮转调度等，决定哪个线程何时在哪个核心上运行。"
+ },
+ {
+ "id": 94,
+ "question": "守护线程了解吗？",
+ "answer": "了解，守护线程是一种特殊的线程，它的作用是为其他线程提供服务。\n\nJava 中的线程分为两类，一种是守护线程，另外一种是用户线程。\n\nJVM 启动时会调用 main 方法，main 方法所在的线程就是一个用户线程。在 JVM 内部，同时还启动了很多守护线程，比如垃圾回收线程。\n\n#### [守护线程和用户线程有什么区别呢？](#守护线程和用户线程有什么区别呢)\n\n区别之一是当最后一个非守护线程束时， JVM 会正常退出，不管当前是否存在守护线程，也就是说守护线程是否结束并不影响 JVM 退出。\n\n换而言之，只要有一个用户线程还没结束，正常情况下 JVM 就不会退出。"
+ },
+ {
+ "id": 95,
+ "question": "线程间有哪些通信方式？",
+ "answer": "线程之间传递信息的方式有多种，比如说使用 volatile 和 synchronized 关键字共享对象、使用 `wait()` 和 `notify()` 方法实现生产者-消费者模式、使用 Exchanger 进行数据交换、使用 Condition 实现线程间的协调等。\n\n#### [简单说说 volatile 和 synchronized 的使用方式？](#简单说说-volatile-和-synchronized-的使用方式)\n\n多个线程可以通过 volatile 和 synchronized 关键字访问和修改同一个对象，从而实现信息的传递。\n\n可以用来修饰成员变量，告知程序任何对该变量的访问均需要从共享内存中获取，并同步刷新回共享内存，保证所有线程对变量访问的可见性。\n\n可以修饰方法，或者同步代码块，确保多个线程在同一个时刻只有一个线程在执行方法或代码块。\n\n\n```java\nclass SharedObject {\n private String message;\n private boolean hasMessage = false;\n\n public synchronized void writeMessage(String message) {\n while (hasMessage) {\n try {\n wait();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n this.message = message;\n hasMessage = true;\n notifyAll();\n }\n\n public synchronized String readMessage() {\n while (!hasMessage) {\n try {\n wait();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n hasMessage = false;\n notifyAll();\n return message;\n }\n}\n\npublic class Main {\n public static void main(String[] args) {\n SharedObject sharedObject = new SharedObject();\n\n Thread writer = new Thread(() -> {\n sharedObject.writeMessage(\"Hello from Writer!\");\n });\n\n Thread reader = new Thread(() -> {\n String message = sharedObject.readMessage();\n System.out.println(\"Reader received: \" + message);\n });\n\n writer.start();\n reader.start();\n }\n}\n```\n\n\n#### [wait() 和 notify() 方法的使用方式了解吗？](#wait-和-notify-方法的使用方式了解吗)\n\n一个线程调用共享对象的 `wait()` 方法时，它会进入该对象的等待池，释放已经持有的锁，进入等待状态。\n\n一个线程调用 `notify()` 方法时，它会唤醒在该对象等待池中等待的一个线程，使其进入锁池，等待获取锁。\n\n\n```java\nclass MessageBox {\n private String message;\n private boolean empty = true;\n\n public synchronized void produce(String message) {\n while (!empty) {\n try {\n wait();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n empty = false;\n this.message = message;\n notifyAll();\n }\n\n public synchronized String consume() {\n while (empty) {\n try {\n wait();\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n }\n empty = true;\n notifyAll();\n return message;\n }\n}\n\npublic class Main {\n public static void main(String[] args) {\n MessageBox box = new MessageBox();\n\n Thread producer = new Thread(() -> {\n box.produce(\"Message from producer\");\n });\n\n Thread consumer = new Thread(() -> {\n String message = box.consume();\n System.out.println(\"Consumer received: \" + message);\n });\n\n producer.start();\n consumer.start();\n }\n}\n```\n\n\n也提供了类似的方法，`await()` 负责阻塞、`signal()` 和 `signalAll()` 负责通知。\n\n通常与锁 一起使用，为线程提供了一种等待某个条件成真的机制，并允许其他线程在该条件变化时通知等待线程。\n\n#### [Exchanger 的使用方式了解吗？](#exchanger-的使用方式了解吗)\n\nExchanger 是一个同步点，可以在两个线程之间交换数据。一个线程调用 `exchange()` 方法，将数据传递给另一个线程，同时接收另一个线程的数据。\n\n\n```java\nclass Main {\n public static void main(String[] args) {\n Exchanger exchanger = new Exchanger<>();\n\n Thread thread1 = new Thread(() -> {\n try {\n String message = \"Message from thread1\";\n String response = exchanger.exchange(message);\n System.out.println(\"Thread1 received: \" + response);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n });\n\n Thread thread2 = new Thread(() -> {\n try {\n String message = \"Message from thread2\";\n String response = exchanger.exchange(message);\n System.out.println(\"Thread2 received: \" + response);\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n }\n });\n\n thread1.start();\n thread2.start();\n }\n}\n```\n\n\n#### [CompletableFuture 的使用方式了解吗？](#completablefuture-的使用方式了解吗)\n\nCompletableFuture 是 Java 8 引入的一个类，支持异步编程，允许线程在完成计算后将结果传递给其他线程。\n\n\n```java\nclass Main {\n public static void main(String[] args) {\n CompletableFuture future = CompletableFuture.supplyAsync(() -> {\n // 模拟长时间计算\n return \"Message from CompletableFuture\";\n });\n\n future.thenAccept(message -> {\n System.out.println(\"Received: \" + message);\n });\n }\n}\n```"
+ },
+ {
+ "id": 96,
+ "question": "请说说 sleep 和 wait 的区别？（补充）",
+ "answer": "> 2024 年 03 月 21 日增补\n\nsleep 会让当前线程休眠，不需要获取对象锁，属于 Thread 类的方法；wait 会让获得对象锁的线程等待，要提前获得对象锁，属于 Object 类的方法。\n\n详细解释下。\n\n①、所属类不同\n\n* `sleep()` 方法专属于 `Thread` 类。\n* `wait()` 方法专属于 `Object` 类。\n\n②、锁行为不同\n\n如果一个线程在持有某个对象锁时调用了 sleep 方法，它在睡眠期间仍然会持有这个锁。\n\n\n```java\nclass SleepDoesNotReleaseLock {\n\n private static final Object lock = new Object();\n\n public static void main(String[] args) throws InterruptedException {\n Thread sleepingThread = new Thread(() -> {\n synchronized (lock) {\n System.out.println(\"Thread 1 会继续持有锁，并且进入睡眠状态\");\n try {\n Thread.sleep(5000);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.println(\"Thread 1 醒来了，并且释放了锁\");\n }\n });\n\n Thread waitingThread = new Thread(() -> {\n synchronized (lock) {\n System.out.println(\"Thread 2 进入同步代码块\");\n }\n });\n\n sleepingThread.start();\n Thread.sleep(1000);\n waitingThread.start();\n }\n}\n```\n\n\n输出结果：\n\n\n```text\nThread 1 会继续持有锁，并且进入睡眠状态\nThread 1 醒来了，并且释放了锁\nThread 2 进入同步代码块\n```\n\n\n从输出中我们可以看到，waitingThread 必须等待 sleepingThread 完成睡眠后才能进入同步代码块。\n\n而当线程执行 wait 方法时，它会释放持有的对象锁，因此其他线程也有机会获取该对象的锁。\n\n\n```java\nclass WaitReleasesLock {\n\n private static final Object lock = new Object();\n\n public static void main(String[] args) throws InterruptedException {\n Thread waitingThread = new Thread(() -> {\n synchronized (lock) {\n try {\n System.out.println(\"Thread 1 持有锁，准备等待 5 秒\");\n lock.wait(5000);\n System.out.println(\"Thread 1 醒来了，并且退出同步代码块\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n });\n\n Thread notifyingThread = new Thread(() -> {\n synchronized (lock) {\n System.out.println(\"Thread 2 尝试唤醒等待中的线程\");\n lock.notify();\n System.out.println(\"Thread 2 执行完了 notify\");\n }\n });\n\n waitingThread.start();\n Thread.sleep(1000);\n notifyingThread.start();\n }\n}\n```\n\n\n输出结果：\n\n\n```text\nThread 1 持有锁，准备等待 5 秒\nThread 2 尝试唤醒等待中的线程\nThread 2 执行完了 notify\nThread 1 醒来了，并且退出同步代码块\n```\n\n\n这表明 waitingThread 在调用 wait 后确实释放了锁。\n\n③、使用条件不同\n\n* `sleep()` 方法可以在任何地方被调用。\n* `wait()` 方法必须在同步代码块或同步方法中被调用，这是因为调用 `wait()` 方法的前提是当前线程必须持有对象的锁。否则会抛出 `IllegalMonitorStateException` 异常。\n\n\n\n④、唤醒方式不同\n\n* 调用 sleep 方法后，线程会进入 TIMED\\_WAITING 状态，即在指定的时间内暂停执行。当指定的时间结束后，线程会自动恢复到 RUNNABLE 状态，等待 CPU 调度再次执行。\n* 调用 wait 方法后，线程会进入 WAITING 状态，直到有其他线程在同一对象上调用 notify 或 notifyAll 方法，线程才会从 WAITING 状态转变为 RUNNABLE 状态，准备再次获得 CPU 的执行权。\n\n我们来通过代码再感受一下 `sleep()` 和 `wait()` 在用法上的区别，先看 `sleep()` 的用法：\n\n\n```java\nclass SleepExample {\n public static void main(String[] args) {\n Thread thread = new Thread(() -> {\n System.out.println(\"线程准备休眠 2 秒\");\n try {\n Thread.sleep(2000); // 线程将睡眠2秒\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n System.out.println(\"线程醒来了\");\n });\n\n thread.start();\n }\n}\n```\n\n\n再来看 `wait()` 的用法：\n\n\n```java\nclass WaitExample {\n public static void main(String[] args) {\n final Object lock = new Object();\n\n Thread thread = new Thread(() -> {\n synchronized (lock) {\n try {\n System.out.println(\"线程准备等待 2 秒\");\n lock.wait(2000); // 线程会等待2秒，或者直到其他线程调用 lock.notify()/notifyAll()\n System.out.println(\"线程结束等待\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }\n });\n\n thread.start();\n }\n}\n```"
+ },
+ {
+ "id": 97,
+ "question": "怎么保证线程安全？（补充）",
+ "answer": "> 2024 年 05 月 01 日增补\n\n线程安全是指在并发环境下，多个线程访问共享资源时，程序能够正确地执行，而不会出现数据不一致的问题。\n\n为了保证线程安全，可以使用 对方法加锁，对代码块加锁。线程在执行同步方法、同步代码块时，会获取类锁或者对象锁，其他线程就会阻塞并等待锁。\n\n如果需要更细粒度的锁，可以使用 等。\n\n如果需要保证变量的内存可见性，可以使用 。\n\n对于简单的原子变量操作，还可以使用 。\n\n对于线程独立的数据，可以使用 来为每个线程提供专属的变量副本。\n\n对于需要并发容器的地方，可以使用 、 等。\n\n#### [有个int的变量为0，十个线程轮流对其进行++操作（循环10000次），结果大于10 万还是小于等于10万，为什么？](#有个int的变量为0-十个线程轮流对其进行-操作-循环10000次-结果大于10-万还是小于等于10万-为什么)\n\n在这个场景中，最终的结果会小于 100000，原因是多线程环境下，++ 操作并不是一个原子操作，而是分为读取、加 1、写回三个步骤。\n\n1. 读取变量的值。\n2. 将读取到的值加 1。\n3. 将结果写回变量。\n\n这样的话，就会有多个线程读取到相同的值，然后对这个值进行加 1 操作，最终导致结果小于 100000。\n\n详细解释下。\n\n多个线程在并发执行 ++ 操作时，可能出现以下竞态条件：\n\n* 线程 1 读取变量值为 0。\n* 线程 2 也读取变量值为 0。\n* 线程 1 进行加法运算并将结果 1 写回变量。\n* 线程 2 进行加法运算并将结果 1 写回变量，覆盖了线程 1 的结果。\n\n可以通过 synchronized 关键字为 ++ 操作加锁。\n\n\n```java\nclass Main {\n private static int count = 0;\n\n public static void main(String[] args) throws InterruptedException {\n Runnable task = () -> {\n for (int i = 0; i < 10000; i++) {\n synchronized (Main.class) {\n count++;\n }\n }\n };\n\n List threads = new ArrayList<>();\n for (int i = 0; i < 10; i++) {\n Thread thread = new Thread(task);\n threads.add(thread);\n thread.start();\n }\n\n for (Thread thread : threads) {\n thread.join();\n }\n\n System.out.println(\"Final count: \" + count);\n }\n}\n```\n\n\n或者使用 AtomicInteger 的 `incrementAndGet()` 方法来替代 ++ 操作，保证变量的原子性。\n\n\n```java\nclass Main {\n private static AtomicInteger count = new AtomicInteger(0);\n\n public static void main(String[] args) throws InterruptedException {\n Runnable task = () -> {\n for (int i = 0; i < 10000; i++) {\n count.incrementAndGet();\n }\n };\n\n List threads = new ArrayList<>();\n for (int i = 0; i < 10; i++) {\n Thread thread = new Thread(task);\n threads.add(thread);\n thread.start();\n }\n\n for (Thread thread : threads) {\n thread.join();\n }\n\n System.out.println(\"Final count: \" + count.get());\n }\n}\n```\n\n\n#### [场景:有一个 key 对应的 value 是一个json 结构，json 当中有好几个子任务，这些子任务如果对 key 进行修改的话，会不会存在线程安全的问题？](#场景-有一个-key-对应的-value-是一个json-结构-json-当中有好几个子任务-这些子任务如果对-key-进行修改的话-会不会存在线程安全的问题)\n\n会。\n\n在单节点环境中，可以使用 synchronized 关键字或 ReentrantLock 来保证对 key 的修改操作是原子的。\n\n\n```java\nclass KeyManager {\n private final ReentrantLock lock = new ReentrantLock();\n\n private String key = \"{\\\"tasks\\\": [\\\"task1\\\", \\\"task2\\\"]}\";\n\n public String readKey() {\n lock.lock();\n try {\n return key;\n } finally {\n lock.unlock();\n }\n }\n\n public void updateKey(String newKey) {\n lock.lock();\n try {\n this.key = newKey;\n } finally {\n lock.unlock();\n }\n }\n}\n```\n\n\n在多节点环境中，可以使用分布式锁 Redisson 来保证对 key 的修改操作是原子的。\n\n\n```java\nclass DistributedKeyManager {\n private final RedissonClient redisson;\n\n public DistributedKeyManager() {\n Config config = new Config();\n config.useSingleServer().setAddress(\"redis://127.0.0.1:6379\");\n this.redisson = Redisson.create(config);\n }\n\n public void updateKey(String key, String newValue) {\n RLock lock = redisson.getLock(key);\n lock.lock();\n try {\n // 模拟读取和更新操作\n String currentValue = readFromDatabase(key); // 假设读取 JSON 数据\n String updatedValue = modifyJson(currentValue, newValue); // 修改 JSON\n writeToDatabase(key, updatedValue); // 写回数据库\n } finally {\n lock.unlock();\n }\n }\n\n private String readFromDatabase(String key) {\n // 模拟从数据库读取\n return \"{\\\"tasks\\\": [\\\"task1\\\", \\\"task2\\\"]}\";\n }\n\n private String modifyJson(String json, String newValue) {\n // 使用 JSON 库解析并修改\n return json.replace(\"task1\", newValue);\n }\n\n private void writeToDatabase(String key, String value) {\n // 模拟写回数据库\n }\n}\n```\n\n\n#### [说一个线程安全的使用场景？](#说一个线程安全的使用场景)\n\n单例模式。在多线程环境下，如果多个线程同时尝试创建实例，单例类必须确保只创建一个实例，并提供一个全局访问点。\n\n饿汉式是一种比较直接的实现方式，它通过在类加载时就立即初始化单例对象来保证线程安全。\n\n\n```java\nclass Singleton {\n private static final Singleton instance = new Singleton();\n\n private Singleton() {\n }\n\n public static Singleton getInstance() {\n return instance;\n }\n}\n```\n\n\n懒汉式单例则在第一次使用时初始化单例对象，这种方式需要使用双重检查锁定来确保线程安全，volatile 关键字用来保证可见性，syncronized 关键字用来保证同步。\n\n\n```java\nclass LazySingleton {\n private static volatile LazySingleton instance;\n\n private LazySingleton() {}\n\n public static LazySingleton getInstance() {\n if (instance == null) { // 第一次检查\n synchronized (LazySingleton.class) {\n if (instance == null) { // 第二次检查\n instance = new LazySingleton();\n }\n }\n }\n return instance;\n }\n}\n```\n\n\n#### [能说一下 Hashtable 的底层数据结构吗？](#能说一下-hashtable-的底层数据结构吗)\n\n与 HashMap 类似，Hashtable 的底层数据结构也是一个数组加上链表的方式，然后通过 synchronized 加锁来保证线程安全。\n\n"
+ }
+ ]
+ },
+ {
+ "id": 20,
+ "categoryName": "ThreadLocal",
+ "questions": [
+ {
+ "id": 98,
+ "question": "ThreadLocal 是什么？",
+ "answer": "是一种用于实现线程局部变量的工具类。它允许每个线程都拥有自己的独立副本，从而实现线程隔离。\n\n\n\n使用 ThreadLocal 通常分为四步：\n\n①、创建 ThreadLocal\n\n\n```java\n//创建一个ThreadLocal变量\npublic static ThreadLocal localVariable = new ThreadLocal<>();\n```\n\n\n②、设置 ThreadLocal 的值\n\n\n```java\n//设置ThreadLocal变量的值\nlocalVariable.set(\"练习伴侣二是沙雕\");\n```\n\n\n③、获取 ThreadLocal 的值\n\n\n```java\n//获取ThreadLocal变量的值\nString value = localVariable.get();\n```\n\n\n④、删除 ThreadLocal 的值\n\n\n```java\n//删除ThreadLocal变量的值\nlocalVariable.remove();\n```\n\n\n在 Web 应用中，可以使用 ThreadLocal 存储用户会话信息，这样每个线程在处理用户请求时都能方便地访问当前用户的会话信息。\n\n在数据库操作中，可以使用 ThreadLocal 存储数据库连接对象，每个线程有自己独立的数据库连接，从而避免了多线程竞争同一数据库连接的问题。\n\n在格式化操作中，例如日期格式化，可以使用 ThreadLocal 存储 SimpleDateFormat 实例，避免多线程共享同一实例导致的线程安全问题。\n\n#### [ThreadLocal 有哪些优点？](#threadlocal-有哪些优点)\n\n每个线程访问的变量副本都是独立的，避免了共享变量引起的线程安全问题。由于 ThreadLocal 实现了变量的线程独占，使得变量不需要同步处理，因此能够避免资源竞争。\n\nThreadLocal 可用于跨方法、跨类时传递上下文数据，不需要在方法间传递参数。"
+ },
+ {
+ "id": 99,
+ "question": "你在工作中用到过 ThreadLocal 吗？",
+ "answer": "有用到过，用来存储用户信息。\n\n是典型的 MVC 架构，登录后的用户每次访问接口，都会在请求头中携带一个 token，在控制层可以根据这个 token，解析出用户的基本信息。\n\n假如在服务层和持久层也要用到用户信息，就可以在控制层拦截请求把用户信息存入 ThreadLocal。\n\n这样我们在任何一个地方，都可以取出 ThreadLocal 中存的用户信息。\n\n很多其它场景的 cookie、session 等等数据隔离都可以通过 ThreadLocal 去实现。\n\n"
+ },
+ {
+ "id": 100,
+ "question": "ThreadLocal 怎么实现的呢？",
+ "answer": "当我们创建一个 ThreadLocal 对象并调用 set 方法时，其实是在当前线程中初始化了一个 ThreadLocalMap。\n\n\n\nThreadLocalMap 是 ThreadLocal 的一个静态内部类，它内部维护了一个 Entry 数组，key 是 ThreadLocal 对象，value 是线程的局部变量，这样就相当于为每个线程维护了一个变量副本。\n\n\n\nEntry 继承了 WeakReference，它限定了 key 是一个弱引用，弱引用的好处是当内存不足时，JVM 会回收 ThreadLocal 对象，并且将其对应的 Entry.value 设置为 null，这样可以在很大程度上避免内存泄漏。\n\n\n```java\nstatic class Entry extends WeakReference> {\n /** The value associated with this ThreadLocal. */\n Object value;\n\n //节点类\n Entry(ThreadLocal k, Object v) {\n //key赋值\n super(k);\n //value赋值\n value = v;\n }\n}\n```\n\n\n总结一下：\n\nThreadLocal 的实现原理是，每个线程维护一个 Map，key 为 ThreadLocal 对象，value 为想要实现线程隔离的对象。\n\n1、通过 ThreadLocal 的 set 方法将对象存入 Map 中。\n\n2、通过 ThreadLocal 的 get 方法从 Map 中取出对象。\n\n3、Map 的大小由 ThreadLocal 对象的多少决定。\n\n\n\n#### [什么是弱引用，什么是强引用？](#什么是弱引用-什么是强引用)\n\n我先说一下强引用，比如 `User user = new User(\"练习伴侣二\")` 中，user 就是一个强引用，`new User(\"练习伴侣二\")` 就是强引用对象。\n\n当 user 被置为 null 时（`user = null`），`new User(\"练习伴侣二\")` 对象就会被垃圾回收；否则即便是内存空间不足，JVM 也不会回收 `new User(\"练习伴侣二\")` 这个强引用对象，宁愿抛出 OutOfMemoryError。\n\n弱引用，比如说在使用 ThreadLocal 中，Entry 的 key 就是一个弱引用对象。\n\n\n```java\nThreadLocal userThreadLocal = new ThreadLocal<>();\nuserThreadLocal.set(new User(\"练习伴侣二\"));\n```\n\n\nuserThreadLocal 是一个强引用，`new ThreadLocal<>()` 是一个强引用对象；\n\n`new User(\"练习伴侣二\")` 是一个强引用对象。\n\n调用 set 方法后，会将 `key = new ThreadLocal<>()` 放入 ThreadLocalMap 中，此时的 key 是一个弱引用对象。当 JVM 进行垃圾回收时，如果发现了弱引用对象，就会将其回收。\n\n\n\n其关系链就是：\n\n* ThreadLocal 强引用 -> ThreadLocal 对象。\n* Thread 强引用 -> ThreadLocalMap。\n* `ThreadLocalMap[i]` 强引用了 -> Entry。\n* Entry.key 弱引用 -> ThreadLocal 对象。\n* Entry.value 强引用 -> 线程的局部变量对象。"
+ },
+ {
+ "id": 101,
+ "question": "ThreadLocal 内存泄露是怎么回事？",
+ "answer": "ThreadLocalMap 的 Key 是 弱引用，但 Value 是强引用。\n\n如果一个线程一直在运行，并且 value 一直指向某个强引用对象，那么这个对象就不会被回收，从而导致内存泄漏。\n\n\n\n#### [那怎么解决内存泄漏问题呢？](#那怎么解决内存泄漏问题呢)\n\n很简单，使用完 ThreadLocal 后，及时调用 `remove()` 方法释放内存空间。\n\n\n```java\ntry {\n threadLocal.set(value);\n // 执行业务操作\n} finally {\n threadLocal.remove(); // 确保能够执行清理\n}\n```\n\n\n`remove()` 方法会将当前线程的 ThreadLocalMap 中的所有 key 为 null 的 Entry 全部清除，这样就能避免内存泄漏问题。\n\n\n```java\nprivate void remove(ThreadLocal key) {\n Entry[] tab = table;\n int len = tab.length;\n // 计算 key 的 hash 值\n int i = key.threadLocalHashCode & (len-1);\n // 遍历数组，找到 key 为 null 的 Entry\n for (Entry e = tab[i];\n e != null;\n e = tab[i = nextIndex(i, len)]) {\n if (e.get() == key) {\n // 将 key 为 null 的 Entry 清除\n e.clear();\n expungeStaleEntry(i);\n return;\n }\n }\n}\n\npublic void clear() {\n this.referent = null;\n}\n```\n\n\n#### [那为什么 key 要设计成弱引用？](#那为什么-key-要设计成弱引用)\n\n弱引用的好处是，当内存不足的时候，JVM 能够及时回收掉弱引用的对象。\n\n比如说：\n\n\n```java\nWeakReference key = new WeakReference(new ThreadLocal());\n```\n\n\nkey 是弱引用，`new WeakReference(new ThreadLocal())` 是弱引用对象，当 JVM 进行垃圾回收时，只要发现了弱引用对象，就会将其回收。\n\n一旦 key 被回收，ThreadLocalMap 在进行 set、get 的时候就会对 key 为 null 的 Entry 进行清理。\n\n\n\n总结一下，在 ThreadLocal 被垃圾收集后，下一次访问 ThreadLocalMap 时，Java 会自动清理那些键为 null 的 entry，这个过程会在执行 `get()`、`set()`、`remove()`时触发。\n\n\n\n#### [你了解哪些 ThreadLocal 的改进方案？](#你了解哪些-threadlocal-的改进方案)\n\n在 JDK 20 Early-Access Build 28 版本中，出现了 ThreadLocal 的改进方案，即 `ScopedValue`。\n\n还有 Netty 中的 FastThreadLocal，它是 Netty 对 ThreadLocal 的优化，内部维护了一个索引常量 index，每次创建 FastThreadLocal 中都会自动+1，用来取代 hash 冲突带来的损耗，用空间换时间。\n\n\n```java\nprivate final int index;\n\npublic FastThreadLocal() {\n index = InternalThreadLocalMap.nextVariableIndex();\n}\npublic static int nextVariableIndex() {\n int index = nextIndex.getAndIncrement();\n if (index < 0) {\n nextIndex.decrementAndGet();\n }\n return index;\n}\n```\n\n\n以及阿里的 TransmittableThreadLocal，不仅实现了子线程可以继承父线程 ThreadLocal 的功能，并且还可以跨线程池传递值。\n\n\n```java\nTransmittableThreadLocal context = new TransmittableThreadLocal<>();\n\n// 在父线程中设置\ncontext.set(\"value-set-in-parent\");\n\n// 在子线程中可以读取，值是\"value-set-in-parent\"\nString value = context.get();\n```"
+ },
+ {
+ "id": 102,
+ "question": "ThreadLocalMap 的源码看过吗？",
+ "answer": "有研究过。\n\nThreadLocalMap 虽然被叫做 Map，但它并没有实现 Map 接口，是一个简单的线性探测哈希表。\n\n\n```java\nstatic class ThreadLocalMap {\n static class Entry extends WeakReference> {\n Object value;\n\n Entry(ThreadLocal k, Object v) {\n super(k); // 这里的 Key 是 WeakReference\n value = v;\n }\n }\n\n private Entry[] table; // 存储 ThreadLocal 变量的数组\n private int size; // 当前 Entry 数量\n private int threshold; // 触发扩容的阈值\n}\n```\n\n\n底层的数据结构也是数组，数组中的每个元素是一个 Entry 对象，Entry 对象继承了 WeakReference，key 是 ThreadLocal 对象，value 是线程的局部变量。\n\n\n\n当调用 `ThreadLocal.set(value)` 时，会将 value 存入 ThreadLocalMap。\n\n\n```java\npublic void set(T value) {\n Thread t = Thread.currentThread();\n ThreadLocalMap map = getMap(t);\n if (map != null) {\n map.set(this, value);\n } else {\n createMap(t, value);\n }\n}\n```\n\n\n`set()` 方法是 ThreadLocalMap 的核心方法，通过 key 的哈希码与数组长度取模，计算出 key 在数组中的位置，这一点和 HashMap 的实现类似。\n\n\n```java\nprivate void set(ThreadLocal key, Object value) {\n Entry[] tab = table;\n int len = tab.length;\n int i = key.threadLocalHashCode & (len - 1); // 计算索引\n\n for (Entry e = tab[i]; e != null; e = tab[nextIndex(i, len)]) {\n ThreadLocal k = e.get();\n if (k == key) { // 如果 key 已存在，更新 value\n e.value = value;\n return;\n }\n if (k == null) { // Key 为 null，清理无效 Entry\n replaceStaleEntry(key, value, i);\n return;\n }\n }\n \n tab[i] = new Entry(key, value); // 直接插入 Entry\n size++;\n if (size >= threshold) {\n rehash();\n }\n}\n```\n\n\nthreadLocalHashCode 的计算有点东西，每创建一个 ThreadLocal 对象，它就会新增一个**黄金分割数**，可以让哈希码**分布的非常均匀**。\n\n\n```java\nprivate static final int HASH_INCREMENT = 0x61c88647;\n\nprivate static int nextHashCode() {\n return nextHashCode.getAndAdd(HASH_INCREMENT);\n}\n```\n\n\n当调用 `ThreadLocal.get()` 时，会调用 ThreadLocalMap 的 `getEntry()` 方法，根据 key 的哈希码找到对应的线程局部变量。\n\n\n```java\nprivate Entry getEntry(ThreadLocal key) {\n int i = key.threadLocalHashCode & (table.length - 1);\n Entry e = table[i];\n\n if (e != null && e.get() == key) { // 如果 key 存在，直接返回\n return e;\n } else {\n return getEntryAfterMiss(key, i, e); // 继续查找\n }\n}\n```\n\n\n当调用 `ThreadLocal.remove()` 时，会调用 ThreadLocalMap 的 `remove()` 方法，根据 key 的哈希码找到对应的线程局部变量，将其清除，防止内存泄漏。\n\n\n```java\nprivate void remove(ThreadLocal key) {\n Entry[] tab = table;\n int len = tab.length;\n int i = key.threadLocalHashCode & (len - 1);\n \n for (Entry e = tab[i]; e != null; e = tab[nextIndex(i, len)]) {\n if (e.get() == key) {\n e.clear(); // 清除 WeakReference\n e.value = null; // 释放 Value\n expungeStaleEntries();\n return;\n }\n }\n}\n```"
+ },
+ {
+ "id": 103,
+ "question": "ThreadLocalMap 怎么解决 Hash 冲突的？",
+ "answer": "**开放定址法**。\n\n如果计算得到的槽位 i 已经被占用，ThreadLocalMap 会采用开放地址法中的线性探测来寻找下一个空闲槽位：\n\n如果 i 位置被占用，尝试 i+1。\n\n如果 i+1 也被占用，继续探测 i+2，直到找到一个空位。\n\n如果到达数组末尾，则回到数组头部，继续寻找空位。\n\n\n```java\nprivate static int nextIndex(int i, int len) {\n return ((i + 1 < len) ? i + 1 : 0);\n}\n```\n\n\n#### [为什么要用线性探测法而不是HashMap 的拉链法来解决哈希冲突？](#为什么要用线性探测法而不是hashmap-的拉链法来解决哈希冲突)\n\nThreadLocalMap 设计的目的是存储线程私有数据，不会有大量的 Key，所以采用线性探测更节省空间。\n\n拉链法还需要单独维护一个链表，甚至红黑树，不适合 ThreadLocal 这种场景。\n\n#### [开放地址法了解吗？](#开放地址法了解吗)\n\n简单来说，就是这个坑被人占了，那就接着去找空着的坑。\n\n\n\n如果我们插入一个 value=27 的数据，通过 hash 计算后应该落入第 4 个槽位，而槽位 4 已经有数据了，而且 key 和当前的不等。\n\n此时就会线性向后查找，一直找到 Entry 为 null 的槽位才会停止。"
+ },
+ {
+ "id": 104,
+ "question": "ThreadLocalMap 扩容机制了解吗？",
+ "answer": "了解。\n\n与 HashMap 不同，ThreadLocalMap 并不会直接在元素数量达到阈值时立即扩容，而是先清理被 GC 回收的 key，然后在填充率达到四分之三时进行扩容。\n\n\n```java\nprivate void rehash() {\n // 清理被 GC 回收的 key\n expungeStaleEntries();\n\n //扩容\n if (size >= threshold - threshold / 4)\n resize();\n}\n```\n\n\n清理过程会遍历整个数组，将 key 为 null 的 Entry 清除。\n\n\n```java\nprivate void expungeStaleEntries() {\n Entry[] tab = table;\n int len = tab.length;\n for (int j = 0; j < len; j++) {\n Entry e = tab[j];\n // 如果 key 为 null，清理 Entry\n if (e != null && e.get() == null)\n expungeStaleEntry(j);\n }\n}\n```\n\n\n阈值 threshold 的默认值是数组长度的三分之二。\n\n\n```java\nprivate void setThreshold(int len) {\n threshold = len * 2 / 3;\n}\n```\n\n\n扩容时，会将数组长度翻倍，然后重新计算每个 Entry 的位置，采用线性探测法来寻找新的空位，然后将 Entry 放入新的数组中。\n\n\n```java\nprivate void resize() {\n Entry[] oldTab = table;\n int oldLen = oldTab.length;\n // 扩容为原来的两倍\n int newLen = oldLen * 2;\n Entry[] newTab = new Entry[newLen];\n \n int count = 0;\n // 遍历老数组\n for (int j = 0; j < oldLen; ++j) {\n Entry e = oldTab[j];\n if (e != null) {\n ThreadLocal k = e.get();\n if (k == null) {\n e.value = null; // 释放 Value，防止内存泄漏\n } else {\n // 重新计算位置\n int h = k.threadLocalHashCode & (newLen - 1);\n while (newTab[h] != null) {\n // 线性探测寻找新位置\n h = nextIndex(h, newLen);\n }\n // 放入新数组\n newTab[h] = e;\n count++;\n }\n }\n }\n table = newTab;\n size = count;\n threshold = newLen * 2 / 3; // 重新计算扩容阈值\n}\n```\n\n\n一句话总结：ThreadLocalMap 采用的是“先清理再扩容”的策略，扩容时，数组长度翻倍，并重新计算索引，如果发生哈希冲突，采用线性探测法来解决。\n\n"
+ },
+ {
+ "id": 105,
+ "question": "父线程能用 ThreadLocal 给子线程传值吗？",
+ "answer": "不能。\n\n\n\n因为 ThreadLocal 变量存储在每个线程的 ThreadLocalMap 中，而子线程不会继承父线程的 ThreadLocalMap。\n\n可以使用 `InheritableThreadLocal`来解决这个问题。\n\n\n\n子线程在创建的时候会拷贝父线程的 InheritableThreadLocal 变量。\n\n\n\n来看一下使用示例：\n\n\n```java\nclass InheritableThreadLocalExample {\n private static final InheritableThreadLocal inheritableThreadLocal = new InheritableThreadLocal<>();\n\n public static void main(String[] args) {\n inheritableThreadLocal.set(\"父线程的值\");\n\n new Thread(() -> {\n System.out.println(\"子线程获取的值：\" + inheritableThreadLocal.get()); // 继承了父线程的值\n }).start();\n }\n}\n```\n\n\n#### [InheritableThreadLocal的原理了解吗？](#inheritablethreadlocal的原理了解吗)\n\n了解。\n\n在 Thread 类的定义中，每个线程都有两个 ThreadLocalMap：\n\n\n```java\npublic class Thread {\n /* 普通 ThreadLocal 变量存储的地方 */\n ThreadLocal.ThreadLocalMap threadLocals = null;\n\n /* InheritableThreadLocal 变量存储的地方 */\n ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;\n}\n```\n\n\n普通 ThreadLocal 变量存储在 threadLocals 中，不会被子线程继承。\n\nInheritableThreadLocal 变量存储在 inheritableThreadLocals 中，当 `new Thread()` 创建一个子线程时，Thread 的 `init()` 方法会检查父线程是否有 inheritableThreadLocals，如果有，就会拷贝 InheritableThreadLocal 变量到子线程：\n\n\n```java\nprivate void init(ThreadGroup g, Runnable target, String name, long stackSize) {\n // 获取当前父线程\n Thread parent = currentThread();\n // 复制 InheritableThreadLocal 变量\n if (parent.inheritableThreadLocals != null) {\n this.inheritableThreadLocals = \n ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);\n }\n}\n```"
+ }
+ ]
+ },
+ {
+ "id": 21,
+ "categoryName": "Java 内存模型",
+ "questions": [
+ {
+ "id": 106,
+ "question": "说一下你对 Java 内存模型的理解？",
+ "answer": "Java 内存模型是 Java 虚拟机规范中定义的一个抽象模型，用来描述多线程环境中共享变量的内存可见性。\n\n\n\n共享变量存储在`主内存`中，每个线程都有一个私有的`本地内存`，存储了共享变量的副本。\n\n* 当一个线程更改了本地内存中共享变量的副本，它需要 JVM 刷新到主内存中，以确保其他线程可以看到这些更改。\n* 当一个线程需要读取共享变量时，它一版会从本地内存中读取。如果本地内存中的副本是过时的，JVM 会将主内存中的共享变量最新值刷新到本地内存中。\n\n\n\n#### [为什么线程要用自己的内存？](#为什么线程要用自己的内存)\n\n线程从主内存拷贝变量到工作内存，可以减少 CPU 访问 RAM 的开销。\n\n每个线程都有自己的变量副本，可以避免多个线程同时修改共享变量导致的数据冲突。"
+ },
+ {
+ "id": 107,
+ "question": "i++是原子操作吗？",
+ "answer": "不是，它包括三个步骤：\n\n1. 从内存中读取 i 的值。\n2. 对 i 进行加 1 操作。\n3. 将新的值写回内存。\n\n#### [说说你对原子性、可见性、有序性的理解？](#说说你对原子性、可见性、有序性的理解)\n\n**原子性**要求一个操作是不可分割的，要么全部执行成功，要么完全不执行。\n\n举个例子：就比如说 `count++` 就不是一个原子操作，它包括读取 count 的值、加 1、写回 count 三个步骤，所以需要加锁或者使用`AtomicInteger`代替 int 来保证原子性。\n\n**可见性**要求一个线程对共享变量的修改，能够被其他线程及时看见。\n\n我通过下面的代码解释一下：\n\n\n```java\nprivate static boolean flag = true;\n\npublic static void main(String[] args) {\n new Thread(() -> {\n while (flag) {} // 线程 A 可能一直看不到 flag=false\n System.out.println(\"线程 A 退出\");\n }).start();\n\n try { Thread.sleep(1000); } catch (InterruptedException e) {}\n\n flag = false; // 线程 B 修改 flag\n}\n```\n\n\n线程 A 会在本地内存中缓存 `flag=true`，虽然线程 B 修改了 `flag=false`，但不会立即同步到主内存以及线程 A 的本地内存，因此线程 A 会一直处于死循环。\n\n解决办法就是通过 volatile 关键字来保证可见性。\n\n**有序性**是指程序执行的顺序是否按照代码编写的顺序执行。\n\n在单线程环境下，代码能够准确无误地按照编写顺序执行。但在多线程环境下，CPU 和编译器可能会进行指令重排，代码的执行顺序因此会发生变化。\n\n我通过下面的代码解释一下：\n\n\n```java\nint a = 0, b = 0;\nboolean flag = false;\n\nvoid thread1() {\n a = 1; \n flag = true; // 可能会被 CPU 优化，先执行\n}\n\nvoid thread2() {\n if (flag) {\n System.out.println(a); // 可能打印 0，而不是 1\n }\n}\n```\n\n\n由于指令重排，`flag = true` 可能会在 `a = 1` 之前执行，导致 `thread2()` 读取 `flag=true` 后，a 仍然是 0，出现不符合代码逻辑的情况。\n\n简要回答：\n\n原子性保证操作不可中断，可见性保证变量修改后线程能看到最新值，有序性保证代码执行顺序一致，可以通过 volatile、synchronized 和 CAS 机制来保证这些特性。\n\n#### [下面的代码是原子操作吗？](#下面的代码是原子操作吗)\n\n\n```java\nint i = 2;\nint j = i;\ni++;\ni = i + 1;\n```\n\n\n* 第 1 行代码是基本类型赋值，是原子性操作。\n* 第 2 行先读 i 的值，再赋值给 j，不是原子操作。\n* 第 3 和第 4 行都不是原子操作，都需要先读取 i 的值，再+1，然后再赋值给 i。"
+ },
+ {
+ "id": 108,
+ "question": "说说什么是指令重排？",
+ "answer": "指令重排是指 CPU 或编译器为了提高程序的执行效率，改变代码执行顺序的一种优化技术。\n\n从 Java 源代码到最终执行的指令序列，会经历 3 种重排序：编译器重排序、指令并行重排序、内存系统重排序。\n\n\n\n指令重排可能会导致双重检查锁失效，比如下面的单例模式代码：\n\n\n```java\npublic class Singleton {\n private static Singleton instance;\n\n public static Singleton getInstance() {\n if (instance == null) { // 第一次检查\n synchronized (Singleton.class) {\n if (instance == null) { // 第二次检查\n instance = new Singleton(); // 可能发生指令重排\n }\n }\n }\n return instance;\n }\n}\n```\n\n\n如果线程 A 执行了 `instance = new Singleton();`，但构造方法还没执行完，线程 B 可能会读取到一个未初始化的对象，导致出现空指针异常。\n\n\n\n正确的方式是给 instance 变量加上 `volatile` 关键字，禁止指令重排。\n\n\n```java\nclass Singleton {\n private static volatile Singleton instance;\n\n public static Singleton getInstance() {\n if (instance == null) {\n synchronized (Singleton.class) {\n if (instance == null) {\n instance = new Singleton(); // 由于 volatile，禁止指令重排\n }\n }\n }\n return instance;\n }\n}\n```"
+ },
+ {
+ "id": 109,
+ "question": "happens-before 了解吗？",
+ "answer": "Happens-Before 是 Java 内存模型定义的一种保证线程间可见性和有序性的规则。\n\n如果操作 A Happens-Before 操作 B，那么：\n\n1. 操作 A 的结果对操作 B 可见。\n2. 操作 A 在时间上先于操作 B 执行。\n\n换句话说，如果 A Happens-Before B，那么 A 的修改必须对 B 可见，并且 B 不能重排序到 A 之前。\n\n#### [你知道哪些 Happens-Before 规则？](#你知道哪些-happens-before-规则)\n\n\n\nJMM 规定了 6 种 Happens-Before 规则，满足这些规则的操作不会被重排序，并且保证了数据的可见性。\n\n①、程序顺序规则：单线程内，代码按顺序执行；比如 `a = 1; b = 2;`，a 先于 b 执行。\n\n②、监视器锁定规则：`unlock() Happens-Before lock()`；比如 synchronized 释放锁后，获取锁的线程能够看到最新的数据。\n\n③、volatile 变量规则：写 volatile 变量 Happens-Before 读 volatile。\n\n④、传递性规则：A Happens-Before B 且 B Happens-Before C，则 A Happens-Before C。例如 a = 1 先于 b = 2，b = 2 先于 c = 3，则 a = 1 先于 c = 3。\n\n⑤、线程启动规则：线程 A 执行操作 `ThreadB.start()`，那么 A 线程的 `ThreadB.start()` 操作 happens-before 于线程 B 中的任意操作。\n\n⑥、线程终止规则：线程的所有操作 Happens-Before `Thread.join()`；例如 `t.join();` 之后，主线程一定能看到 t 的修改。"
+ },
+ {
+ "id": 110,
+ "question": "as-if-serial 了解吗？",
+ "answer": "As-If-Serial 规则允许 CPU 和编译器优化代码顺序，但不会改变单线程的执行结果。它只适用于单线程，多线程环境仍然可能发生指令重排，需要 volatile 和 synchronized 等机制来保证有序性。\n\n来解释说明一下。\n\n\n```java\ndouble pi = 3.14; // A\ndouble r = 1.0; // B\ndouble area = pi * r * r; // C\n```\n\n\nC 依赖于 A，同时 C 也依赖着 B。\n\n\n\n因此在最终执行的指令序列中，C 不能被重排序到 A 或者 B 的前面，否则就会出现错误。\n\n但 A 和 B 之间没有依赖关系，因此编译器和处理器可以重排序 A 和 B 之间的执行顺序。\n\n所以程序可能会有两种执行顺序：\n\n\n\nHappens-Before 规则保证了多线程环境下的有序性，防止指令重排导致的并发问题。As-If-Serial 规则保证了单线程代码不会因优化而执行错误。"
+ },
+ {
+ "id": 111,
+ "question": "volatile 了解吗？",
+ "answer": "了解。\n\n第一，保证可见性，线程修改 volatile 变量后，其他线程能够立即看到最新值；第二，防止指令重排，volatile 变量的写入不会被重排序到它之前的代码。\n\n#### [volatile 怎么保证可见性的？](#volatile-怎么保证可见性的)\n\n当线程对 volatile 变量进行写操作时，JVM 会在这个变量写入之后插入一个写屏障指令，这个指令会强制将本地内存中的变量值刷新到主内存中。\n\n\n```java\nStoreStore; // 保证写入之前的操作不会重排\nvolatile_write(); // 写入 volatile 变量\nStoreLoad; // 保证写入后，其他线程立即可见\n```\n\n\n在 x86 架构下，通常会使用 `lock` 指令来实现写屏障，例如：\n\n\n```text\nmov [a], 2 ; 将值 2 写入内存地址 a\nlock add [a], 0 ; lock 指令充当写屏障，确保内存可见性\n```\n\n\n当线程对 volatile 变量进行读操作时，JVM 会插入一个读屏障指令，这个指令会强制让本地内存中的变量值失效，从而重新从主内存中读取最新的值。\n\n\n\n我们来声明一个 volatile 变量 x：\n\n\n```java\nvolatile int x = 0\n```\n\n\n线程 A 对 x 写入后会将其最新的值刷新到主内存中，线程 B 读取 x 时由于本地内存中的 x 失效了，就会从主内存中读取最新的值。\n\n\n\n#### [volatile 怎么保证有序性的？](#volatile-怎么保证有序性的)\n\nJVM 会在 volatile 变量的读写前后插入 “内存屏障”，以约束 CPU 和编译器的优化行为：\n\n* StoreStore 屏障可以禁止普通写操作与 volatile 写操作的重排\n* StoreLoad 屏障会禁止 volatile 写与 volatile 读重排\n* LoadLoad 屏障会禁止 volatile 读与后续普通读操作重排\n* LoadStore 屏障会禁止 volatile 读与后续普通写操作重排\n\n#### [volatile 和 synchronized 的区别？](#volatile-和-synchronized-的区别)\n\nvolatile 关键字用于修饰变量，确保该变量的更新操作对所有线程是可见的，即一旦某个线程修改了 volatile 变量，其他线程会立即看到最新的值。\n\nsynchronized 关键字用于修饰方法或代码块，确保同一时刻只有一个线程能够执行该方法或代码块，从而实现互斥访问。\n\n#### [volatile 加在基本类型和对象上的区别？](#volatile-加在基本类型和对象上的区别)\n\n当 `volatile` 用于基本数据类型时，能确保该变量的读写操作是直接从主内存中读取或写入的。\n\n\n```java\nprivate volatile int count = 0;\n```\n\n\n当 `volatile` 用于引用类型时，能确保引用本身的可见性，即确保引用指向的对象地址是最新的。\n\n但是，`volatile` 并不能保证引用对象内部状态的线程安全。\n\n\n```java\nprivate volatile SomeObject obj = new SomeObject();\n```\n\n\n虽然 `volatile` 确保了 `obj` 引用的可见性，但对 `obj` 引用的 `new SomeObject()` 对象并不受 `volatile` 保护。\n\n如果需要保证引用对象内部状态的线程安全，需要使用 `synchronized` 或 `ReentrantLock` 等锁机制。"
+ }
+ ]
+ },
+ {
+ "id": 22,
+ "categoryName": "锁",
+ "questions": [
+ {
+ "id": 112,
+ "question": "synchronized 用过吗？",
+ "answer": "用过，频率还很高。\n\nsynchronized 在 JDK 1.6 之后，进行了锁优化，增加了偏向锁、轻量级锁，大大提升了 synchronized 的性能。\n\n#### [synchronized 上锁的对象是什么？](#synchronized-上锁的对象是什么)\n\nsynchronized 用在普通方法上时，上锁的是执行这个方法的对象。\n\n\n```java\npublic synchronized void increment() {\n this.count++;\n}\n```\n\n\nsynchronized 用在静态方法上时，上锁的是这个类的 Class 对象。\n\n\n```java\npublic static synchronized void increment() {\n count++;\n}\n```\n\n\nsynchronized 用在代码块上时，上锁的是括号中指定的对象，比如说当前对象 this。\n\n\n```java\npublic void increment() {\n synchronized (this) {\n this.count++;\n }\n}\n```"
+ },
+ {
+ "id": 113,
+ "question": "synchronized 的实现原理了解吗？",
+ "answer": "synchronized 依赖 JVM 内部的 Monitor 对象来实现线程同步。使用的时候不用手动去 lock 和 unlock，JVM 会自动加锁和解锁。\n\nsynchronized 加锁代码块时，JVM 会通过 `monitorenter`、`monitorexit` 两个指令来实现同步：\n\n* 前者表示线程正在尝试获取 lock 对象的 Monitor；\n* 后者表示线程执行完了同步代码块，正在释放锁。\n\n使用 `javap -c -s -v -l SynchronizedDemo.class` 反编译 synchronized 代码块时，就能看到这两个指令。\n\n\n\nsynchronized 修饰普通方法时，JVM 会通过 `ACC_SYNCHRONIZED` 标记符来实现同步。\n\n\n\n#### [你对 Monitor 了解多少？](#你对-monitor-了解多少)\n\nMonitor 是 JVM 内置的同步机制，每个对象在内存中都有一个对象头——Mark Word，用于存储锁的状态，以及 Monitor 对象的指针。\n\n\n\nsynchronized 依赖对象头的 Mark Word 进行状态管理，支持无锁、偏向锁、轻量级锁，以及重量级锁。\n\n在 Hotspot 虚拟机中，Monitor 由 ObjectMonitor 实现：\n\n\n```java\nObjectMonitor() {\n _count = 0; // 记录线程获取锁的次数\n _owner = NULL; // 指向持有ObjectMonitor对象的线程\n _WaitSet = NULL; // 处于wait状态的线程，会被加入到_WaitSet\n _cxq = NULL ;\n _EntryList = NULL ; // 处于等待锁block状态的线程，会被加入到该列表\n }\n```\n\n\n* \\_owner：当前持有 ObjectMonitor 的线程，初始值为 null，表示没有线程持有锁。线程成功获取锁后，该值更新为线程 ID，释放锁后重置为 null。\n* \\_count：记录当前线程获取锁的次数（可重入锁），每次成功加锁 `_count + 1`，释放锁 `_count - 1`。\n* \\_WaitSet：等待队列，调用 `wait()` 方法后，线程会释放锁，并加入 \\_WaitSet，进入 WAITING 状态，等待 `notify()` 唤醒。\n* \\_cxq：阻塞队列，用于存放刚进入 Monitor 的线程（还未进入 \\_EntryList）。\n* \\_EntryList：竞争队列，所有等待获取锁的线程（BLOCKED 状态）会进入 \\_EntryList，等待锁释放后竞争执行权。\n\n结构示意图：\n\n\n```text\n+----------------------+\n| ObjectMonitor |\n| ---------------- |\n| _owner = Thread-1 | // 当前持有锁的线程\n| _count = 1 | // 线程获取锁的次数\n| _WaitSet -> T3,T4 | // 执行 wait() 的线程\n| _EntryList -> T2,T5| // 竞争锁的线程\n| _cxq -> T6,T7 | // 新进入的线程\n+----------------------+\n```\n\n\n#### [会不会牵扯到 os 层面呢？](#会不会牵扯到-os-层面呢)\n\n会，synchronized 升级为重量级锁时，依赖于操作系统的互斥量——mutex 来实现，mutex 用于保证任何给定时间内，只有一个线程可以执行某一段特定的代码段。"
+ },
+ {
+ "id": 114,
+ "question": "synchronized 怎么保证可见性？",
+ "answer": "通过两步操作：\n\n* 加锁时，线程必须从主内存读取最新数据。\n* 释放锁时，线程必须将修改的数据刷回主内存，这样其他线程获取锁后，就能看到最新的数据。\n\n\n```text\n线程 A 线程 B\n ┌────────────────────┐\n │ synchronized(lock) │\n │ x = 1; │ // 1. 线程 A 修改变量 x\n └────────────────────┘\n ↓ 释放锁\n （JVM 强制刷新 x 到主内存）\n\n （线程 B 获取锁）\n ┌────────────────────┐\n │ synchronized(lock) │\n │ print(x); │ // 2. 线程 B 读取最新 x=1\n └────────────────────┘\n```\n\n\n#### [synchronized 怎么保证有序性？](#synchronized-怎么保证有序性)\n\nsynchronized 通过 JVM 指令 monitorenter 和 monitorexit，来确保加锁代码块内的指令不会被重排。\n\n来解释一下，比如说对于：\n\n\n```java\nsynchronized (lock) {\n x = 1;\n flag = true;\n}\n```\n\n\njavap 反编译后的伪代码：\n\n\n```java\nmonitorenter // 获取锁\nstore x, 1 // 变量 x = 1\nstore flag, true // 变量 flag = true\nmonitorexit // 释放锁\n```\n\n\n实际 javap 反编译后的结果：\n\n\n\n指令解释一下：\n\n| 指令 | 作用 |\n| --- | --- |\n| monitorenter | 获取锁，进入同步代码块 |\n| iconst\\_1 | 将整数 1 压入操作数栈 |\n| istore\\_1 | 存储 1 到局部变量 x |\n| iconst\\_1 | 再次将整数 1 压入操作数栈 |\n| istore\\_2 | 存储 1 到局部变量 flag |\n| aload 4 | 加载 lock 对象引用 |\n| monitorexit | 释放锁，退出同步代码块 |\n\n#### [synchronized 怎么实现可重入的呢？](#synchronized-怎么实现可重入的呢)\n\n可重入意味着同一个线程可以多次获得同一个锁，而不会被阻塞。\n\n\n\nsynchronized 之所以支持可重入，是因为 Java 的对象头包含了一个 Mark Word，用于存储对象的状态，包括锁信息。\n\n当一个线程获取对象锁时，JVM 会将该线程的 ID 写入 Mark Word，并将锁计数器设为 1。\n\n如果一个线程尝试再次获取已经持有的锁，JVM 会检查 Mark Word 中的线程 ID。如果 ID 匹配，表示的是同一个线程，锁计数器递增。\n\n当线程退出同步块时，锁计数器递减。如果计数器值为零，JVM 将锁标记为未持有状态，并清除线程 ID 信息。\n\n来解释一下：\n\n\n```java\nclass ReentrantExample {\n public synchronized void method1() {\n System.out.println(\"Method1 acquired lock\");\n method2(); // 线程已经持有锁，能继续调用 method2\n }\n\n public synchronized void method2() {\n System.out.println(\"Method2 acquired lock\");\n }\n\n public static void main(String[] args) {\n ReentrantExample example = new ReentrantExample();\n example.method1();\n }\n}\n```\n\n\n执行结果：\n\n\n```text\nMethod1 acquired lock\nMethod2 acquired lock\n```\n\n\n因为 synchronized 支持可重入，所以 method1 获取锁后，method2 仍然可以获取锁。\n\n底层是通过 Monitor 对象的 owner 和 count 字段实现的，owner 记录持有锁的线程，count 记录线程获取锁的次数。\n\n\n```text\n+----------------------+\n| ObjectMonitor |\n| ---------------- |\n| _owner = Thread-1 | // 当前持有锁的线程\n| _count = 2 | // 线程重入了 2 次\n+----------------------+\n```"
+ },
+ {
+ "id": 115,
+ "question": "synchronized 锁升级了解吗？",
+ "answer": "JDK 1.6 的时候，为了提升 synchronized 的性能，引入了锁升级机制，从低开销的锁逐步升级到高开销的锁，以最大程度减少锁的竞争。\n\n\n\n没有线程竞争时，就使用低开销的“偏向锁”，此时没有额外的 CAS 操作；轻度竞争时，使用“轻量级锁”，采用 CAS 自旋，避免线程阻塞；只有在重度竞争时，才使用“重量级锁”，由 Monitor 机制实现，需要线程阻塞。\n\n#### [了解 synchronized 四种锁状态吗？](#了解-synchronized-四种锁状态吗)\n\n了解。\n\n①、无锁状态，对象未被锁定，Mark Word 存储对象的哈希码等信息。\n\n②、偏向锁，当线程第一次获取锁时，会进入偏向模式。Mark Word 会记录线程 ID，后续同一线程再次获取锁时，可以直接进入 synchronized 加锁的代码，无需额外加锁。\n\n\n\n③、轻量级锁，当多个线程在不同时段获取同一把锁，即不存在锁竞争的情况时，JVM 会采用轻量级锁来避免线程阻塞。\n\n未持有锁的线程通过等待锁释放。\n\n\n\n当线程进入 synchronized 加锁的代码时，如果对象的锁状态为偏向锁，也就是锁类型为“01”，偏向锁标记为“0”的状态。\n\n\n\n然后采用 CAS 自旋的方式，尝试将对象头中的 Mark Word 替换为指向 Lock Record 的指针，并将 Lock Record 中的 owner 指针指向对象的 Mark Word。\n\n\n\n如果这个替换动作成功了，线程就拥有了该对象的锁，对象头 Mark Word 的锁标志位会更新为“00”，表示对象处于轻量级锁状态。\n\n④、重量级锁，如果自旋超过一定的次数，或者一个线程持有锁，一个自旋，又有第三个线程进入 synchronized 加锁的代码时，轻量级锁就会升级为重量级锁。\n\n此时，对象头的锁类型会更新为“10”，Mark Word 会存储指向 Monitor 对象的指针，其他等待锁的线程都会进入阻塞状态。\n\n#### [synchronized 做了哪些优化？](#synchronized-做了哪些优化)\n\n在 JDK 1.6 之前，synchronized 是直接调用 ObjectMonitor 的 enter 和 exit 指令实现的，这种锁也被称为**重量级锁**，性能较差。\n\n随着 JDK 版本的更新，synchronized 的性能得到了极大的优化：\n\n**①、偏向锁**：同一个线程可以多次获取同一把锁，无需重复加锁。\n\n**②、轻量级锁**：当没有线程竞争时，通过 CAS 自旋等待锁，避免直接进入阻塞。\n\n**③、锁消除**： 可以在运行时进行代码分析，如果发现某些锁操作不可能被多个线程同时访问，就会对这些锁进行消除，从而减少上锁开销。\n\n#### [请详细说说锁升级的过程？](#请详细说说锁升级的过程)\n\n懵逼状态下的回答：锁升级会从无锁升级为偏向锁，再升级为轻量级锁，最后升级为重量级锁。\n\n\n\n知道一点，但不深入的回答：\n\n\n\n①、偏向锁：当一个线程第一次获取锁时，JVM 会在对象头的 Mark Word 记录这个线程 ID，下次进入 synchronized 时，如果还是同一个线程，可以直接执行，无需额外加锁。\n\n②、轻量级锁：当多个线程尝试获取锁但不是同一个时段，偏向锁会升级为轻量级锁，等待锁的线程通过 CAS 自旋避免进入阻塞状态。\n\n③、重量级锁：如果自旋失败，锁会升级为重量级锁，等待锁的线程会进入阻塞状态，等待监视器 Monitor 进行调度。\n\n详细解释一下：\n\n**①、从无锁到偏向锁：**\n\n当一个线程首次访问同步代码时，如果此对象处于无锁状态且偏向锁未被禁用，JVM 会将该对象头的锁标记改为偏向锁状态，并记录当前线程 ID。此时，对象头中的 Mark Word 中存储了持有偏向锁的线程 ID。\n\n如果另一个线程尝试获取这个已被偏向的锁，JVM 会检查当前持有偏向锁的线程是否活跃。如果持有偏向锁的线程不活跃，可以将锁偏向给新的线程；否则撤销偏向锁，升级为轻量级锁。\n\n**②、偏向锁的轻量级锁：**\n\n进行偏向锁撤销时，会遍历堆栈的所有锁记录，暂停拥有偏向锁的线程，并检查锁对象。如果这个过程中发现有其他线程试图获取这个锁，JVM 会撤销偏向锁，并将锁升级为轻量级锁。\n\n当有两个或以上线程竞争同一个偏向锁时，偏向锁模式不再有效，此时偏向锁会被撤销，对象的锁状态会升级为轻量级锁。\n\n**③、轻量级锁到重量级锁：**\n\n轻量级锁通过自旋来等待锁释放。如果自旋超过预定次数（自旋次数是可调的，并且是自适应的，失败次数多自旋次数就少），表明锁竞争激烈。\n\n当自旋多次失败，或者有线程在等待队列中等待相同的轻量级锁时，轻量级锁会升级为重量级锁。在这种情况下，JVM 会在操作系统层面创建一个互斥锁——Mutex，所有进一步尝试获取该锁的线程将会被阻塞，直到锁被释放。"
+ },
+ {
+ "id": 116,
+ "question": "synchronized 和 ReentrantLock 的区别了解吗？",
+ "answer": "两句话回答： 由 JVM 内部的 Monitor 机制实现，基于 AQS 实现。\n\nsynchronized 可以自动加锁和解锁，ReentrantLock 需要手动 `lock()` 和 `unlock()`。\n\n\n\n如果面试官还想知道更多，可以继续回答：\n\n①、ReentrantLock 可以实现多路选择通知，绑定多个 ，而 synchronized 只能通过 wait 和 notify 唤醒，属于单路通知；\n\n\n```java\nReentrantLock lock = new ReentrantLock();\nCondition condition = lock.newCondition();\n```\n\n\n②、synchronized 可以在方法和代码块上加锁，ReentrantLock 只能在代码块上加锁，但可以指定是公平锁还是非公平锁。\n\n\n```java\n// synchronized 修饰方法\npublic synchronized void method() {\n // 业务代码\n}\n\n// synchronized 修饰代码块\nsynchronized (this) {\n // 业务代码\n}\n\n// ReentrantLock 加锁\nReentrantLock lock = new ReentrantLock();\nlock.lock();\ntry {\n // 业务代码\n} finally {\n lock.unlock();\n}\n```\n\n\n③、ReentrantLock 提供了一种能够中断等待锁的线程机制，通过 `lock.lockInterruptibly()` 来实现。\n\n\n```java\nReentrantLock lock = new ReentrantLock();\ntry {\n lock.lockInterruptibly();\n} catch (InterruptedException e) {\n // 处理中断异常\n}\n```\n\n\n#### [并发量大的情况下，使用 synchronized 还是 ReentrantLock？](#并发量大的情况下-使用-synchronized-还是-reentrantlock)\n\n我更倾向于 ReentrantLock，因为：\n\n* ReentrantLock 提供了超时和公平锁等特性，可以应对更复杂的并发场景。\n* ReentrantLock 允许更细粒度的锁控制，能有效减少锁竞争。\n* ReentrantLock 支持条件变量 Condition，可以实现比 synchronized 更友好的线程间通信机制。\n\n#### [Lock 了解吗？](#lock-了解吗)\n\nLock 是 JUC 中的一个接口，最常用的实现类包括可重入锁 ReentrantLock、读写锁 ReentrantReadWriteLock 等。\n\n#### [ReentrantLock 的 lock() 方法实现逻辑了解吗？](#reentrantlock-的-lock-方法实现逻辑了解吗)\n\nlock 方法的具体实现由 ReentrantLock 内部的 Sync 类来实现，涉及到线程的自旋、阻塞队列、CAS、AQS 等。\n\n\n\nlock 方法会首先尝试通过 CAS 来获取锁。如果当前锁没有被持有，会将锁状态设置为 1，表示锁已被占用。否则，会将当前线程加入到 AQS 的等待队列中。\n\n\n```java\nfinal void lock() {\n if (compareAndSetState(0, 1)) // 尝试直接获取锁\n setExclusiveOwnerThread(Thread.currentThread());\n else\n acquire(1); // 如果获取失败，进入AQS队列等待\n}\n```"
+ },
+ {
+ "id": 117,
+ "question": "AQS 了解多少？",
+ "answer": "AQS 是一个抽象类，它维护了一个共享变量 state 和一个线程等待队列，为 ReentrantLock 等类提供底层支持。\n\n\n\nAQS 的思想是，如果被请求的共享资源处于空闲状态，则当前线程成功获取锁；否则，将当前线程加入到等待队列中，当其他线程释放锁时，从等待队列中挑选一个线程，把锁分配给它。\n\n#### [AQS 的源码阅读过吗？](#aqs-的源码阅读过吗)\n\n有研究过。\n\n第一，状态 state 由 volatile 变量修饰，用于保证多线程之间的可见性；\n\n\n```java\nprivate volatile int state;\n```\n\n\n②、同步队列由内部定义的 Node 类实现，每个 Node 包含了等待状态、前后节点、线程的引用等，是一个先进先出的双向链表。\n\n\n```java\nstatic final class Node {\n static final int CANCELLED = 1;\n static final int SIGNAL = -1;\n static final int CONDITION = -2;\n static final int PROPAGATE = -3;\n\n volatile Node prev;\n\n volatile Node next;\n\n volatile Thread thread;\n}\n```\n\n\nAQS 支持两种同步方式：\n\n* 独占模式下：每次只能有一个线程持有锁，例如 ReentrantLock。\n* 共享模式下：多个线程可以同时获取锁，例如 Semaphore 和 CountDownLatch。\n\n核心方法包括：\n\n* `acquire`：获取锁，失败进入等待队列；\n* `release`：释放锁，唤醒等待队列中的线程；\n* `acquireShared`：共享模式获取锁；\n* `releaseShared`：共享模式释放锁。\n\nAQS 使用一个 CLH 队列来维护等待线程，CLH 是三个作者 Craig、Landin 和 Hagersten 的首字母缩写，是一种基于链表的自旋锁。\n\n\n\n在 CLH 中，当一个线程尝试获取锁失败后，会被添加到队列的尾部并自旋，等待前一个节点的线程释放锁。\n\n\n\nCLH 的优点是，假设有 100 个线程在等待锁，锁释放之后，只会通知队列中的第一个线程去竞争锁。避免同时唤醒大量线程，浪费 CPU 资源。"
+ },
+ {
+ "id": 118,
+ "question": "说说 ReentrantLock 的实现原理？",
+ "answer": "是基于 AQS 实现的 可重入排他锁，使用 CAS 尝试获取锁，失败的话，会进入 CLH 阻塞队列，支持公平锁、非公平锁，可以中断、超时等待。\n\n\n\n内部通过一个计数器 state 来跟踪锁的状态和持有次数。当线程调用 `lock()` 方法获取锁时，ReentrantLock 会检查 state 的值，如果为 0，通过 CAS 修改为 1，表示成功加锁。否则根据当前线程的公平性策略，加入到等待队列中。\n\n线程首次获取锁时，state 值设为 1；如果同一个线程再次获取锁时，state 加 1；每释放一次锁，state 减 1。\n\n当线程调用 `unlock()` 方法时，ReentrantLock 会将持有锁的 state 减 1，如果 `state = 0`，则释放锁，并唤醒等待队列中的线程来竞争锁。\n\n使用方式非常简单：\n\n\n```java\nclass CounterWithLock {\n private int count = 0;\n private final Lock lock = new ReentrantLock();\n\n public void increment() {\n lock.lock(); // 获取锁\n try {\n count++;\n } finally {\n lock.unlock(); // 释放锁\n }\n }\n\n public int getCount() {\n return count;\n }\n}\n```\n\n\n`new ReentrantLock()` 默认创建的是非公平锁 NonfairSync。在非公平锁模式下，锁可能会授予刚刚请求它的线程，而不考虑等待时间。当切换到公平锁模式下，锁会授予等待时间最长的线程。"
+ },
+ {
+ "id": 119,
+ "question": "ReentrantLock 怎么创建公平锁？",
+ "answer": "很简单，创建 ReentrantLock 的时候，传递参数 true 就可以了。\n\n\n```java\nReentrantLock lock = new ReentrantLock(true);\n// true 代表公平锁，false 代表非公平锁\npublic ReentrantLock(boolean fair) {\n sync = fair ? new FairSync() : new NonfairSync();\n}\n```\n\n\n#### [怎么创建一个非公平锁呢？](#怎么创建一个非公平锁呢)\n\n创建 ReentrantLock 时，不传递参数或者传递参数就好了。\n\n#### [非公平锁和公平锁有什么不同？](#非公平锁和公平锁有什么不同)\n\n两句话回答：\n\n公平锁意味着在多个线程竞争锁时，获取锁的顺序与线程请求锁的顺序相同，即先来先服务。\n\n非公平锁不保证线程获取锁的顺序，当锁被释放时，任何请求锁的线程都有机会获取锁，而不是按照请求的顺序。\n\n#### [公平锁的实现逻辑了解吗？](#公平锁的实现逻辑了解吗)\n\n公平锁的核心逻辑在 AQS 的 `hasQueuedPredecessors()` 方法中，该方法用于判断当前线程前面是否有等待的线程。\n\n\n\n如果队列前面有等待线程，当前线程就不能抢占锁，必须按照队列顺序排队。如果队列前面没有线程，或者当前线程是队列头部的线程，就可以获取锁。"
+ },
+ {
+ "id": 120,
+ "question": "CAS 了解多少？",
+ "answer": "CAS 是一种乐观锁，用于比较一个变量的当前值是否等于预期值，如果相等，则更新值，否则重试。\n\n\n\n在 CAS 中，有三个值：\n\n* V：要更新的变量(var)\n* E：预期值(expected)\n* N：新值(new)\n\n先判断 V 是否等于 E，如果等于，将 V 的值设置为 N；如果不等，说明已经有其它线程更新了 V，当前线程就放弃更新。\n\n这个比较和替换的操作需要是原子的，不可中断的。Java 中的 CAS 是由 Unsafe 类实现的。\n\nAtomicInteger 类的 compareAndSet 就是一个 CAS 方法：\n\n\n```java\nAtomicInteger atomicInteger = new AtomicInteger(0);\nint expect = 0;\nint update = 1;\natomicInteger.compareAndSet(expect, update);\n```\n\n\n它调用的是 Unsafe 的 compareAndSwapInt。\n\n\n\n#### [怎么保证 CAS 的原子性？](#怎么保证-cas-的原子性)\n\nCPU 会发出一个 LOCK 指令进行总线锁定，阻止其他处理器对内存地址进行操作，直到当前指令执行完成。\n\n\n```text\nlock cmpxchg [esi], eax ; 比较 esi 地址中的值与 eax，如果相等则替换\n```\n"
+ },
+ {
+ "id": 121,
+ "question": "CAS 有什么问题？",
+ "answer": "CAS 存在三个经典问题，ABA 问题、自旋开销大、只能操作一个变量等。\n\n\n\n#### [什么是 ABA 问题？](#什么是-aba-问题)\n\nABA 问题指的是，一个值原来是 A，后来被改为 B，再后来又被改回 A，这时 CAS 会误认为这个值没有发生变化。\n\n\n```text\n线程 1：CAS(A → B)，修改变量 A → B\n线程 2：CAS(B → A)，变量又变回 A\n线程 3：CAS(A → C)，CAS 成功，但实际数据已被修改过！\n```\n\n\n可以使用版本号/时间戳的方式来解决 ABA 问题。\n\n比如说，每次变量更新时，不仅更新变量的值，还更新一个版本号。CAS 操作时，不仅比较变量的值，还比较版本号。\n\n\n```java\nclass OptimisticLockExample {\n private int version;\n private int value;\n\n public synchronized boolean updateValue(int newValue, int currentVersion) {\n if (this.version == currentVersion) {\n this.value = newValue;\n this.version++;\n return true;\n }\n return false;\n }\n}\n```\n\n\nJava 的 AtomicStampedReference 就增加了版本号，它会同时检查引用值和 stamp 是否都相等。\n\n\n\n使用示例：\n\n\n```java\nclass ABAFix {\n private static AtomicStampedReference ref = new AtomicStampedReference<>(\"100\", 1);\n\n public static void main(String[] args) {\n new Thread(() -> {\n int stamp = ref.getStamp();\n ref.compareAndSet(\"100\", \"200\", stamp, stamp + 1);\n ref.compareAndSet(\"200\", \"100\", ref.getStamp(), ref.getStamp() + 1);\n }).start();\n\n new Thread(() -> {\n try { Thread.sleep(100); } catch (InterruptedException e) {}\n int stamp = ref.getStamp();\n System.out.println(\"CAS 结果：\" + ref.compareAndSet(\"100\", \"300\", stamp, stamp + 1));\n }).start();\n }\n}\n```\n\n\n#### [自旋开销大怎么解决？](#自旋开销大怎么解决)\n\nCAS 失败时会不断自旋重试，如果一直不成功，会给 CPU 带来非常大的执行开销。\n\n可以加一个自旋次数的限制，超过一定次数，就切换到 synchronized 挂起线程。\n\n\n```java\nint MAX_RETRIES = 10;\nint retries = 0;\nwhile (!atomicInt.compareAndSet(expect, update)) {\n retries++;\n if (retries > MAX_RETRIES) {\n synchronized (this) { // 超过次数，使用 synchronized 处理\n if (atomicInt.get() == expect) {\n atomicInt.set(update);\n }\n }\n break;\n }\n}\n```\n\n\n#### [涉及到多个变量同时更新怎么办？](#涉及到多个变量同时更新怎么办)\n\n可以将多个变量封装为一个对象，使用 AtomicReference 进行 CAS 更新。\n\n\n```java\nclass Account {\n static class Balance {\n final int money;\n final int points;\n\n Balance(int money, int points) {\n this.money = money;\n this.points = points;\n }\n }\n\n private AtomicReference balance = new AtomicReference<>(new Balance(100, 10));\n\n public void update(int newMoney, int newPoints) {\n Balance oldBalance, newBalance;\n do {\n oldBalance = balance.get();\n newBalance = new Balance(newMoney, newPoints);\n } while (!balance.compareAndSet(oldBalance, newBalance));\n }\n}\n```"
+ },
+ {
+ "id": 122,
+ "question": "Java 有哪些保证原子性的方法？",
+ "answer": "\n\n比如说以 Atomic 开头的原子类，synchronized 关键字，ReentrantLock 锁等。"
+ },
+ {
+ "id": 123,
+ "question": "原子操作类了解多少？",
+ "answer": "原子操作类是基于 CAS + volatile 实现的，底层依赖于 Unsafe 类，最常用的有 AtomicInteger、AtomicLong、AtomicReference 等。\n\n\n\n像 AtomicIntegerArray 这种以 Array 结尾的，还可以原子更新数组里的元素。\n\n\n```java\nclass AtomicArrayExample {\n public static void main(String[] args) {\n AtomicIntegerArray atomicArray = new AtomicIntegerArray(new int[]{1, 2, 3});\n\n atomicArray.incrementAndGet(1); // 对索引 1 进行自增\n System.out.println(atomicArray.get(1)); // 输出 3\n }\n}\n```\n\n\n像 AtomicStampedReference 还可以通过版本号的方式解决 CAS 中的 ABA 问题。\n\n\n```java\nclass AtomicStampedReferenceExample {\n public static void main(String[] args) {\n AtomicStampedReference ref = new AtomicStampedReference<>(100, 1);\n\n int stamp = ref.getStamp(); // 获取版本号\n ref.compareAndSet(100, 200, stamp, stamp + 1); // A → B\n ref.compareAndSet(200, 100, ref.getStamp(), ref.getStamp() + 1); // B → A\n }\n}\n```"
+ },
+ {
+ "id": 124,
+ "question": "AtomicInteger 的源码读过吗？",
+ "answer": "有读过。\n\nAtomicInteger 是基于 volatile 和 CAS 实现的，底层依赖于 Unsafe 类。核心方法包括 getAndIncrement、compareAndSet 等。\n\n\n```java\npublic final int getAndIncrement() {\n return unsafe.getAndAddInt(this, valueOffset, 1);\n}\n```"
+ },
+ {
+ "id": 125,
+ "question": "线程死锁了解吗？",
+ "answer": "死锁发生在多个线程相互等待对方释放锁时。比如说线程 1 持有锁 R1，等待锁 R2；线程 2 持有锁 R2，等待锁 R1。\n\n\n\n#### [死锁发生的四个条件了解吗？](#死锁发生的四个条件了解吗)\n\n\n\n第一条件是**互斥**：资源不能被多个线程共享，一次只能由一个线程使用。如果一个线程已经占用了一个资源，其他请求该资源的线程必须等待，直到资源被释放。\n\n第二个条件是**持有并等待**：一个线程已经持有一个资源，并且在等待获取其他线程持有的资源。\n\n第三个条件是**不可抢占**：资源不能被强制从线程中夺走，必须等线程自己释放。\n\n第四个条件是**循环等待**：存在一种线程等待链，线程 A 等待线程 B 持有的资源，线程 B 等待线程 C 持有的资源，直到线程 N 又等待线程 A 持有的资源。\n\n#### [该如何避免死锁呢？](#该如何避免死锁呢)\n\n第一，所有线程都按照固定的顺序来申请资源。例如，先申请 R1 再申请 R2。\n\n第二，如果线程发现无法获取某个资源，可以先释放已经持有的资源，重新尝试申请。"
+ },
+ {
+ "id": 126,
+ "question": "死锁问题怎么排查呢？",
+ "answer": "首先从系统级别上排查，比如说在 Linux 生产环境中，可以先使用 `top` `ps` 等命令查看进程状态，看看是否有进程占用了过多的资源。\n\n接着，使用 JDK 自带的一些性能监控工具进行排查，比如说 使用 `jps -l` 查看当前进程，然后使用 `jstack 进程号` 查看当前进程的线程堆栈信息，看看是否有线程在等待锁资源。\n\n也可以使用一些可视化的性能监控工具，比如说 JConsole、VisualVM 等，查看线程的运行状态、锁的竞争情况等。\n\n\n\n我们来通过实际代码说明一下：\n\n\n```java\nclass DeadLockDemo {\n private static final Object lock1 = new Object();\n private static final Object lock2 = new Object();\n\n public static void main(String[] args) {\n new Thread(() -> {\n synchronized (lock1) {\n System.out.println(\"线程1获取到了锁1\");\n try {\n Thread.sleep(1000);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n synchronized (lock2) {\n System.out.println(\"线程1获取到了锁2\");\n }\n }\n }).start();\n\n new Thread(() -> {\n synchronized (lock2) {\n System.out.println(\"线程2获取到了锁2\");\n try {\n Thread.sleep(1000);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n synchronized (lock1) {\n System.out.println(\"线程2获取到了锁1\");\n }\n }\n }).start();\n }\n}\n```\n\n\n创建两个线程，每个线程都试图按照不同的顺序获取两个。\n\n锁的获取顺序不一致很容易导致死锁。运行这段代码，会发现两个线程都无法继续执行，进入了死锁状态。\n\n\n\n运行 `jstack pid` 命令，可以看到死锁的线程信息。\n\n\n\n编码时，尽量使用 `tryLock()` 代替 `lock()`，`tryLock()` 可以设置超时时间，避免线程一直等待。\n\n同时，尽量避免一个线程同时获取多个锁，如果需要多个锁，可以按照固定的顺序获取。"
+ },
+ {
+ "id": 127,
+ "question": "聊聊线程同步和互斥？（补充）",
+ "answer": "同步，意味着线程之间要密切合作，按照一定的顺序来执行任务。比如说，线程 A 先执行，线程 B 再执行。\n\n互斥，意味着线程之间要抢占资源，同一时间只能有一个线程访问共享资源。比如说，线程 A 在访问共享资源时，线程 B 不能访问。\n\n同步关注的是线程之间的协作，互斥关注的是线程之间的竞争。\n\n#### [如何实现同步和互斥？](#如何实现同步和互斥)\n\n可以使用 synchronized 关键字或者 Lock 接口的实现类，如 ReentrantLock 来给资源加锁。\n\n锁在操作系统层面的意思是 Mutex，某个线程进入临界区后，也就是获取到锁后，其他线程不能再进入临界区，要阻塞等待持有锁的线程离开临界区。\n\n\n\n#### [锁要解决哪些问题？](#锁要解决哪些问题)\n\n第一，谁可以拿到锁，可以是类对象，可以是当前的 this 对象，也可以是任何其他新建的对象。\n\n\n```java\nsynchronized (this) {\n // 临界区\n}\n```\n\n\n第二，抢占锁的规则，能不能抢占多次，自己能不能反复抢。\n\n第三，抢不到怎么办，自旋？阻塞？或者超时放弃？\n\n第四，锁被释放了还在等待锁的线程怎么办？是通知所有线程一起抢或者只告诉一个线程抢？\n\n#### [说说自旋锁？](#说说自旋锁)\n\n自旋锁是指当线程尝试获取锁时，如果锁已经被占用，线程不会立即阻塞，而是**通过自旋**，也就是循环等待的方式不断尝试获取锁。\n\n\n```text\n线程1 线程2\n | |\n | 获取锁成功 | 尝试获取锁\n |------------>|（锁已被占用，自旋等待）\n | 释放锁 |\n |<------------| 获取锁成功\n | |\n```\n\n\n适用于锁持有时间短的场景，ReentrantLock 的 tryLock 方法就用到了自旋锁。\n\n\n\n自旋锁的优点是可以避免线程切换带来的开销，缺点是如果锁被占用时间过长，会导致线程空转，浪费 CPU 资源。\n\n\n```java\nclass SpinLock {\n private AtomicBoolean lock = new AtomicBoolean(false);\n\n public void lock() {\n while (!lock.compareAndSet(false, true)) {\n // 自旋等待，不断尝试获取锁\n }\n }\n\n public void unlock() {\n lock.set(false);\n }\n\n public static void main(String[] args) {\n SpinLock spinLock = new SpinLock();\n\n Runnable task = () -> {\n spinLock.lock();\n try {\n System.out.println(Thread.currentThread().getName() + \" 获取到锁\");\n } finally {\n spinLock.unlock();\n }\n };\n\n Thread t1 = new Thread(task);\n Thread t2 = new Thread(task);\n\n t1.start();\n t2.start();\n }\n}\n```\n\n\n默认情况下，自旋锁会一直等待，直到获取到锁为止。在实际开发中，需要设置自旋次数或者超时时间。如果超过阈值，线程可以放弃锁或者进入阻塞状态。\n\n#### [互斥和同步在时间上有要求吗？](#互斥和同步在时间上有要求吗)\n\n有。\n\n互斥的核心是保证同一时刻只有一个线程能访问共享资源。\n\n同步强调的是线程之间的执行顺序，特别是在多个线程需要依赖于彼此的执行结果时。\n\n例如，在 CountDownLatch 中，主线程会等待多个子线程的任务完成。\n\n\n```java\nclass SyncExample {\n public static void main(String[] args) throws InterruptedException {\n CountDownLatch latch = new CountDownLatch(3);\n \n // 创建3个子线程\n for (int i = 0; i < 3; i++) {\n new Thread(() -> {\n try {\n Thread.sleep(1000); // 模拟任务\n System.out.println(\"打完练习伴侣者了.\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n latch.countDown(); // 每个线程任务完成后计数器减1\n }\n }).start();\n }\n \n System.out.println(\"等打完三把练习伴侣者就去睡觉...\");\n latch.await(); // 主线程等待子线程完成\n System.out.println(\"好，练习伴侣者玩完了，可以睡了\");\n }\n}\n```\n\n\n所有子线程完成后，主线程才会继续执行。\n\n"
+ },
+ {
+ "id": 128,
+ "question": "聊聊悲观锁和乐观锁？（补充）",
+ "answer": "> 2024 年 05 月 01 日增补\n\n好的。\n\n悲观锁认为每次访问共享资源时都会发生冲突，所在在操作前一定要先加锁，防止其他线程修改数据。\n\n乐观锁认为冲突不会总是发生，所以在操作前不加锁，而是在更新数据时检查是否有其他线程修改了数据。如果发现数据被修改了，就会重试。\n\n#### [乐观锁发现有线程过来修改数据，怎么办？](#乐观锁发现有线程过来修改数据-怎么办)\n\n可以重新读取数据，然后再尝试更新，直到成功为止或达到最大重试次数。\n\n\n```text\n读取数据 -> 尝试更新 -> 成功（返回成功）\n |\n -> 失败 -> 重试 -> 达到最大次数 -> 返回失败\n```\n\n\n写个代码演示一下：\n\n\n```java\nclass CasRetryExample {\n private static AtomicInteger counter = new AtomicInteger(0);\n private static final int MAX_RETRIES = 5;\n\n public static void main(String[] args) {\n boolean success = false;\n int retries = 0;\n\n while (retries < MAX_RETRIES) {\n int currentValue = counter.get();\n boolean updated = counter.compareAndSet(currentValue, currentValue + 1);\n \n if (updated) {\n System.out.println(\"更新成功，当前值: \" + counter.get());\n success = true;\n break;\n } else {\n retries++;\n System.out.println(\"更新失败，进行第 \" + retries + \" 次重试\");\n }\n }\n\n if (!success) {\n System.out.println(\"达到最大重试次数，操作失败\");\n }\n }\n}\n```"
+ }
+ ]
+ },
+ {
+ "id": 23,
+ "categoryName": "并发工具类",
+ "questions": [
+ {
+ "id": 129,
+ "question": "CountDownLatch 了解吗？",
+ "answer": "CountDownLatch 是 JUC 中的一个同步工具类，用于协调多个线程之间的同步，确保主线程在多个子线程完成任务后继续执行。\n\n它的核心思想是通过一个倒计时计数器来控制多个线程的执行顺序。\n\n\n```java\nclass CountDownLatchExample {\n public static void main(String[] args) throws InterruptedException {\n int threadCount = 3;\n CountDownLatch latch = new CountDownLatch(threadCount);\n\n for (int i = 0; i < threadCount; i++) {\n new Thread(() -> {\n try {\n Thread.sleep((long) (Math.random() * 1000)); // 模拟任务执行\n System.out.println(Thread.currentThread().getName() + \" 执行完毕\");\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n latch.countDown(); // 线程完成后，计数器 -1\n }\n }).start();\n }\n\n latch.await(); // 主线程等待\n System.out.println(\"所有子线程执行完毕，主线程继续执行\");\n }\n}\n```\n\n\n在使用的时候，我们需要先初始化一个 CountDownLatch 对象，指定一个计数器的初始值，表示需要等待的线程数量。\n\n然后在每个子线程执行完任务后，调用 `countDown()` 方法，计数器减 1。\n\n接着主线程调用 `await()` 方法进入阻塞状态，直到计数器为 0，也就是所有子线程都执行完任务后，主线程才会继续执行。\n\n\n\n以练习伴侣者荣耀为例，我们来创建五个线程，分别代表大乔、兰陵王、安其拉、哪吒和铠。每个玩家都调用 `countDown()` 方法，表示已就位。主线程调用 `await()` 方法，等待所有玩家就位。\n\n\n```java\npublic static void main(String[] args) throws InterruptedException {\n CountDownLatch countDownLatch = new CountDownLatch(5);\n\n Thread daqiao = new Thread(() -> {\n System.out.println(\"大乔已就位！\");\n countDownLatch.countDown();\n });\n Thread lanlingwang = new Thread(() -> {\n System.out.println(\"兰陵练习伴侣已就位！\");\n countDownLatch.countDown();\n });\n Thread anqila = new Thread(() -> {\n System.out.println(\"安其拉已就位！\");\n countDownLatch.countDown();\n });\n Thread nezha = new Thread(() -> {\n System.out.println(\"哪吒已就位！\");\n countDownLatch.countDown();\n });\n Thread kai = new Thread(() -> {\n System.out.println(\"铠已就位！\");\n countDownLatch.countDown();\n });\n\n daqiao.start();\n lanlingwang.start();\n anqila.start();\n nezha.start();\n kai.start();\n\n countDownLatch.await();\n System.out.println(\"全员就位，开始游戏！\");\n}\n```\n\n\n五个玩家在倒计时结束后，一起出击。\n\n\n```java\nprivate static void waitToFight(CountDownLatch countDownLatch, String name) {\n try {\n countDownLatch.await(); // 在此等待信号再继续\n System.out.println(name + \" 收到，发起进攻！\");\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n System.out.println(name + \" 被中断\");\n }\n}\n\npublic static void main(String[] args) {\n CountDownLatch countDownLatch = new CountDownLatch(1);\n\n Thread daqiao = new Thread(() -> waitToFight(countDownLatch, \"大乔\"), \"Thread-大乔\");\n Thread lanlingwang = new Thread(() -> waitToFight(countDownLatch, \"兰陵练习伴侣\"), \"Thread-兰陵练习伴侣\");\n Thread anqila = new Thread(() -> waitToFight(countDownLatch, \"安琪拉\"), \"Thread-安琪拉\");\n Thread nezha = new Thread(() -> waitToFight(countDownLatch, \"哪吒\"), \"Thread-哪吒\");\n Thread kai = new Thread(() -> waitToFight(countDownLatch, \"凯\"), \"Thread-凯\");\n\n daqiao.start();\n lanlingwang.start();\n anqila.start();\n nezha.start();\n kai.start();\n\n try {\n Thread.sleep(5000); // 模拟准备时间\n } catch (InterruptedException e) {\n Thread.currentThread().interrupt();\n System.out.println(\"主线程被中断\");\n }\n\n System.out.println(\"敌军还有 5 秒到达战场，全军出击！\");\n countDownLatch.countDown(); // 发出信号\n}\n```\n\n\n#### [场景题：假如要查10万多条数据，用线程池分成20个线程去执行，怎么做到等所有的线程都查找完之后，即最后一条结果查找结束了，才输出结果？](#场景题-假如要查10万多条数据-用线程池分成20个线程去执行-怎么做到等所有的线程都查找完之后-即最后一条结果查找结束了-才输出结果)\n\n很简单，可以使用 CountDownLatch 来实现。CountDownLatch 非常适合这个场景。\n\n第一步，创建 CountDownLatch 对象，初始值设定为 20，表示 20 个线程需要完成任务。\n\n第二步，创建线程池，每个线程执行查询操作，查询完毕后调用 `countDown()` 方法，计数器减 1。\n\n第三步，主线程调用 `await()` 方法，等待所有线程执行完毕。\n\n\n```java\nclass DataQueryExample {\n\n public static void main(String[] args) throws InterruptedException {\n // 模拟10万条数据\n int totalRecords = 100000;\n int threadCount = 20;\n int batchSize = totalRecords / threadCount; // 每个线程处理的数据量\n\n // 创建线程池\n ExecutorService executor = Executors.newFixedThreadPool(threadCount);\n CountDownLatch latch = new CountDownLatch(threadCount);\n\n // 模拟查询结果\n ConcurrentLinkedQueue results = new ConcurrentLinkedQueue<>();\n\n for (int i = 0; i < threadCount; i++) {\n int start = i * batchSize;\n int end = (i == threadCount - 1) ? totalRecords : (start + batchSize);\n \n executor.execute(() -> {\n try {\n // 模拟查询操作\n for (int j = start; j < end; j++) {\n results.add(\"Data-\" + j);\n }\n System.out.println(Thread.currentThread().getName() + \" 处理数据 \" + start + \" - \" + end);\n } finally {\n latch.countDown(); // 线程任务完成，计数器减1\n }\n });\n }\n\n // 等待所有线程完成\n latch.await();\n executor.shutdown();\n\n // 输出结果\n System.out.println(\"所有线程执行完毕，查询结果总数：\" + results.size());\n }\n}\n```"
+ },
+ {
+ "id": 130,
+ "question": "CyclicBarrier 了解吗？",
+ "answer": "了解。\n\nCyclicBarrier 的字面意思是可循环使用的屏障，用于多个线程相互等待，直到所有线程都到达屏障后再同时执行。\n\n\n\n在使用的时候，我们需要先初始化一个 CyclicBarrier 对象，指定一个屏障值 N，表示需要等待的线程数量。\n\n然后每个线程执行 `await()` 方法，表示自己已经到达屏障，等待其他线程，此时屏障值会减 1。\n\n当所有线程都到达屏障后，也就是屏障值为 0 时，所有线程会继续执行。\n\n\n```java\nclass CyclicBarrierExample {\n private static final int THREAD_COUNT = 3;\n private static final CyclicBarrier barrier = new CyclicBarrier(THREAD_COUNT);\n\n public static void main(String[] args) {\n for (int i = 0; i < THREAD_COUNT; i++) {\n new Thread(() -> {\n try {\n System.out.println(Thread.currentThread().getName() + \" 到达屏障\");\n barrier.await(); // 线程阻塞，直到所有线程都到达\n System.out.println(Thread.currentThread().getName() + \" 继续执行\");\n } catch (InterruptedException | BrokenBarrierException e) {\n e.printStackTrace();\n }\n }).start();\n }\n }\n}\n```"
+ },
+ {
+ "id": 131,
+ "question": "CyclicBarrier 和 CountDownLatch 有什么区别？",
+ "answer": "CyclicBarrier 让所有线程相互等待，全部到达后再继续；CountDownLatch 让主线程等待所有子线程执行完再继续。\n\n| 对比项 | CyclicBarrier | CountDownLatch |\n| --- | --- | --- |\n| 主要用途 | 让所有线程相互等待，全部到达后再继续 | 让主线程等待所有子线程执行完 |\n| 可重用性 | ✅ 可重复使用，每次屏障打开后自动重置 | ❌ 不可重复使用，计数器归零后不能恢复 |\n| 是否可执行回调 | ✅ 可以，所有线程到达屏障后可执行 barrierAction | ❌ 不能 |\n| 线程等待情况 | 所有线程互相等待，一个线程未到达，其他线程都会阻塞 | 主线程等待所有子线程完成，子线程执行完后可继续运行 |\n| 适用场景 | 线程相互依赖，需要同步执行 | 主线程等待子线程完成 |\n| 示例场景 | 计算任务拆分，所有线程都到达后才能继续 | 主线程等多个任务初始化完成 |"
+ },
+ {
+ "id": 132,
+ "question": "Semaphore 了解吗？",
+ "answer": "Semaphore——信号量，用于控制同时访问某个资源的线程数量，类似限流器，确保最多只有指定数量的线程能够访问某个资源，超过的必须等待。\n\n\n\n拿停车场来举例。\n\n停车场的车位是有限的，如果有空位，显示牌需要显示剩余的车位，车辆就可以驶入；否则就会显示数字 0，新来的车辆就得排队等待。\n\n如果有车离开，显示牌重新显示闲置的车位数量，等待的车辆按序驶入停车场。\n\n\n\n在使用 Semaphore 时，首先需要初始化一个 Semaphore 对象，指定许可证数量，表示最多允许多少个线程同时访问资源。\n\n然后在每个线程访问资源前，调用 `acquire()` 方法获取许可证，如果没有可用许可证，则阻塞等待。\n\n需要注意的是，访问完资源后，要调用 `release()` 方法释放许可证。\n\n\n```java\nclass SemaphoreExample {\n private static final int THREAD_COUNT = 5;\n private static final Semaphore semaphore = new Semaphore(2); // 最多允许 2 个线程访问\n\n public static void main(String[] args) {\n for (int i = 0; i < THREAD_COUNT; i++) {\n new Thread(() -> {\n try {\n semaphore.acquire(); // 获取许可（如果没有可用许可，则阻塞）\n System.out.println(Thread.currentThread().getName() + \" 访问资源...\");\n Thread.sleep(2000); // 模拟任务执行\n } catch (InterruptedException e) {\n e.printStackTrace();\n } finally {\n semaphore.release(); // 释放许可\n }\n }).start();\n }\n }\n}\n```\n\n\nSemaphore 可以用于流量控制，比如数据库连接池、网络连接池等。\n\n假如有这样一个需求，要读取几万个文件的数据，因为都是 IO 密集型任务，我们可以启动几十个线程并发地读取。\n\n但是在读到内存后，需要存储到数据库，而数据库连接数是有限的，比如说只有 10 个，那我们就必须控制线程的数量，保证同时只有 10 个线程在使用数据库连接。\n\n这个时候，就可以使用 Semaphore 来做流量控制：\n\n\n```java\nclass SemaphoreTest {\n private static final int THREAD_COUNT = 30;\n private static ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_COUNT);\n private static Semaphore s = new Semaphore(10);\n\n public static void main(String[] args) {\n for (int i = 0; i < THREAD_COUNT; i++) {\n threadPool.execute(new Runnable() {\n @Override\n public void run() {\n try {\n s.acquire();\n System.out.println(\"save data\");\n s.release();\n } catch (InterruptedException e) {\n }\n }\n });\n }\n threadPool.shutdown();\n }\n}\n```"
+ },
+ {
+ "id": 133,
+ "question": "Exchanger 了解吗？",
+ "answer": "Exchanger——交换者，用于在两个线程之间进行数据交换。\n\n\n\n支持双向数据交换，比如说线程 A 调用 `exchange(dataA)`，线程 B 调用 `exchange(dataB)`，它们会在同步点交换数据，即 A 得到 B 的数据，B 得到 A 的数据。\n\n如果一个线程先调用 `exchange()`，它会阻塞等待，直到另一个线程也调用 `exchange()`。\n\n使用 Exchanger 的时候，需要先创建一个 Exchanger 对象，然后在两个线程中调用 `exchange()` 方法，就可以进行数据交换了。\n\n\n```java\nclass ExchangerExample {\n private static final Exchanger exchanger = new Exchanger<>();\n\n public static void main(String[] args) {\n new Thread(() -> {\n try {\n String threadAData = \"数据 A\";\n System.out.println(\"线程 A 交换前的数据：\" + threadAData);\n String received = exchanger.exchange(threadAData);\n System.out.println(\"线程 A 收到的数据：\" + received);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }).start();\n\n new Thread(() -> {\n try {\n String threadBData = \"数据 B\";\n System.out.println(\"线程 B 交换前的数据：\" + threadBData);\n String received = exchanger.exchange(threadBData);\n System.out.println(\"线程 B 收到的数据：\" + received);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n }).start();\n }\n}\n```\n\n\nExchanger 可以用于遗传算法，也可以用于校对工作，比如我们将纸制银行流水通过人工的方式录入到电子银行时，为了避免错误，可以录入两遍，然后通过 Exchanger 来校对两次录入的结果。\n\n\n```java\nclass ExchangerTest {\n private static final Exchanger exgr = new Exchanger();\n private static ExecutorService threadPool = Executors.newFixedThreadPool(2);\n\n public static void main(String[] args) {\n threadPool.execute(new Runnable() {\n @Override\n public void run() {\n try {\n String A = \"银行流水A\"; // A录入银行流水数据\n exgr.exchange(A);\n } catch (InterruptedException e) {\n }\n }\n });\n threadPool.execute(new Runnable() {\n @Override\n public void run() {\n try {\n String B = \"银行流水B\"; // B录入银行流水数据\n String A = exgr.exchange(\"B\");\n System.out.println(\"A和B数据是否一致：\" + A.equals(B) + \"，A录入的是：\"\n + A + \"，B录入是：\" + B);\n } catch (InterruptedException e) {\n }\n }\n });\n threadPool.shutdown();\n }\n}\n```"
+ },
+ {
+ "id": 134,
+ "question": "能说一下 ConcurrentHashMap 的实现吗？（补充）",
+ "answer": "> 2024 年 03 月 25 日增补，从集合框架篇移到这里。\n\n好的。 是 HashMap 的线程安全版本。\n\nJDK 7 采用的是分段锁，整个 Map 会被分为若干段，每个段都可以独立加锁。不同的线程可以同时操作不同的段，从而实现并发。\n\n\n\nJDK 8 使用了一种更加细粒度的锁——桶锁，再配合 CAS + synchronized 代码块控制并发写入，以最大程度减少锁的竞争。\n\n\n\n对于读操作，ConcurrentHashMap 使用了 volatile 变量来保证内存可见性。\n\n对于写操作，ConcurrentHashMap 优先使用 CAS 尝试插入，如果成功就直接返回；否则使用 synchronized 代码块进行加锁处理。\n\n#### [说一下 JDK 7 中 ConcurrentHashMap 的实现原理？](#说一下-jdk-7-中-concurrenthashmap-的实现原理)\n\n好的。\n\nJDK 7 的 ConcurrentHashMap 采用的是分段锁，整个 Map 会被分为若干段，每个段都可以独立加锁，每个段类似一个 Hashtable。\n\n\n\n每个段维护一个键值对数组 `HashEntry[] table`，HashEntry 是一个单项链表。\n\n\n```java\nstatic final class HashEntry {\n final int hash;\n final K key;\n volatile V value;\n final HashEntry next;\n}\n```\n\n\n段继承了 ReentrantLock，所以每个段都是一个可重入锁，不同的线程可以同时操作不同的段，从而实现并发。\n\n\n```java\nstatic final class Segment extends ReentrantLock {\n transient volatile HashEntry[] table;\n transient int count;\n}\n```\n\n\n#### [说一下 JDK 7 中 ConcurrentHashMap 的 put 流程？](#说一下-jdk-7-中-concurrenthashmap-的-put-流程)\n\nput 流程和 HashMap 非常类似，只不过是先定位到具体的段，再通过 ReentrantLock 去操作而已。一共可以分为 4 个步骤：\n\n第一步，计算 key 的 hash，定位到段，段如果是空就先初始化；\n\n第二步，使用 ReentrantLock 进行加锁，如果加锁失败就自旋，自旋超过次数就阻塞，保证一定能获取到锁；\n\n第三步，遍历段中的键值对 HashEntry，key 相同直接替换，key 不存在就插入。\n\n第四步，释放锁。\n\n\n\n#### [说一下 JDK 7 中 ConcurrentHashMap 的 get 流程？](#说一下-jdk-7-中-concurrenthashmap-的-get-流程)\n\nget 就更简单了，先计算 key 的 hash 找到段，再遍历段中的键值对，找到就直接返回 value。\n\nget 不用加锁，因为是 value 是 的，所以线程读取 value 时不会出现可见性问题。\n\n#### [说一下 JDK 8 中 ConcurrentHashMap 的实现原理？](#说一下-jdk-8-中-concurrenthashmap-的实现原理)\n\n好的。\n\nJDK 8 中的 ConcurrentHashMap 取消了分段锁，采用 CAS + synchronized 来实现更细粒度的桶锁，并且使用红黑树来优化链表以提高哈希冲突时的查询效率，性能比 JDK 7 有了很大的提升。\n\n#### [说一下 JDK 8 中 ConcurrentHashMap 的 put 流程？](#说一下-jdk-8-中-concurrenthashmap-的-put-流程)\n\n\n\n第一步，计算 key 的 hash，以确定桶在数组中的位置。如果数组为空，采用 CAS 的方式初始化，以确保只有一个线程在初始化数组。\n\n\n```java\n// 计算 hash\nint hash = spread(key.hashCode());\n\n// 初始化数组\nif (tab == null || (n = tab.length) == 0)\n tab = initTable();\n\n// 计算桶的位置\nint i = (n - 1) & hash;\n```\n\n\n第二步，如果桶为空，直接 CAS 插入节点。如果 CAS 操作失败，会退化为 synchronized 代码块来插入节点。\n\n\n```java\n// CAS 插入节点\nif (tabAt(tab, i) == null) {\n if (casTabAt(tab, i, null, new Node(hash, key, value, null)))\n break;\n}\n\n// 否则，使用 synchronized 代码块插入节点\nelse {\n synchronized (f) { // **只锁当前桶**\n if (tabAt(tab, i) == f) { // 确保未被其他线程修改\n if (f.hash >= 0) { // 链表处理\n for (Node e = f;;) {\n K ek;\n if (e.hash == hash && ((ek = e.key) == key || (key != null && key.equals(ek)))) {\n e.val = value;\n break;\n }\n e = e.next;\n }\n } else if (f instanceof TreeBin) { // **红黑树处理**\n ((TreeBin) f).putTreeVal(hash, key, value);\n }\n }\n }\n}\n```\n\n\n插入的过程中会判断桶的哈希是否小于 0（`f.hash >= 0`），小于 0 说明是红黑树，大于等于 0 说明是链表。\n\n这里补充一点：在 ConcurrentHashMap 的实现中，红黑树节点 TreeBin 的 hash 值固定为 -2。\n\n\n\n第三步，如果链表长度超过 8，转换为红黑树。\n\n\n```java\nif (binCount >= TREEIFY_THRESHOLD)\n treeifyBin(tab, i);\n```\n\n\n第四步，在插入新节点后，会调用 `addCount()` 方法检查是否需要扩容。\n\n\n```java\naddCount(1L, binCount);\n```\n\n\n#### [说一下 JDK 8 中 ConcurrentHashMap 的 get 流程？](#说一下-jdk-8-中-concurrenthashmap-的-get-流程)\n\nget 也是通过 key 的 hash 进行定位，如果该位置节点的哈希匹配且键相等，则直接返回值。\n\n\n\n如果节点的哈希为负数，说明是个特殊节点，比如说如树节点或者正在迁移的节点，就调用`find`方法查找。\n\n\n\n否则遍历链表查找匹配的键。如果都没找到，返回 null。\n\n#### [说一下 HashMap 和 ConcurrentHashMap 的区别？](#说一下-hashmap-和-concurrenthashmap-的区别)\n\nHashMap 是非线程安全的，多线程环境下应该使用 ConcurrentHashMap。\n\n#### [你项目中怎么使用 ConcurrentHashMap 的？](#你项目中怎么使用-concurrenthashmap-的)\n\n在中，很多地方都用到了 ConcurrentHashMap，比如说在异步工具类 AsyncUtil 中，就使用了 ConcurrentHashMap 来存储任务的名称和它们的运行时间，以便观察和分析任务的执行情况。\n\n\n\n#### [说一下 ConcurrentHashMap 对 HashMap 的改进？](#说一下-concurrenthashmap-对-hashmap-的改进)\n\n首先是 hash 的计算方法上，ConcurrentHashMap 的 spread 方法接收一个已经计算好的 hashCode，然后将这个哈希码的高 16 位与自身进行异或运算。\n\n\n```java\nstatic final int spread(int h) {\n return (h ^ (h >>> 16)) & HASH_BITS;\n}\n```\n\n\n比 HashMap 的 hash 计算多了一个 `& HASH_BITS` 的操作。这里的 HASH\\_BITS 是一个常数，值为 0x7fffffff，它确保结果是一个非负整数。\n\n\n```java\nstatic final int hash(Object key) {\n int h;\n return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);\n}\n```\n\n\n另外，ConcurrentHashMap 对节点 Node 做了进一步的封装，比如说用 Forwarding Node 来表示正在进行扩容的节点。\n\n\n```java\nstatic final class ForwardingNode extends Node {\n final Node[] nextTable;\n ForwardingNode(Node[] tab) {\n super(MOVED, null, null, null);\n this.nextTable = tab;\n }\n}\n```\n\n\n最后就是 put 方法，通过 CAS + synchronized 代码块来进行并发写入。\n\n\n\n#### [为什么 ConcurrentHashMap 在 JDK 1.7 中要用 ReentrantLock，而在 JDK 1.8 要用 synchronized](#为什么-concurrenthashmap-在-jdk-1-7-中要用-reentrantlock-而在-jdk-1-8-要用-synchronized)\n\nJDK 1.7 中的 ConcurrentHashMap 使用了分段锁机制，每个 Segment 都继承了 ReentrantLock，这样可以保证每个 Segment 都可以独立地加锁。\n\n而在 JDK 1.8 中，ConcurrentHashMap 取消了 Segment 分段锁，采用了更加精细化的锁——桶锁，以及 CAS 无锁算法，每个桶都可以独立地加锁，只有在 CAS 失败时才会使用 synchronized 代码块加锁，这样可以减少锁的竞争，提高并发性能。"
+ },
+ {
+ "id": 135,
+ "question": "ConcurrentHashMap 怎么保证可见性？（补充）",
+ "answer": "> 2024 年 03 月 25 日增补\n\nConcurrentHashMap 中的 Node 节点中，value 和 next 都是 volatile 的，这样就可以保证对 value 或 next 的更新会被其他线程立即看到。\n\n\n```java\nstatic class Node implements Map.Entry {\n final int hash;\n final K key;\n volatile V value;\n volatile Node next;\n}\n```"
+ },
+ {
+ "id": 136,
+ "question": "为什么 ConcurrentHashMap 比 Hashtable 效率高（补充）",
+ "answer": "> 2024 年 03 月 26 日增补，从集合框架移动到并发编程这里\n\nHashtable 在任何时刻只允许一个线程访问整个 Map，是通过对整个 Map 加锁来实现线程安全的。比如 get 和 put 方法，是直接在方法上加的 synchronized 关键字。\n\n\n```java\npublic synchronized V put(K key, V value) {\n if (value == null) throw new NullPointerException();\n int hash = key.hashCode();\n int index = (hash & 0x7FFFFFFF) % table.length;\n ...\n return oldValue;\n}\n```\n\n\n而 ConcurrentHashMap 在 JDK 8 中是采用 CAS + synchronized 实现的，仅在必要时加锁。\n\n比如说 put 的时候优先使用 CAS 尝试插入，如果失败再使用 synchronized 代码块加锁。\n\nget 的时候是完全无锁的，因为 value 是 修饰的，保证了内存可见性。\n\n\n```java\npublic V get(Object key) {\n int hash = spread(key.hashCode());\n Node[] tab = table;\n int index = (tab.length - 1) & hash;\n Node e = tabAt(tab, index);\n \n if (e != null) {\n do {\n if (e.hash == hash && (e.key == key || (key != null && key.equals(e.key)))) {\n return e.value; // 读取 volatile 变量，保证可见性\n }\n } while ((e = e.next) != null);\n }\n return null;\n}\n```"
+ },
+ {
+ "id": 137,
+ "question": "能说一下 CopyOnWriteArrayList 的实现原理吗？（补充）",
+ "answer": "CopyOnWriteArrayList 是 ArrayList 的线程安全版本，适用于读多写少的场景。它的核心思想是写操作时创建一个新数组，修改后再替换原数组，这样就能够确保读操作无锁，从而提高并发性能。\n\n\n\n内部使用 volatile 变量来修饰数组 array，以读操作的内存可见性。\n\n\n```java\nprivate transient volatile Object[] array;\n```\n\n\n写操作的时候使用 ReentrantLock 来保证线程安全。\n\n\n```java\npublic boolean add(E e) {\n final ReentrantLock lock = this.lock;\n // 加锁\n lock.lock();\n try {\n Object[] elements = getArray();\n int len = elements.length;\n // 创建一个新数组\n Object[] newElements = Arrays.copyOf(elements, len + 1);\n newElements[len] = e;\n // 替换原数组\n setArray(newElements);\n return true;\n } finally {\n // 释放锁\n lock.unlock();\n }\n}\n```\n\n\n缺点就是写操作的时候会复制一个新数组，如果数组很大，写操作的性能会受到影响。"
+ },
+ {
+ "id": 138,
+ "question": "能说一下 BlockingQueue 吗？（补充）",
+ "answer": "> 2024 年 08 月 18 日增补，从集合框架移动到并发编程这里\n\n是 JUC 包下的一个线程安全队列，支持阻塞式的“生产者-消费者”模型。\n\n当队列容器已满，生产者线程会被阻塞，直到消费者线程取走元素后为止；当队列容器为空时，消费者线程会被阻塞，直至队列非空时为止。\n\nBlockingQueue 的实现类有很多，比如说 ArrayBlockingQueue、PriorityBlockingQueue 等。\n\n| 实现类 | 数据结构 | 是否有界 | 特点 |\n| --- | --- | --- | --- |\n| ArrayBlockingQueue | 数组 | ✅ 有界 | 基于数组，固定容量，FIFO |\n| LinkedBlockingQueue | 链表 | ✅ 可有界（默认 Integer.MAX\\_VALUE） | 基于链表，吞吐量比 ArrayBlockingQueue 高 |\n| PriorityBlockingQueue | 堆（优先队列） | ❌ 无界 | 元素按优先级排序（非 FIFO） |\n| DelayQueue | 优先队列（基于 Delayed 接口） | ❌ 无界 | 元素到期后才能被取出 |\n| SynchronousQueue | 无缓冲 | ✅ 容量为 0 | 必须一对一交换数据，适用于高吞吐的任务提交 |\n| LinkedTransferQueue | 链表 | ❌ 无界 | 支持 tryTransfer()，数据立即交给消费者 |\n\n#### [阻塞队列是如何实现的？](#阻塞队列是如何实现的)\n\n阻塞队列使用 + Condition 来确保并发安全。\n\n以 ArrayBlockingQueue 为例，它内部维护了一个数组，使用两个指针分别指向队头和队尾。\n\nput 的时候先用 ReentrantLock 加锁，然后判断队列是否已满，如果已满就阻塞等待，否则插入元素。\n\n\n```java\nfinal ReentrantLock lock;\nprivate final Condition notEmpty;\nprivate final Condition notFull;\n\npublic void put(E e) throws InterruptedException {\n final ReentrantLock lock = this.lock;\n lock.lockInterruptibly(); // 🔹 加锁，确保线程安全\n try {\n while (count == items.length) { // 🔹 队列满，阻塞\n notFull.await();\n }\n enqueue(e); // 🔹 插入元素\n } finally {\n lock.unlock(); // 🔹 释放锁\n }\n}\n```"
+ }
+ ]
+ },
+ {
+ "id": 24,
+ "categoryName": "线程池",
+ "questions": [
+ {
+ "id": 139,
+ "question": "什么是线程池？",
+ "answer": "线程池是用来管理和复用线程的工具，它可以减少线程的创建和销毁开销。\n\n\n\n在 Java 中，ThreadPoolExecutor 是线程池的核心实现，它通过核心线程数、最大线程数、任务队列和拒绝策略来控制线程的创建和执行。\n\n举个例子：就像你开了一家餐厅，线程池就相当于固定数量的服务员，顾客（任务）来了就安排空闲的服务员（线程）处理，避免了频繁招人和解雇的成本。"
+ },
+ {
+ "id": 140,
+ "question": "你在项目中有用到线程池吗？",
+ "answer": "有，用到过很多次。\n\n比如说在当中， 我们就封装了一个异步工具类 AsyncUtil，内置了可配置的线程池，基于 ThreadPoolExecutor，适用于 IO 密集型任务。\n\n其中 corePoolSize 为 CPU 核心数的两倍，因为技术派中的大多数任务都是 IO 密集型的，maxPoolSize 设置为 50，是一个比较理想的值，尤其是在本地环境中；阻塞队列为 SynchronousQueue，意味着任务被创建后可以直接提交给等待的线程处理。"
+ },
+ {
+ "id": 141,
+ "question": "说一下线程池的工作流程？",
+ "answer": "可以简单总结为：\n\n任务提交 → 核心线程执行 → 任务队列缓存 → 非核心线程执行 → 拒绝策略处理。\n\n第一步，线程池通过 `submit()` 提交任务。\n\n\n```java\nExecutorService threadPool = Executors.newFixedThreadPool(5);\nthreadPool.submit(() -> {\n System.out.println(Thread.currentThread().getName() + \"\\t\" + \"办理业务\");\n});\n```\n\n\n第二步，线程池会先创建核心线程来执行任务。\n\n\n```java\nif (workerCountOf(c) < corePoolSize) {\n if (addWorker(command, true)) {\n return;\n }\n}\n```\n\n\n第三步，如果核心线程都在忙，任务会被放入任务队列中。\n\n\n```java\nworkQueue.offer(task);\n```\n\n\n第四步，如果任务队列已满，且当前线程数量小于最大线程数，线程池会创建新的线程来处理任务。\n\n\n```java\nif (!addWorker(command, false))\n```\n\n\n第五步，如果线程池中的线程数量已经达到最大线程数，且任务队列已满，线程池会执行拒绝策略。\n\n\n```java\nhandler.rejectedExecution(command, this);\n```\n\n\n另外一版回答。\n\n第一步，创建线程池。\n\n第二步，调用线程池的 `execute()`方法，准备执行任务。\n\n* 如果正在运行的线程数量小于 corePoolSize，那么线程池会创建一个新的线程来执行这个任务；\n* 如果正在运行的线程数量大于或等于 corePoolSize，那么线程池会将这个任务放入等待队列；\n* 如果等待队列满了，而且正在运行的线程数量小于 maximumPoolSize，那么线程池会创建新的线程来执行这个任务；\n* 如果等待队列满了，而且正在运行的线程数量大于或等于 maximumPoolSize，那么线程池会执行拒绝策略。\n\n\n\n第三步，线程执行完毕后，线程并不会立即销毁，而是继续保持在池中等待下一个任务。\n\n第四步，当线程空闲时间超出指定时间，且当前线程数量大于核心线程数时，线程会被回收。\n\n#### [能用一个生活中的例子说明下吗？](#能用一个生活中的例子说明下吗)\n\n可以。有个名叫“你一定暴富”的银行，该银行有 6 个窗口，现在开放了 3 个窗口，坐着 3 个小姐姐在办理业务。\n\n靓仔小二去办理业务，会遇到什么情况呢？\n\n第一情况，小二发现有个空闲的小姐姐，正在翘首以盼，于是小二就快马加鞭跑过去办理了。\n\n\n\n第二种情况，小姐姐们都在忙，接待员小美招呼小二去排队区区取号排队，让小二稍安勿躁。\n\n\n\n第三种情况，不仅小姐姐们都在忙，排队区也满了，小二着急用钱，于是脾气就上来了，和接待员小美对线了起来，要求开放另外 3 个空闲的窗口。\n\n小美迫于小二的压力，开放了另外 3 个窗口，排队区的人立马就冲了过去。\n\n\n\n第四种情况，6 个窗口的小姐姐都在忙，排队区也满了。。。\n\n\n\n接待员小美给了小二 4 个选项：\n\n1. 对不起，我们暴富银行系统瘫痪了。\n2. 没看忙着呢，谁叫你来办的你找谁去！\n3. 靓仔，看你比较急，去队里偷偷加个塞。\n4. 不好意思，今天没办法，你改天再来吧。\n\n这个流程和线程池不能说一模一样，简直就是一模一样：\n\n1. corePoolSize 对应营业窗口数 3\n2. maximumPoolSize 对应最大窗口数 6\n3. workQueue 对应排队区\n4. handler 对应接待员小美\n\n\n```java\nclass ThreadPoolDemo {\n public static void main(String[] args) {\n // 创建一个线程池\n ExecutorService threadPool = new ThreadPoolExecutor(\n 3, // 核心线程数\n 6, // 最大线程数\n 0, // 线程空闲时间\n TimeUnit.SECONDS, // 时间单位\n new LinkedBlockingQueue<>(10), // 等待队列\n Executors.defaultThreadFactory(), // 线程工厂\n new ThreadPoolExecutor.AbortPolicy() // 拒绝策略\n );\n // 模拟 10 个顾客来银行办理业务\n try {\n for (int i = 1; i <= 10; i++) {\n final int tempInt = i;\n threadPool.execute(() -> {\n System.out.println(Thread.currentThread().getName() + \"\\t\" + \"办理业务\" + tempInt);\n });\n }\n } catch (Exception e) {\n e.printStackTrace();\n } finally {\n threadPool.shutdown();\n }\n }\n}\n```"
+ },
+ {
+ "id": 142,
+ "question": "线程池的主要参数有哪些？",
+ "answer": "线程池有 7 个参数，需要重点关注的有核心线程数、最大线程数、等待队列、拒绝策略。\n\n\n\n**①、corePoolSize**：核心线程数，长期存活，执行任务的主力。\n\n**②、maximumPoolSize**：线程池允许的最大线程数。\n\n**③、workQueue**：任务队列，存储等待执行的任务。\n\n**④、handler**：拒绝策略，任务超载时的处理方式。也就是线程数达到 maximumPoolSiz，任务队列也满了的时候，就会触发拒绝策略。\n\n**⑤、threadFactory**：线程工厂，用于创建线程，可自定义线程名。\n\n**⑥、keepAliveTime**：非核心线程的存活时间，空闲时间超过该值就销毁。\n\n**⑦、unit**：keepAliveTime 参数的时间单位：\n\n* TimeUnit.DAYS; 天\n* TimeUnit.HOURS; 小时\n* TimeUnit.MINUTES; 分钟\n* TimeUnit.SECONDS; 秒\n* TimeUnit.MILLISECONDS; 毫秒\n* TimeUnit.MICROSECONDS; 微秒\n* TimeUnit.NANOSECONDS; 纳秒\n\n#### [能简单说一下参数之间的关系吗？](#能简单说一下参数之间的关系吗)\n\n一句话：任务优先使用核心线程执行，满了进入等待队列，队列满了启用非核心线程备用，线程池达到最大线程数量后触发拒绝策略，非核心线程的空闲时间超过存活时间就被回收。\n\n#### [核心线程数不够会怎么进行处理？](#核心线程数不够会怎么进行处理)\n\n当提交的任务数超过了 corePoolSize，但是小于 maximumPoolSize 时，线程池会创建新的线程来处理任务。\n\n当提交的任务数超过了 maximumPoolSize 时，线程池会根据拒绝策略来处理任务。\n\n#### [举个例子说一下这些参数的变化？](#举个例子说一下这些参数的变化)\n\n假设一个场景，线程池的配置如下：\n\n\n```java\ncorePoolSize = 5\nmaximumPoolSize = 10\nkeepAliveTime = 60秒\nworkQueue = LinkedBlockingQueue（容量为100）\nhandler = ThreadPoolExecutor.AbortPolicy()\n```\n\n\n**场景一**：当系统启动后，有 10 个任务提交到线程池。\n\n* 前 5 个任务会立即执行，因为核心线程数足够容纳它们。\n* 随后的 5 个任务会被放入等待队列。\n\n**场景二**：如果此时再有 100 个任务提交到线程池。\n\n* 工作队列已满，线程池会创建额外的线程来执行这些任务，直到线程总数达到 10。\n* 如果任务继续增加，超过了工作队列+最大线程数的限制，新来的任务会被 AbortPolicy 拒绝，抛出 RejectedExecutionException 异常。\n\n**场景三**：如果任务突然减少：\n\n核心线程会一直运行，而超出核心线程数的线程，会在 60 秒后回收。"
+ },
+ {
+ "id": 143,
+ "question": "线程池的拒绝策略有哪些？",
+ "answer": "有四种：\n\n* AbortPolicy：默认的拒绝策略，会抛 RejectedExecutionException 异常。\n* CallerRunsPolicy：让提交任务的线程自己来执行这个任务，也就是调用 execute 方法的线程。\n* DiscardOldestPolicy：等待队列会丢弃队列中最老的一个任务，也就是队列中等待最久的任务，然后尝试重新提交被拒绝的任务。\n* DiscardPolicy：丢弃被拒绝的任务，不做任何处理也不抛出异常。\n\n\n\n分别对应着小二去银行办理业务被经理“薄纱”的四个场景：“我们系统瘫痪了”、“谁叫你来办的你找谁去”、“看你比较急，去队里加个塞”、“今天没办法，不行你看改一天”。\n\n当线程池无法接受新的任务时，也就是线程数达到 maximumPoolSize，任务队列也满了的时候，就会触发拒绝策略。\n\n如果默认策略不能满足需求，可以通过实现 RejectedExecutionHandler 接口来定义自己的淘汰策略。例如：记录被拒绝任务的日志。\n\n\n```java\nclass CustomRejectedHandler {\n public static void main(String[] args) {\n // 自定义拒绝策略\n RejectedExecutionHandler rejectedHandler = (r, executor) -> {\n System.out.println(\"Task \" + r.toString() + \" rejected. Queue size: \" \n + executor.getQueue().size());\n };\n\n // 自定义线程池\n ThreadPoolExecutor executor = new ThreadPoolExecutor(\n 2, // 核心线程数\n 4, // 最大线程数\n 10, // 空闲线程存活时间\n TimeUnit.SECONDS,\n new ArrayBlockingQueue<>(2), // 阻塞队列容量\n Executors.defaultThreadFactory(),\n rejectedHandler // 自定义拒绝策略\n );\n\n for (int i = 0; i < 10; i++) {\n final int taskNumber = i;\n executor.execute(() -> {\n System.out.println(\"Executing task \" + taskNumber);\n try {\n Thread.sleep(1000); // 模拟任务耗时\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n });\n }\n\n executor.shutdown();\n }\n}\n```"
+ },
+ {
+ "id": 144,
+ "question": "线程池有哪几种阻塞队列？",
+ "answer": "常用的有五种，有界队列 ArrayBlockingQueue；无界队列 LinkedBlockingQueue；优先级队列 PriorityBlockingQueue；延迟队列 DelayQueue；同步队列 SynchronousQueue。\n\n\n\n①、ArrayBlockingQueue：一个有界的先进先出的阻塞队列，底层是一个数组，适合固定大小的线程池。\n\n\n```java\nArrayBlockingQueue blockingQueue = new ArrayBlockingQueue(10, true);\n```\n\n\n②、LinkedBlockingQueue：底层是链表，如果不指定大小，默认大小是 Integer.MAX\\_VALUE，几乎相当于一个无界队列。\n\n中，就使用了 LinkedBlockingQueue 来配置 RabbitMQ 的消息队列。\n\n③、PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。任务按照其自然顺序或 Comparator 来排序。\n\n适用于需要按照给定优先级处理任务的场景，比如优先处理紧急任务。\n\n④、DelayQueue：类似于 PriorityBlockingQueue，由二叉堆实现的无界优先级阻塞队列。\n\nExecutors 中的 `newScheduledThreadPool()` 就使用了 DelayQueue 来实现延迟执行。\n\n\n```java\npublic ScheduledThreadPoolExecutor(int corePoolSize) {\n super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,\n new DelayedWorkQueue());\n}\n```\n\n\n⑤、SynchronousQueue：每个插入操作必须等待另一个线程的移除操作，同样，任何一个移除操作都必须等待另一个线程的插入操作。\n\n`Executors.newCachedThreadPool()` 就使用了 SynchronousQueue，这个线程池会根据需要创建新线程，如果有空闲线程则会重复使用，线程空闲 60 秒后会被回收。\n\n\n```java\npublic static ExecutorService newCachedThreadPool() {\n return new ThreadPoolExecutor(0, Integer.MAX_VALUE,\n 60L, TimeUnit.SECONDS,\n new SynchronousQueue());\n}\n```"
+ },
+ {
+ "id": 145,
+ "question": "线程池提交 execute 和 submit 有什么区别？",
+ "answer": "execute 方法没有返回值，适用于不关心结果和异常的简单任务。\n\n\n```java\nthreadsPool.execute(new Runnable() {\n @Override public void run() {\n System.out.println(\"execute() 方法提交的任务\");\n }\n});\n```\n\n\nsubmit 有返回值，适用于需要获取结果或处理异常的场景。\n\n\n```java\nFuture future = executor.submit(harReturnValuetask);\ntry { Object s = future.get(); } \ncatch (InterruptedException e | ExecutionException e) {\n // 处理无法执行任务异常\n} finally {\n // 关闭线程池 executor.shutdown();\n}\n```"
+ },
+ {
+ "id": 146,
+ "question": "线程池怎么关闭知道吗？",
+ "answer": "可以调用线程池的`shutdown`或`shutdownNow`方法来关闭线程池。\n\nshutdown 不会立即停止线程池，而是等待所有任务执行完毕后再关闭线程池。\n\n\n```java\nExecutorService executor = Executors.newFixedThreadPool(3);\nexecutor.execute(() -> System.out.println(\"Task 1\"));\nexecutor.execute(() -> System.out.println(\"Task 2\"));\n\nexecutor.shutdown(); // 不会立刻关闭，而是等待所有任务执行完毕\n```\n\n\nshutdownNow 会尝试通过一系列动作来停止线程池，包括停止接收外部提交的任务、忽略队列里等待的任务、尝试将正在跑的任务 interrupt 中断。\n\n\n```java\nExecutorService executor = Executors.newFixedThreadPool(3);\nexecutor.execute(() -> {\n try {\n Thread.sleep(5000); // 模拟长时间运行任务\n System.out.println(\"Task executed\");\n } catch (InterruptedException e) {\n System.out.println(\"任务被中断\");\n }\n});\n\nList unexecutedTasks = executor.shutdownNow(); // 立即关闭线程池\nSystem.out.println(\"未执行的任务数: \" + unexecutedTasks.size());\n```\n\n\n需要注意的是，shutdownNow 不会真正终止正在运行的任务，只是给任务线程发送 interrupt 信号，任务是否能真正终止取决于线程是否响应 InterruptedException。"
+ },
+ {
+ "id": 147,
+ "question": "线程池的线程数应该怎么配置？",
+ "answer": "首先，我会分析线程池中执行的任务类型是 CPU 密集型还是 IO 密集型？\n\n①、对于 CPU 密集型任务，我的目标是尽量减少线程上下文切换，以优化 CPU 使用率。一般来说，核心线程数设置为处理器的核心数或核心数加一是较理想的选择。\n\n> +1 是为了以备不时之需，如果某线程因等待系统资源而阻塞时，可以有多余的线程顶上去，不至于影响整体性能。\n\n②、对于 IO 密集型任务，由于线程经常处于等待状态，等待 IO 操作完成，所以可以设置更多的线程来提高并发，比如说 CPU 核心数的两倍。\n\n\n> 核心数可以通过 Java 的`Runtime.getRuntime().availableProcessors()`方法获取。\n\n最后，我会根据业务需求和系统资源来调整线程池的其他参数，比如最大线程数、任务队列容量、非核心线程的空闲存活时间等。\n\n\n```java\nThreadPoolExecutor executor = new ThreadPoolExecutor(\n cores, // 核心线程数设置为CPU核心数\n cores * 2, // 最大线程数为核心数的两倍\n 60L, TimeUnit.SECONDS, // 非核心线程的空闲存活时间\n new LinkedBlockingQueue<>(100) // 任务队列容量\n);\n```\n\n\n#### [如何知道你设置的线程数多了还是少了？](#如何知道你设置的线程数多了还是少了)\n\n可以通过监控和调试来判断线程数是多还是少。\n\n比如说通过 top 命令观察 CPU 的使用率，如果 CPU 使用率较低，可能是线程数过少；如果 CPU 使用率接近 100%，但吞吐量未提升，可能是线程数过多。\n\n然后再通过 VisualVM 或 Arthas 分析线程运行情况，查看线程的状态、等待时间、运行时间等信息。\n\n也可以使用 jstack 命令查看线程堆栈信息，查看线程是否处于阻塞状态。\n\n\n```java\njstack | grep -A 20 \"BLOCKED\" // 查看阻塞线程\n```\n\n\n如果有大量的 BLOCKED 线程，说明线程数可能过多，竞争比较激烈。"
+ },
+ {
+ "id": 148,
+ "question": "有哪几种常见的线程池？",
+ "answer": "主要有四种：\n\n固定大小的线程池 `Executors.newFixedThreadPool(int nThreads);`，适合用于任务数量确定，且对线程数有明确要求的场景。例如，IO 密集型任务、数据库连接池等。\n\n缓存线程池 `Executors.newCachedThreadPool();`，适用于短时间内任务量波动较大的场景。例如，短时间内有大量的文件处理任务或网络请求。\n\n定时任务线程池 `Executors.newScheduledThreadPool(int corePoolSize);`，适用于需要定时执行任务的场景。例如，定时发送邮件、定时备份数据等。\n\n单线程线程池 `Executors.newSingleThreadExecutor();`，适用于需要按顺序执行任务的场景。例如，日志记录、文件处理等。"
+ },
+ {
+ "id": 149,
+ "question": "能说一下四种常见线程池的原理吗？",
+ "answer": "不管是 FixedThreadPool、CachedThreadPool，还是 SingleThreadExecutor 和 ScheduledThreadPoolExecutor，它们本质上都是 ThreadPoolExecutor 的不同配置。\n\n#### [说说固定大小线程池的原理？](#说说固定大小线程池的原理)\n\n线程池大小是固定的，`corePoolSize == maximumPoolSize`，默认使用 LinkedBlockingQueue 作为阻塞队列，适用于任务量稳定的场景，如数据库连接池、RPC 处理等。\n\n\n```java\nnew ThreadPoolExecutor(4, 4, 0L, TimeUnit.MILLISECONDS,\n new LinkedBlockingQueue<>());\n```\n\n\n新任务提交时，如果线程池有空闲线程，直接执行；如果没有，任务进入 LinkedBlockingQueue 等待。缺点是任务队列默认无界，可能导致任务堆积，甚至 OOM。\n\n\n\n#### [说说缓存线程池的原理？](#说说缓存线程池的原理)\n\n线程池大小不固定，`corePoolSize = 0`，`maximumPoolSize = Integer.MAX_VALUE`。空闲线程超过 60 秒会被销毁，使用 SynchronousQueue 作为阻塞队列，适用于短时间内有大量任务的场景。\n\n\n```java\nnew ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,\n new SynchronousQueue<>());\n```\n\n\n提交任务时，如果线程池没有空闲线程，直接新建线程执行任务；如果有，复用线程执行任务。线程空闲 60 秒后销毁，减少资源占用。缺点是线程数没有上限，在高并发情况下可能导致 OOM。\n\n\n\n#### [说说单线程线程池的原理？](#说说单线程线程池的原理)\n\n线程池只有 1 个线程，保证任务按提交顺序执行，使用 LinkedBlockingQueue 作为阻塞队列，适用于需要按顺序执行任务的场景。\n\n\n```java\nnew ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS,\n new LinkedBlockingQueue<>());\n```\n\n\n始终只创建 1 个线程，新任务必须等待前一个任务完成后才能执行，其他任务都被放入 LinkedBlockingQueue 排队执行。缺点是无法并行处理任务。\n\n\n\n#### [说说定时任务线程池的原理？](#说说定时任务线程池的原理)\n\n定时任务线程池的大小可配置，支持定时 & 周期性任务执行，使用 DelayedWorkQueue 作为阻塞队列，适用于周期性执行任务的场景。\n\n\n```java\npublic ScheduledThreadPoolExecutor(int corePoolSize) {\n super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,\n new DelayedWorkQueue());\n}\n```\n\n\n执行定时任务时，`schedule()` 方法可以将任务延迟一定时间后执行一次；`scheduleAtFixedRate()` 方法可以将任务延迟一定时间后以固定频率执行；`scheduleWithFixedDelay()` 方法可以将任务延迟一定时间后以固定延迟执行。\n\n\n\n缺点是，如果任务执行时间 `>` 设定时间间隔，scheduleAtFixedRate 可能会导致任务堆积。\n\n\n\n#### [使用无界队列的线程池会出现什么问题？](#使用无界队列的线程池会出现什么问题)\n\n如果线程获取一个任务后，任务的执行时间比较长，会导致队列的任务越积越多，导致内存使用不断飙升，最终出现 OOM。"
+ },
+ {
+ "id": 150,
+ "question": "线程池异常怎么处理知道吗？",
+ "answer": "常见的处理方式有，使用 try-catch 捕获、使用 Future 获取异常、自定义ThreadPoolExecutor 重写 afterExecute 方法、使用 UncaughtExceptionHandler 捕获异常。\n\n\n\n①、try-catch 是最简单的方法。\n\n\n```java\nexecutor.execute(() -> {\n try {\n System.out.println(\"任务开始\");\n int result = 1 / 0; // 除零异常\n } catch (Exception e) {\n System.err.println(\"捕获异常：\" + e.getMessage());\n }\n});\n```\n\n\n②、使用 Future 获取异常。\n\n\n```java\nFuture future = executor.submit(() -> {\n System.out.println(\"任务开始\");\n int result = 1 / 0; // 除零异常\n return result;\n});\n\ntry {\n future.get();\n} catch (InterruptedException | ExecutionException e) {\n System.err.println(\"捕获异常：\" + e.getMessage());\n}\n```\n\n\n③、自定义 ThreadPoolExecutor 重写 afterExecute 方法。\n\n\n```java\nThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS,\n new LinkedBlockingQueue()) {\n @Override\n protected void afterExecute(Runnable r, Throwable t) {\n super.afterExecute(r, t);\n if (t != null) {\n System.err.println(\"捕获异常：\" + t.getMessage());\n }\n }\n};\n\nexecutor.execute(() -> {\n System.out.println(\"任务开始\");\n int result = 1 / 0; // 除零异常\n});\n```\n\n\n④、使用 UncaughtExceptionHandler 捕获异常。\n\n\n```java\nThreadPoolExecutor executor = new ThreadPoolExecutor(2, 2, 0L, TimeUnit.MILLISECONDS,\n new LinkedBlockingQueue());\nexecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());\nexecutor.setThreadFactory(new ThreadFactory() {\n @Override\n public Thread newThread(Runnable r) {\n Thread thread = new Thread(r);\n thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {\n @Override\n public void uncaughtException(Thread t, Throwable e) {\n System.err.println(\"捕获异常：\" + e.getMessage());\n }\n });\n return thread;\n }\n});\n\nexecutor.execute(() -> {\n System.out.println(\"任务开始\");\n int result = 1 / 0; // 除零异常\n});\n```\n\n\n如果项目使用 `execute()`，不关心任务返回值，建议使用 UncaughtExceptionHandler：\n\n\n```java\nthread.setUncaughtExceptionHandler((t, e) -> \n System.err.println(\"线程 \" + t.getName() + \" 捕获到异常：\" + e.getMessage()));\n```\n\n\n如果项目使用 `submit()`，关心任务返回值，建议使用 Future：\n\n\n```java\nFuture future = executor.submit(task);\ntry {\n future.get();\n} catch (ExecutionException e) {\n System.err.println(\"捕获异常：\" + e.getCause());\n}\n```\n\n\n如果想要全局捕获所有任务异常，建议重写 afterExecute 方法：\n\n\n```java\nclass MyThreadPoolExecutor extends ThreadPoolExecutor {\n @Override\n protected void afterExecute(Runnable r, Throwable t) {\n if (t == null && r instanceof Future) {\n try { ((Future) r).get(); } catch (Exception e) { System.err.println(\"任务异常：\" + e.getCause()); }\n }\n }\n}\n```"
+ },
+ {
+ "id": 151,
+ "question": "能说一下线程池有几种状态吗？",
+ "answer": "有 5 种状态，它们的转换遵循严格的状态流转规则，不同状态控制着线程池的任务调度和关闭行为。\n\n状态由 RUNNING → SHUTDOWN → STOP → TIDYING → TERMINATED 依次流转。\n\n\n\n**RUNNING** 状态的线程池可以接收新任务，并处理阻塞队列中的任务；**SHUTDOWN** 状态的线程池不会接收新任务，但会处理阻塞队列中的任务；**STOP** 状态的线程池不会接收新任务，也不会处理阻塞队列中的任务，并且会尝试中断正在执行的任务；**TIDYING** 状态表示所有任务已经终止；**TERMINATED** 状态表示线程池完全关闭，所有线程销毁。\n\n| 状态 | 状态码 | 是否接收新任务 | 是否执行队列中的任务 | 是否中断正在执行的任务 |\n| --- | --- | --- | --- | --- |\n| RUNNING | 111 | ✅ 是 | ✅ 是 | ❌ 否 |\n| SHUTDOWN | 000 | ❌ 否 | ✅ 是 | ❌ 否 |\n| STOP | 001 | ❌ 否 | ❌ 否 | ✅ 是 |\n| TIDYING | 010 | ❌ 否 | ❌ 否 | ❌ 否 |\n| TERMINATED | 011 | ❌ 否 | ❌ 否 | ❌ 否 |"
+ },
+ {
+ "id": 152,
+ "question": "线程池如何实现参数的动态修改？",
+ "answer": "线程池提供的 setter 方法就可以在运行时动态修改参数，比如说 setCorePoolSize 可以用来修改核心线程数、setMaximumPoolSize 可以用来修改最大线程数。\n\n\n\n需要注意的是，调用 `setCorePoolSize()` 时如果新的核心线程数比原来的大，线程池会创建新的线程；如果更小，线程池不会立即销毁多余的线程，除非有空闲线程超过 keepAliveTime。\n\n当然了，还可以利用 Nacos 配置中心，或者实现自定义的线程池，监听参数变化去动态调整参数。\n\n"
+ },
+ {
+ "id": 153,
+ "question": "线程池调优了解吗？（补充）",
+ "answer": "\n\n首先我会根据任务类型设置核心线程数参数，比如 IO 密集型任务会设置为 CPU 核心数\\*2 的经验值。\n\n其次我会结合线程池动态调整的能力，在流量波动时通过 setCorePoolSize 平滑扩容，或者直接使用 DynamicTp 实现线程池参数的自动化调整。\n\n最后，我会通过内置的监控指标建立容量预警机制。比如通过 JMX 监控线程池的运行状态，设置阈值，当线程池的任务队列长度超过阈值时，触发告警。"
+ },
+ {
+ "id": 154,
+ "question": "线程池在使用的时候需要注意什么？（补充）",
+ "answer": "> 2024 年 03 月 16 日增补\n\n我认为有 3 个比较重要的关注点：\n\n第一个，选择合适的线程池大小。**过小**的线程池可能会导致任务一直在排队；**过大**的线程池可能会导致大家都在竞争 CPU 资源，增加上下文切换的开销\n\n第二个，选择合适的任务队列。使用有界队列可以避免资源耗尽的风险，但是可能会导致任务被拒绝；使用无界队列虽然可以避免任务被拒绝，但是可能会导致内存耗尽\n\n比如在使用 LinkedBlockingQueue 的时候，可以传入参数来限制队列中任务的数量，这样就不会出现 OOM。\n\n第三个，尽量使用自定义的线程池，而不是使用 Executors 创建的线程池。\n\n因为 newFixedThreadPool 线程池由于使用了 LinkedBlockingQueue，队列的容量默认无限大，任务过多时会导致内存溢出；newCachedThreadPool 线程池由于核心线程数无限大，当任务过多的时候会导致创建大量的线程，导致服务器负载过高宕机。"
+ },
+ {
+ "id": 155,
+ "question": "你能设计实现一个线程池吗？",
+ "answer": "线程池的主要目的是为了避免频繁地创建和销毁线程。\n\n\n\n我会把线程池看作一个工厂，里面有一群“工人”，也就是线程了，专门用来做任务。\n\n当任务来了，需要先判断有没有空闲的工人，如果有就把任务交给他们；如果没有，就把任务暂存到一个任务队列里，等工人忙完了再去处理。\n\n如果队列满了，还没有空闲的工人，就要考虑扩容，让预备的工人过来干活，但不能超过预定的最大值，防止工厂被挤爆。\n\n如果连扩容也没法解决，就需要一个拒绝策略，可能直接拒绝任务或者报个错。\n\n核心线程池类（可参考）：\n\n\n```java\nclass CustomThreadPoolExecutor {\n\n private final int corePoolSize;\n private final int maximumPoolSize;\n private final long keepAliveTime;\n private final TimeUnit unit;\n private final BlockingQueue workQueue;\n private final RejectedExecutionHandler handler;\n\n private volatile boolean isShutdown = false;\n private int currentPoolSize = 0;\n\n // 构造方法\n public CustomThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,\n BlockingQueue workQueue, RejectedExecutionHandler handler) {\n this.corePoolSize = corePoolSize;\n this.maximumPoolSize = maximumPoolSize;\n this.keepAliveTime = keepAliveTime;\n this.unit = unit;\n this.workQueue = workQueue;\n this.handler = handler;\n }\n\n // 提交任务\n public void execute(Runnable task) {\n if (isShutdown) {\n throw new IllegalStateException(\"ThreadPool is shutdown\");\n }\n\n synchronized (this) {\n // 如果当前线程数小于核心线程数，直接创建新线程\n if (currentPoolSize < corePoolSize) {\n new Worker(task).start();\n currentPoolSize++;\n return;\n }\n\n // 尝试将任务添加到队列中\n if (!workQueue.offer(task)) {\n if (currentPoolSize < maximumPoolSize) {\n new Worker(task).start();\n currentPoolSize++;\n } else {\n // 调用拒绝策略\n handler.rejectedExecution(task, null);\n }\n }\n }\n }\n\n // 关闭线程池\n public void shutdown() {\n isShutdown = true;\n }\n\n // 工作线程\n private class Worker extends Thread {\n private Runnable task;\n\n Worker(Runnable task) {\n this.task = task;\n }\n\n @Override\n public void run() {\n while (task != null || (task = getTask()) != null) {\n try {\n task.run();\n } finally {\n task = null;\n }\n }\n }\n\n // 从队列中获取任务\n private Runnable getTask() {\n try {\n return workQueue.poll(keepAliveTime, unit);\n } catch (InterruptedException e) {\n return null;\n }\n }\n }\n}\n```\n\n\n拒绝策略：\n\n\n```java\n/**\n * 拒绝策略\n */\nclass CustomRejectedExecutionHandler {\n\n // AbortPolicy 抛出异常\n public static class AbortPolicy implements RejectedExecutionHandler {\n public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {\n throw new RuntimeException(\"Task \" + r.toString() + \" rejected from \" + e.toString());\n }\n }\n\n // DiscardPolicy 什么都不做\n public static class DiscardPolicy implements RejectedExecutionHandler {\n public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {\n // Do nothing\n }\n }\n\n // DiscardOldestPolicy 丢弃队列中最旧的任务\n public static class CallerRunsPolicy implements RejectedExecutionHandler {\n public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {\n if (!e.isShutdown()) {\n r.run();\n }\n }\n }\n}\n```\n\n\n使用示例：\n\n\n```java\nclass ThreadPoolTest {\n public static void main(String[] args) {\n // 创建线程池\n CustomThreadPoolExecutor executor = new CustomThreadPoolExecutor(\n 2, 4, 10, TimeUnit.SECONDS,\n new LinkedBlockingQueue<>(2),\n new CustomRejectedExecutionHandler.AbortPolicy());\n\n // 提交任务\n for (int i = 0; i < 10; i++) {\n final int index = i;\n executor.execute(() -> {\n System.out.println(\"Task \" + index + \" is running\");\n try {\n Thread.sleep(2000);\n } catch (InterruptedException e) {\n e.printStackTrace();\n }\n });\n }\n\n // 关闭线程池\n executor.shutdown();\n }\n}\n```\n\n\n执行结果：\n\n\n\n#### [手写一个数据库连接池，可以吗？](#手写一个数据库连接池-可以吗)\n\n可以的，我的思路是这样的：数据库连接池主要是为了避免每次操作数据库时都去创建连接，因为那样很浪费资源。所以我打算在初始化时预先创建好固定数量的连接，然后把它们放到一个线程安全的容器里，后续有请求的时候就从队列里拿，使用完后再归还到队列中。\n\n\n```java\nclass SimpleConnectionPool {\n // 配置\n private String jdbcUrl;\n private String username;\n private String password;\n private int maxConnections;\n private BlockingQueue connectionPool;\n\n // 构造方法\n public SimpleConnectionPool(String jdbcUrl, String username, String password, int maxConnections) throws SQLException {\n this.jdbcUrl = jdbcUrl;\n this.username = username;\n this.password = password;\n this.maxConnections = maxConnections;\n this.connectionPool = new LinkedBlockingQueue<>(maxConnections);\n\n // 初始化连接池\n for (int i = 0; i < maxConnections; i++) {\n connectionPool.add(createNewConnection());\n }\n }\n\n // 创建新连接\n private Connection createNewConnection() throws SQLException {\n return DriverManager.getConnection(jdbcUrl, username, password);\n }\n\n // 获取连接\n public Connection getConnection(long timeout, TimeUnit unit) throws InterruptedException, SQLException {\n Connection connection = connectionPool.poll(timeout, unit); // 等待指定时间获取连接\n if (connection == null) {\n throw new SQLException(\"Timeout: Unable to acquire a connection.\");\n }\n return connection;\n }\n\n // 归还连接\n public void releaseConnection(Connection connection) throws SQLException {\n if (connection != null) {\n if (connection.isClosed()) {\n // 如果连接已关闭，创建一个新连接补充到池中\n connectionPool.add(createNewConnection());\n } else {\n // 将连接归还到池中\n connectionPool.offer(connection);\n }\n }\n }\n\n // 关闭所有连接\n public void closeAllConnections() throws SQLException {\n for (Connection connection : connectionPool) {\n if (!connection.isClosed()) {\n connection.close();\n }\n }\n }\n\n // 测试用例\n public static void main(String[] args) {\n try {\n SimpleConnectionPool pool = new SimpleConnectionPool(\n \"jdbc:mysql://localhost:3306/pai_coding\", \"root\", \"\", 5\n );\n\n // 获取连接\n Connection conn = pool.getConnection(5, TimeUnit.SECONDS);\n\n // 使用连接（示例查询）\n System.out.println(\"Connection acquired: \" + conn);\n Thread.sleep(2000); // 模拟查询\n\n // 归还连接\n pool.releaseConnection(conn);\n System.out.println(\"Connection returned.\");\n\n // 关闭所有连接\n pool.closeAllConnections();\n } catch (Exception e) {\n e.printStackTrace();\n }\n }\n}\n```\n\n\n运行结果：\n\n"
+ },
+ {
+ "id": 156,
+ "question": "线程池执行中断电了应该怎么处理？",
+ "answer": "线程池本身只能在内存中进行任务调度，并不会持久化，一旦断电，线程池里的所有任务和状态都会丢失。\n\n我会考虑以下几个方面：\n\n第一，持久化任务。可以将任务持久化到数据库或者消息队列中，等电恢复后再重新执行。\n\n第二，任务幂等性，需要保证任务是幂等的，也就是无论执行多少次，结果都一致。\n\n第三，恢复策略。当系统重启时，应该有一个恢复流程：检测上次是否有未完成的任务，将这些任务重新加载到线程池中执行，确保断电前的工作能够恢复。"
+ }
+ ]
+ },
+ {
+ "id": 25,
+ "categoryName": "并发容器和框架",
+ "questions": [
+ {
+ "id": 157,
+ "question": "Fork/Join 框架了解吗？",
+ "answer": "关于 Fork/Join 框架，我了解一些，它是 Java 7 引入的一个并行框架，主要用于分治算法的并行执行。这个框架通过将大的任务递归地分解成小任务，然后并行执行，最后再合并结果，以达到最高效率处理大量数据的目的。\n\n\n\nFork/Join 框架的核心理念是**分而治之**，将大任务拆分为多个小任务并行处理，最后再将这些小任务的结果汇总。\n\n就像是一个树形结构，根节点是一个大的任务，叶子节点是最小的子任务，每个任务都可能会被分裂成更小的子任务，直到达到某个临界点，任务再逐个执行。\n\n具体来说，Fork/Join 包括两个主要的类：\n\nForkJoinPool，一个特殊的线程池，底层使用了工作窃取算法，也就是当一个线程执行完自己的任务后，它可以窃取其他线程的任务，避免线程闲置。\n\n\n\nRecursiveTask 和 RecursiveAction，分别用于有返回值和无返回值的任务，这两个类都继承自 ForkJoinTask。\n\n\n```java\nclass ForkJoinExample {\n public static void main(String[] args) {\n int[] arr = new int[100];\n for (int i = 0; i < 100; i++) {\n arr[i] = i + 1; // 填充数据 1 到 100\n }\n\n // 创建 ForkJoinPool，默认使用可用的处理器核心数\n ForkJoinPool pool = new ForkJoinPool();\n\n // 创建 ForkJoin 任务\n SumTask task = new SumTask(arr, 0, arr.length);\n\n // 执行任务\n Integer result = pool.invoke(task);\n\n System.out.println(\"数组的和是: \" + result);\n }\n\n // 自定义任务，继承 RecursiveTask\n static class SumTask extends RecursiveTask {\n private int[] arr;\n private int start;\n private int end;\n\n public SumTask(int[] arr, int start, int end) {\n this.arr = arr;\n this.start = start;\n this.end = end;\n }\n\n @Override\n protected Integer compute() {\n if (end - start <= 10) { // 如果任务足够小，就直接计算\n int sum = 0;\n for (int i = start; i < end; i++) {\n sum += arr[i];\n }\n return sum;\n } else {\n // 否则拆分任务\n int mid = (start + end) / 2;\n SumTask left = new SumTask(arr, start, mid);\n SumTask right = new SumTask(arr, mid, end);\n\n // 分别执行子任务\n left.fork();\n right.fork();\n\n // 合并结果\n int leftResult = left.join();\n int rightResult = right.join();\n\n return leftResult + rightResult; // 汇总结果\n }\n }\n }\n}\n```"
+ }
+ ]
+ }
+ ]
+ },
+ {
+ "id": 4,
+ "topicName": "JVM",
+ "categories": [
+ {
+ "id": 26,
+ "categoryName": "引言",
+ "questions": [
+ {
+ "id": 158,
+ "question": "什么是 JVM?",
+ "answer": "JVM，也就是 Java 虚拟机，它是 Java 实现跨平台的基石。\n\n程序运行之前，需要先通过编译器将 Java 源代码文件编译成 Java 字节码文件；\n\n程序运行时，JVM 会对字节码文件进行逐行解释，翻译成机器码指令，并交给对应的操作系统去执行。\n\n\n\n这样就实现了 Java 一次编译，处处运行的特性。\n\n#### [说说 JVM 的其他特性？](#说说-jvm-的其他特性)\n\n①、JVM 可以自动管理内存，通过垃圾回收器回收不再使用的对象并释放内存空间。\n\n②、JVM 包含一个即时编译器 JIT，它可以在运行时将热点代码缓存到 codeCache 中，下次执行的时候不用再一行一行的解释，而是直接执行缓存后的机器码，执行效率会大幅提高。\n\n\n\n③、任何可以通过 Java 编译的语言，比如说 Groovy、Kotlin、Scala 等，都可以在 JVM 上运行。\n\n\n\n#### [为什么要学习 JVM？](#为什么要学习-jvm)\n\n学习 JVM 可以帮助我们开发者更好地优化程序性能、避免内存问题。\n\n比如说了解 JVM 的内存模型和垃圾回收机制，可以帮助我们更合理地配置内存、减少 GC 停顿。\n\n比如说掌握 JVM 的类加载机制可以帮助我们排查类加载冲突或异常。\n\n再比如说，JVM 还提供了很多调试和监控工具，可以帮助我们分析内存和线程的使用情况，从而解决内存溢出内存泄露等问题。"
+ },
+ {
+ "id": 159,
+ "question": "说说 JVM 的组织架构（补充）",
+ "answer": "> 增补于 2024 年 03 月 08 日。\n\nJVM 大致可以划分为三个部分：类加载器、运行时数据区和执行引擎。\n\n\n\n① 类加载器，负责从文件系统、网络或其他来源加载 Class 文件，将 Class 文件中的二进制数据读入到内存当中。\n\n② 运行时数据区，JVM 在执行 Java 程序时，需要在内存中分配空间来处理各种数据，这些内存区域按照 Java 虚拟机规范可以划分为方法区、堆、虚拟机栈、程序计数器和本地方法栈。\n\n③ 执行引擎，也是 JVM 的心脏，负责执行字节码。它包括一个虚拟处理器、即时编译器 JIT 和垃圾回收器。"
+ }
+ ]
+ },
+ {
+ "id": 27,
+ "categoryName": "内存管理",
+ "questions": [
+ {
+ "id": 160,
+ "question": "能说一下 JVM 的内存区域吗？",
+ "answer": "按照 Java 虚拟机规范，JVM 的内存区域可以细分为`程序计数器`、`虚拟机栈`、`本地方法栈`、`堆`和`方法区`。\n\n\n\n其中`方法区`和`堆`是线程共享的，`虚拟机栈`、`本地方法栈`和`程序计数器`是线程私有的。\n\n#### [介绍一下程序计数器？](#介绍一下程序计数器)\n\n程序计数器也被称为 PC 寄存器，是一块较小的内存空间。它可以看作是当前线程所执行的字节码行号指示器。\n\n#### [介绍一下 Java 虚拟机栈？](#介绍一下-java-虚拟机栈)\n\nJava 虚拟机栈的生命周期与线程相同。\n\n当线程执行一个方法时，会创建一个对应的，用于存储局部变量表、操作数栈、动态链接、方法出口等信息，然后栈帧会被压入虚拟机栈中。当方法执行完毕后，栈帧会从虚拟机栈中移除。\n\n\n\n#### [一个什么都没有的空方法，空的参数都没有，那局部变量表里有没有变量？](#一个什么都没有的空方法-空的参数都没有-那局部变量表里有没有变量)\n\n对于，由于不需要访问实例对象 this，因此在局部变量表中不会有任何变量。\n\n对于非静态方法，即使是一个完全空的方法，局部变量表中也会有一个用于存储 this 引用的变量。this 引用指向当前实例对象，在方法调用时被隐式传入。\n\n详细解释一下：\n\n比如说有这样一段代码：\n\n\n```java\npublic class VarDemo1 {\n public void emptyMethod() {\n // 什么都没有\n }\n\n public static void staticEmptyMethod() {\n // 什么都没有\n }\n}\n```\n\n\n用 `javap -v VarDemo1` 命令查看编译后的字节码，就可以在 emptyMethod 中看到这样的内容：\n\n\n\n这里的 `locals=1` 表示局部变量表有一个变量，即 this，Slot 0 位置存储了 this 引用。\n\n而在静态方法 staticEmptyMethod 中，你会看到这样的内容：\n\n\n\n这里的 locals=0 表示局部变量表为空，因为静态方法属于类级别方法，不需要 this 引用，也就没有局部变量。\n\n#### [介绍一下本地方法栈？](#介绍一下本地方法栈)\n\n本地方法栈与虚拟机栈相似，区别在于虚拟机栈是为 JVM 执行 Java 编写的方法服务的，而本地方法栈是为 Java 调用服务的，通常由 C/C++ 编写。\n\n在本地方法栈中，主要存放了 native 方法的局部变量、动态链接和方法出口等信息。当一个 Java 程序调用一个 native 方法时，JVM 会切换到本地方法栈来执行这个方法。\n\n#### [介绍一下本地方法栈的运行场景？](#介绍一下本地方法栈的运行场景)\n\n当 Java 应用需要与操作系统底层或硬件交互时，通常会用到本地方法栈。\n\n比如调用操作系统的特定功能，如内存管理、文件操作、系统时间、系统调用等。\n\n详细说明一下：\n\n比如说获取系统时间的 `System.currentTimeMillis()` 方法就是调用本地方法，来获取操作系统当前时间的。\n\n\n\n再比如 JVM 自身的一些底层功能也需要通过本地方法来实现。像 Object 类中的 `hashCode()` 方法、`clone()` 方法等。\n\n\n\n#### [native 方法解释一下？](#native-方法解释一下)\n\nnative 方法是在 Java 中通过 声明的，用于调用非 Java 语言，如 C/C++ 编写的代码。Java 可以通过 JNI，也就是 Java Native Interface 与底层系统、硬件设备、或者本地库进行交互。\n\n#### [介绍一下 Java 堆？](#介绍一下-java-堆)\n\n堆是 JVM 中最大的一块内存区域，被所有线程共享，在 JVM 启动时创建，主要用来存储 new 出来的对象。\n\n\n\nJava 中“几乎”所有的对象都会在堆中分配，堆也是管理的目标区域。\n\n从内存回收的角度来看，由于垃圾收集器大部分都是基于分代收集理论设计的，所以堆又被细分为`新生代`、`老年代`、`Eden空间`、`From Survivor空间`、`To Survivor空间`等。\n\n\n\n随着 的发展和逃逸技术的逐渐成熟，“所有的对象都会分配到堆上”就不再那么绝对了。\n\n从 JDK 7 开始，JVM 默认开启了逃逸分析，意味着如果某些方法中的对象引用没有被返回或者没有在方法体外使用，也就是未逃逸出去，那么对象可以直接在栈上分配内存。\n\n#### [堆和栈的区别是什么？](#堆和栈的区别是什么)\n\n堆属于线程共享的内存区域，几乎所有 new 出来的对象都会堆上分配，生命周期不由单个方法调用所决定，可以在方法调用结束后继续存在，直到不再被任何变量引用，最后被垃圾收集器回收。\n\n栈属于线程私有的内存区域，主要存储局部变量、方法参数、对象引用等，通常随着方法调用的结束而自动释放，不需要垃圾收集器处理。\n\n#### [介绍一下方法区？](#介绍一下方法区)\n\n方法区并不真实存在，属于 Java 虚拟机规范中的一个逻辑概念，用于存储已被 JVM 加载的类信息、常量、静态变量、即时编译器编译后的代码缓存等。\n\n在 HotSpot 虚拟机中，方法区的实现称为永久代 PermGen，但在 Java 8 及之后的版本中，已经被元空间 Metaspace 所替代。\n\n#### [变量存在堆栈的什么位置？](#变量存在堆栈的什么位置)\n\n对于局部变量，它存储在当前方法栈帧中的局部变量表中。当方法执行完毕，栈帧被回收，局部变量也会被释放。\n\n\n```java\npublic void method() {\n int localVar = 100; // 局部变量，存储在栈帧中的局部变量表里\n}\n```\n\n\n对于静态变量来说，它存储在 Java 虚拟机规范中的方法区中，在 Java 7 中是永久带，在 Java8 及以后 是元空间。\n\n\n```java\npublic class StaticVarDemo {\n public static int staticVar = 100; // 静态变量，存储在方法区中\n}\n```"
+ },
+ {
+ "id": 161,
+ "question": "说一下 JDK 1.6、1.7、1.8 内存区域的变化？",
+ "answer": "JDK 1.6 使用永久代来实现方法区：\n\n\n\nJDK 1.7 时仍然是永久带，但发生了一些细微变化，比如将字符串常量池、静态变量存放到了堆上。\n\n\n\n在 JDK 1.8 时，直接在内存中划出了一块区域，叫**元空间**，来取代之前放在 JVM 内存中的永久代，并将运行时常量池、类常量池都移动到了元空间。\n\n"
+ },
+ {
+ "id": 162,
+ "question": "为什么使用元空间替代永久代？",
+ "answer": "客观上，永久代会导致 Java 应用程序更容易出现内存溢出的问题，因为它要受到 JVM 内存大小的限制。\n\nHotSpot 虚拟机的永久代大小可以通过 `-XX：MaxPermSize` 参数来设置，32 位机器默认的大小为 64M，64 位的机器则为 85M。\n\n而 J9 和 JRockit 虚拟机就不存在这种限制，只要没有触碰到进程可用的内存上限，例如 32 位系统中的 4GB 限制，就不会出问题。\n\n主观上，当 Oracle 收购 BEA 获得了 JRockit 的所有权后，就准备把 JRockit 中的优秀功能移植到 HotSpot 中。\n\n如 Java Mission Control 管理工具。\n\n但因为两个虚拟机对方法区实现有差异，导致这项工作遇到了很多阻力。\n\n考虑到 HotSpot 虚拟机未来的发展，JDK 6 的时候，开发团队就打算放弃永久代了。\n\nJDK 7 的时候，前进了一小步，把原本放在永久代的字符串常量池、静态变量等移动到了堆中。\n\nJDK 8 就终于完成了这项移出工作，这样的好处就是，元空间的大小不再受到 JVM 内存的限制，而是可以像 J9 和 JRockit 那样，只要系统内存足够，就可以一直用。"
+ },
+ {
+ "id": 163,
+ "question": "对象创建的过程了解吗？",
+ "answer": "当我们使用 new 关键字创建一个对象时，JVM 首先会检查 new 指令的参数是否能在常量池中定位到类的符号引用，然后检查这个符号引用代表的类是否已被加载、解析和初始化。如果没有，就先执行类加载。\n\n\n\n如果已经加载，JVM 会为对象分配内存完成初始化，比如数值类型的成员变量初始值是 0，布尔类型是 false，对象类型是 null。\n\n接下来会设置对象头，里面包含了对象是哪个类的实例、对象的哈希码、对象的 GC 分代年龄等信息。\n\n最后，JVM 会执行构造方法 `