[Java后端面经]-自用牛客大中小厂一面二面三面实习or正式批-

0.记录：

A.手撕关注点：设计模式的具体实现+代码随想录+juc部分,特别是涉及到线程池的结构。

B.场景题：强化阶段需要补充，25年6月前保持八股稳定记忆和复习。

C.八股部分：

1. Mysql

2. elasticSearch

3. mongoDB

4. Redis

5. RabbitMq

6. Kafka

7. ZooKeeper

8. Netty

9. k8s and docker

1.某不知名小厂：

AOP（面向切面编程）的实现原理：

AOP 是一种编程范式，用于将横切关注点（cross-cutting concerns）从业务逻辑中分离出来。AOP 的实现原理主要依赖于代理模式。在 Java 中，AOP 通常通过以下两种方式实现：

1. 静态代理：在编译时期，通过 AOP 框架生成代理类的字节码，直接编译成 class 文件。这种方式通常通过AspectJ等工具实现。

2. 动态代理：在运行时期，通过反射机制动态创建目标对象的代理对象。Java 提供了 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口来实现动态代理。Spring AOP 就是基于动态代理实现的。

     以下是一些关于面向切面编程（AOP）的代码题目及其答案：

     题目1：编写一个简单的AOP示例，实现对某个方法执行前后添加日志功能。

     答案1：

   import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Pointcut; @Aspect public class LoggingAspect { @Pointcut("execution(* com.example.service.*.*(..))") public void businessMethods() {} @Before("businessMethods()") public void logBefore() { System.out.println("方法执行前，记录日志..."); } @After("businessMethods()") public void logAfter() { System.out.println("方法执行后，记录日志..."); } }

     题目2：编写一个AOP切面，实现对某个方法进行权限校验。

     答案2：

   import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut; @Aspect public class PermissionAspect { @Pointcut("execution(* com.example.service.*.update*(..))") public void updateMethods() {} @Before("updateMethods()") public void checkPermission() { // 假设有一个方法用于校验权限 if (!hasPermission()) { throw new RuntimeException("没有权限执行该操作！"); } } private boolean hasPermission() { // 这里是模拟权限校验，实际项目中需要根据具体业务实现 return true; } }

     题目3：编写一个AOP切面，实现对某个方法进行异常捕获并记录日志。

     答案3：

   import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang.annotation.Pointcut; @Aspect public class ExceptionHandlingAspect { @Pointcut("execution(* com.example.service.*.*(..))") public void businessMethods() {} @AfterThrowing(pointcut = "businessMethods()", throwing = "e") public void logException(Throwable e) { System.out.println("捕获到异常：" + e.getMessage()); // 这里可以将异常信息记录到日志文件中 } }

     这些题目和答案仅供参考，实际项目中可能需要根据具体需求进行调整。希望这些题目能帮助你更好地理解AOP。

1. SpringBoot 的装配过程和实现原理：

1. SpringBoot 的装配过程主要依赖于 SpringFactoriesLoader 类和 @EnableAutoConfiguration 注解。以下是简要的装配过程：

1. 启动类：SpringBoot 应用通常有一个带有 @SpringBootApplication 注解的启动类，这个注解包含了 @EnableAutoConfiguration。

2. 自动配置：@EnableAutoConfiguration 注解告诉 SpringBoot 启动时自动配置。SpringBoot 会读取 classpath 下的 META-INF/spring.factories 文件，查找并加载所有可用的配置类。

3. 条件注解：自动配置类通常会使用条件注解（如 @ConditionalOnClass、@ConditionalOnMissingBean 等）来确保只有在满足特定条件时才会应用配置。

1. 关于其他开源经历，这需要根据个人经验来回答。

1. Java 里的强引用和弱引用：

• 强引用（Strong Reference）：最常见的引用类型，如果一个对象具有强引用，那么垃圾回收器绝不会回收它。

• 弱引用（Weak Reference）：指向一个对象，但并不足以保证对象的生命周期。如果一个对象只有弱引用，那么在垃圾回收器线程扫描时，不管当前内存是否足够，都会回收该对象。

其他两种引用类型：

• 软引用（Soft Reference）：用于实现内存敏感的高速缓存。软引用指向的对象，当系统内存充足时，不会被回收；当系统内存不足时，会被回收。

• 虚引用（Phantom Reference）：也称为幽灵引用，它是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。

HashMap 多线程并发问题：

HashMap 在多线程并发情况下可能出现以下问题：

1. 数据覆盖：多个线程同时执行 put 操作，可能导致后一个线程的值覆盖前一个线程的值。

2. 死循环：在 JDK 1.7 中，HashMap 的扩容操作可能引起链表成环，导致 get 操作出现死循环。

3. 安全问题：在并发环境下，HashMap 的行为是不可预测的，可能导致数据丢失或脏读。

1. 间隙锁（Gap Lock）：

1. 间隙锁是 InnoDB 中的一种锁机制，用于解决幻读问题。它锁定一个范围，但不包括记录本身。间隙锁可以防止其他事务在这个范围内插入新的记录，从而保证了事务的隔离性。

1. 行级锁解决的问题：

1. 行级锁解决了事务在操作数据时，锁定整个数据表所带来的性能问题。通过锁定需要操作的数据行，减少了锁定的范围，提高了并发性能。

1. 可重复读的实现：

1. 可重复读是事务隔离级别的一种，InnoDB 通过以下方式实现：

1. 多版本并发控制（MVCC）：为每行数据生成多个版本，每个事务看到的数据都是快照版本。

2. 行级锁：事务操作数据时，对数据行加锁。

1. 事务的隔离级别及其保证方式：

• 读未提交（Read Uncommitted）：允许读取尚未提交的数据变更，通过共享锁实现。

• 读已提交（Read Committed）：只允许读取已经提交的数据变更，通过行级锁实现。

• 可重复读（Repeatable Read）：确保在事务内可以多次读取同样的数据结果，通过 MVCC 和行级锁实现。

• 串行化（Serializable）：确保事务可以从数据库中检索到的数据，就好像其他事务不存在一样，通过锁定整个范围的数据实现。

间隙锁的底层实现：

间隙锁是 InnoDB 通过在索引记录之间的空间插入特殊锁对象来实现的。

为什么选择短链接项目，项目难点，遇到的问题：

选择短链接项目的原因可能包括：

• 节省字符：在短信、社交媒体等场景中，短链接可以节省字符空间。

• 便于分享：短链接更易于分享和记忆。

• 数据跟踪：通过短链接可以跟踪点击量、用户行为等。

2.科大讯飞

以下是对您提出的“八股”问题的回答：

Java优势：

1. 跨平台性：Java 的口号是“一次编写，到处运行”，因为它依赖于 Java 虚拟机（JVM），可以在不同的操作系统上运行。

2. 面向对象：Java 是一种纯粹的面向对象编程语言，提供了封装、继承和多态等特性。

3. 丰富的API：Java 提供了丰富的标准类库，简化了开发过程。

4. 安全性：Java 设计了安全机制，如类加载器、字节码校验器等，以防止恶意代码。

5. 多线程支持：Java 内建了对多线程的支持，简化了并发编程。

6. 内存管理：Java 有自动垃圾回收机制，减少了内存泄漏的风险。

1. Java常用集合：

• List：ArrayList、LinkedList、Vector、Stack

• Set：HashSet、LinkedHashSet、TreeSet

• Map：HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

ArrayList和LinkedList区别和底层：

• 区别：

  • ArrayList 基于动态数组实现，LinkedList 基于双向链表实现。

  • ArrayList 随机访问效率高，LinkedList 插入和删除效率高。

• 底层：

    Set底层：

  • ArrayList 使用一个 Object 数组来存储元素。

  • LinkedList 使用节点（Node）存储元素，每个节点包含数据和指向前一个和后一个节点的引用。

• HashSet：基于 HashMap 实现，使用对象的 hashCode() 来存储值，确保唯一性。

• TreeSet：基于红黑树实现，可以确保元素处于排序状态。

红黑树讲讲：

红黑树是一种自平衡的二叉查找树，它通过以下规则保持平衡：

1. 每个节点非红即黑。

2. 根节点是黑色。

3. 所有叶子节点（NIL节点，树尾端的虚拟节点）都是黑色。

4. 每个红色节点的两个子节点都是黑色（从每个叶子到根的所有路径上不会有两个连续的红色节点）。

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

1. HashMap和TreeMap区别，底层实现：

• 区别：

  • HashMap 不保证顺序，TreeMap 根据 key 自然排序或者指定的 Comparator 进行排序。

• 底层实现：

    ConcurrentHashMap底层实现：

  • HashMap 基于哈希表实现。

  • TreeMap 基于红黑树实现。

• JDK 1.7：使用分段锁（Segment），每个 Segment 继承自 ReentrantLock，包含若干个桶（HashEntry）。

• JDK 1.8：使用 Synchronized 和 CAS 操作，以及对部分桶进行加锁，提高了并发访问的性能。

JVM内存区域：

• 程序计数器

• 虚拟机栈

• 本地方法栈

• 堆

• 方法区（JDK 1.8 之后替换为元空间）

对象创建过程：

1. 类加载检查：检查类是否已经被加载。

2. 分配内存：为对象分配内存空间。

3. 初始化零值：将分配的内存空间初始化为零值。

4. 设置对象头：设置对象所属类信息、HashCode、GC分代年龄等。

5. 执行初始化方法：执行对象的构造方法。

1. 垃圾回收过程：

1. 标记：标记出所有需要回收的对象。

2. 清除：清除被标记的对象。

3. 整理：整理内存碎片。

1. Full GC和Young GC区别：

• Young GC：发生在新生代，速度快，回收频率高。

• Full GC：发生在老年代，速度慢，回收频率低，会回收新生代和老年代。

Full GC详细流程：

1. 标记-清除（Mark-Sweep）或标记-整理（Mark-Compact）。

2. 标记整个堆中的存活对象。

3. 清除或整理非存活对象占用的空间。

1. 静态代码块存在哪里：

1. 静态代码块存储在方法区中。

1. Final修饰的变量存在哪里：

1. Final 修饰的变量存储在堆（对象实例）、栈（基本类型或局部变量）或常量池（常量）中。

1. CAP理论：

1. CAP 理论指的是在一个分布式系统中，一致性（Consistency）、可用性（Availability）、分区容错性（Partition tolerance）三者不可同时得到保证。

1. 为什么要首先保证P（Partition tolerance）：

1. 在分布式系统中，网络分区是必然发生的，因此分区容错性（P）是必须首先保证的。然后，系统设计者需要在一致性和可用性之间做出权衡，选择CP（一致性+分区容错性）或AP（可用性+分区容错性）。

3.拼多多

== 和 equals方法区别，JAVA对象是值传递还是引用传递：

• == 操作符：

  • 对于基本数据类型，比较的是两个变量的值是否相等。

  • 对于引用数据类型，比较的是两个引用是否指向同一个对象地址。

• equals 方法：

    Java 对象传递是引用传递，但传递的是引用的副本，即传递的是引用的值。因此，从效果上看，可以认为是值传递，但传递的是对象的引用。

  • 是 Object 类中的一个方法，默认情况下，比较的是两个对象的地址是否相同，但通常会被重写来比较对象的内容是否相等。

1. String用==的情况，为什么java这么设计：

• String 使用 == 的情况：当需要比较两个字符串对象的引用是否指向同一个对象时，可以使用 ==。

• 字符串常量池设计原因：

    4.1 MYSQL索引怎么存储的：

    MySQL 索引通常使用 B-Tree 数据结构进行存储，对于全文本索引则使用倒排索引。

    4.2 select * from t where a = x and b = x ； a和b都建了索引，mysql会怎么查：

    MySQL 优化器会根据索引的选择性、统计信息等因素来决定使用哪个索引。如果两个索引的选择性相同，MySQL 可能会使用其中一个索引，或者可能会使用索引合并（Index Merge）来同时使用两个索引。

  • 节省内存：字符串常量池避免了相同字符串的重复创建，节省了内存空间。

  • 提高效率：字符串是不可变对象，使用常量池可以快速比较字符串内容是否相等，不需要重新创建对象。

1. Spring在开发中有什么常用的特性，为什么这么用：

• 依赖注入（DI）：简化了组件之间的依赖关系，使得代码更加模块化，易于测试和重用。

• 面向切面编程（AOP）：允许开发者定义跨多个点的行为，如日志、事务、安全等，分离横切关注点。

• 声明式事务管理：通过注解或配置简化事务管理，使得业务代码不受事务管理代码的侵入。

• 自动配置：Spring Boot 提供自动配置，减少了手动配置的工作量，提高了开发效率。

• Spring Beans：提供了统一的bean管理方式，包括生命周期管理、作用域管理等。

1. 介绍一下GC，把gc的流程基本讲了一遍，问了有没有调参的经验（无）：

1. 垃圾回收（GC）是自动内存管理的一部分，它旨在回收不再使用的内存空间。流程包括标记、清除、整理等。

1. GC的根节点有哪些：说白了就是 全局的 局部的 本地方法里面声明的

• 虚拟机栈中引用的对象。

• 方法区中类静态属性引用的对象。

• 方法区中常量引用的对象。

• 本地方法栈中 JNI（即一般说的 Native 方法）引用的对象。

1. 反转二叉树：

public TreeNode invertTree(TreeNode root) { if (root == null) return null; TreeNode temp = root.left; root.left = invertTree(root.right); root.right = invertTree(temp); return root; }

1. 二进制加分 "101"+"10" = "111" 这种：

public String addBinary(String a, String b) { StringBuilder result = new StringBuilder(); int i = a.length() - 1, j = b.length() - 1, carry = 0; while (i >= 0 || j >= 0 || carry != 0) { int sum = carry; if (i >= 0) sum += a.charAt(i--) - '0'; if (j >= 0) sum += b.charAt(j--) - '0'; result.append(sum % 2); carry = sum / 2; } return result.reverse().toString(); }

4.百度健康

以下是对您面试问题的回答：

1. Java有哪些基本数据类型：

1. Java有8种基本数据类型：byte, short, int, long, float, double, char（16bit）, boolean(内存1bit 数组32bit)。

1. 接口和抽象类的区别：

   1. 接口只能包含抽象方法和默认方法（Java 8+），属性默认是public static final的；抽象类可以包含具体实现的方法和属性。

   2. 一个类可以实现多个接口，但只能继承一个抽象类。

   3. 接口主要用于定义公共的方法规范；抽象类可以包含具体实现，提供更灵活的抽象。

2. 介绍JVM内存模型：

1. JVM内存模型主要包括程序计数器、虚拟机栈、本地方法栈、堆和方法区（或元空间）。

1. 介绍虚拟机栈：

1. 虚拟机栈是线程私有的，每个方法执行时都会创建一个栈帧，用于存储局部变量表、操作数栈、动态链接、方法出口等信息。

1. 栈溢出和堆溢出抛出什么类型的异常：

   1. 栈溢出抛出 StackOverflowError 或 OutOfMemoryError。

   2. 堆溢出抛出 OutOfMemoryError。

2. 介绍堆和栈的内存释放机制（垃圾回收）。启动堆的时候可以指定堆大小吗？有什么参数指定的？

   1. 栈的内存释放是自动的，方法执行完毕，对应的栈帧就会出栈，内存随之释放。

   2. 堆的内存释放是通过垃圾回收器来进行的。

   3. 可以通过JVM参数 -Xms 和 -Xmx 来指定堆的初始大小和最大大小。

3. 介绍类加载的过程：

1. 包括加载、链接（验证、准备、解析）、初始化、使用、卸载。

1. 介绍Spring的ioc和aop，项目中怎么使用aop的：

   1. IOC（控制反转）是通过依赖注入实现对象之间的解耦。

   2. AOP（面向切面编程）用于在不修改源代码的情况下，添加额外的功能。

   3. 项目中可以通过定义切面（Aspect）和通知（Advice）来使用AOP，例如日志记录、事务管理。

2. Bean的作用域有哪些，项目中常用什么作用域：

   1. 作用域：singleton（单例）、prototype（原型）、request、session、application、websocket。

   2. 常用：singleton。

3. 依赖注入的方式：

1. 构造器注入、setter注入、字段注入。

1. MySQL中char和varchar的区别：

   1. char是固定长度的，varchar是可变长度的。

   2. char在存储时会用空格填充至固定长度，varchar则不会。

2. MySQL有哪些索引类型：

   1. B-Tree索引、哈希索引、全文索引、R-Tree索引。

3. 常见的join类型。使用左连接的方式连接A/B两张表，若B中某数据行缺失，但在A中改行存在，最终结果能查出来这一行数据吗？

   1. 常见的join类型：内连接（INNER JOIN）、左连接（LEFT JOIN）、右连接（RIGHT JOIN）、全连接（FULL JOIN）。

   2. 能，左连接会返回左表（A表）的所有行，即使在右表（B表）中没有匹配的行。

4. 聚簇索引和非聚簇索引有什么区别：

   1. 聚簇索引的叶节点包含了完整的数据行；非聚簇索引的叶节点包含指向数据行的指针。

5. 什么情况下应该使用索引，什么情况不该使用索引。某字段只有十种数据值，应当对其使用索引吗？

   1. 应该使用索引的情况：数据量大、经常查询的字段。

   2. 不应该使用索引的情况：数据量小、更新频繁的字段。

   3. 如果字段只有十种数据值，但数据量大且查询频繁，可以考虑使用索引。

6. redis为什么快：

   1. 基于内存、单线程模型、优化的数据结构。

7. redis怎么在项目中使用的：

   1. 用于缓存、会话管理、消息队列等。

8. redis持久化怎么实现的：

   1. RDB（快照持久化）、AOF（追加文件持久化）。

9. redis常见的数据结构。其中list是双向链表还是单向：

   1. 常见数据结构：字符串（strings）、列表（lists）、集合（sets）、有序集合（sorted sets）、哈希（hashes）。

   2. List是双向链表。

10. HTTP状态码的401和403表示什么意思：

    1. 401：未授权，请求需要用户验证。

    2. 403：禁止，服务器理解请求但拒绝执行。

11. 如何设计token？token如何鉴权？介绍项目中使用到的SA-Token框架：

    1. Token设计应该包含唯一标识、发行者、过期时间等信息，通常使用JWT（JSON Web Tokens）格式。 - 鉴权通常通过在请求头中携带Token，服务器端验证Token的有效性。 - SA-Token是一个轻量级Java权限认证框架，提供了诸如登录认证、权限验证、Session会话、单点登录、OAuth2.0、微服务网关鉴权等功能。

5.科大讯飞一面

1. Redis数据结构和缓存实现：

   1. 数据结构：

      • 字符串（Strings）：Redis中最基本的数据结构，用于存储简单的字符串、整数或者浮点数。

      • 列表（Lists）：实现了双向链表，可以用来存储一系列字符串。

      • 集合（Sets）：无序集合，元素唯一，可以用来存储不重复的字符串。

      • 有序集合（Sorted Sets）：类似于集合，但每个元素都会关联一个分数（score），可以根据分数排序。

      • 哈希（Hashes）：键值对集合，适合存储对象。

      • 位图（Bitmaps）：以位为单位进行存储，适用于布尔值存储。

      • 超日志（HyperLogLogs）：用于估计集合的基数，占用空间非常小。

      • 地理空间（Geospatial）：存储地理位置信息，可以进行半径查询等操作。

   2. 缓存实现：

      • 缓存通常用于存储热点数据，减少数据库的访问压力。

      • 实现方式通常是将数据读取和写入操作先作用于缓存，然后同步或异步更新到数据库。

   3. 缓存三兄弟问题及解决方案：

      • 缓存击穿：大量请求访问一个不存在或过期的缓存键。解决方案：使用锁或设置热点数据永不过期。

      • 缓存雪崩：大量缓存同时过期。解决方案：设置不同的过期时间，使用缓存预热。

      • 缓存穿透：查询不存在的数据。解决方案：使用布隆过滤器，返回空值并设置过期时间。

2. Redis分布式锁实现：

   1. 使用Redis的SETNX命令尝试设置一个key，如果设置成功，则表示获取到了锁。

   2. 设置锁的过期时间，防止客户端崩溃后锁无法释放。

   3. 释放锁时，使用Lua脚本确保只有锁的持有者才能释放锁，避免误释放。

   4. 可以使用Redis的Redlock算法来提高分布式锁的可靠性。

3. HashMap底层原理和扩容原理：

   1. 底层原理：

      • HashMap基于数组和链表（或红黑树）实现。

      • 通过hash函数计算key的hashCode，然后映射到数组的某个位置。

      • 如果多个key的hashCode相同，这些key会形成一个链表，称为hash冲突。

      • 当链表长度超过一定阈值时，链表会转换成红黑树，以提高查询效率。

   2. 扩容原理：

      • 当HashMap中的元素数量达到容量和负载因子（load factor）的乘积时，会进行扩容操作。

      • 扩容操作会创建一个新的更大的数组，并将旧数组中的所有元素重新哈希到新数组中。

4. JVM垃圾回收算法和回收过程：

   1. 垃圾回收算法：

      • 标记-清除（Mark-Sweep）：标记出所有活动对象，然后清除未被标记的对象。

      • 标记-整理（Mark-Compact）：标记活动对象后，将所有活动对象移动到内存的一端，清理掉边界以外的内存。

      • 复制（Copying）：将内存分为两个半区，每次只使用一个半区，在垃圾回收时，将活动对象复制到另一个半区。

   2. 回收过程：

      • 标记阶段：遍历所有可达对象，标记它们为活动状态。

      • 清除或整理阶段：清除未被标记的对象，或者在标记后移动活动对象。

5. JVM内存机制和对象垃圾判断：

   1. 内存机制：

      • 程序计数器：记录当前线程所执行的字节码行号。

      • 虚拟机栈：线程私有的，存储局部变量表、操作数栈等。

      • 本地方法栈：为虚拟机使用到的Native方法服务。

      • 堆：所有线程共享的内存区域，用于存放对象实例。

      • 方法区（或元空间）：存储已被加载的类信息、常量、静态变量等。

   2. 对象垃圾判断：

      • 使用可达性分析算法，从GC Roots（如虚拟机栈中的引用、静态变量、常量池中的引用等）开始，如果一个对象无法通过任何引用链到达，则被认为是垃圾。

6. 支付幂等性：

     6.新国都一面

   1. 幂等性指的是多次执行同一操作，结果一致，不会因为多次执行而产生副作用。

   2. 在支付系统中，可以通过以下方式实现幂等性：

      • 唯一事务号：为每次支付请求生成一个唯一的事务号，处理时检查事务号是否已存在。

      • 状态机：维护支付请求的状态，确保每个状态只被处理一次

      • 幂等接口设计：支付接口设计时保证多次请求不会导致重复支付。

      • 消息队列：将支付请求放入消息队列，消费端保证消息的幂等性。

      • 幂等数据库操作：使用数据库的事务机制或乐观锁保证数据库操作的幂等性。

   3. 自我介绍：

      1.   请简要介绍您的个人背景、工作经历、技术专长以及为什么对这个职位感兴趣。

   4. Java有哪些集合：

      1. List：ArrayList、LinkedList、Vector、Stack

      2. Set：HashSet、LinkedHashSet、TreeSet

      3. Map：HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

      4. Queue：PriorityQueue、ArrayDeque、LinkedList

      5. Collection：包含所有集合类型

      6. Deque：双端队列，如ArrayDeque、LinkedList

      7. SortedSet：有序集合，如TreeSet

      8. SortedMap：有序映射表，如TreeMap

   5. ArrayList和LinkedList区别，数组为什么能随机访问，ArrayList怎么扩容的，原数组怎么办，GC流程是怎么样的：

      1. 区别：ArrayList基于动态数组实现，LinkedList基于双向链表实现。ArrayList随机访问效率高，LinkedList插入和删除效率高。

      2. 数组为什么能随机访问：因为ArrayList底层使用数组存储元素，数组支持随机访问。

      3. ArrayList扩容：当ArrayList的容量达到当前容量和负载因子的乘积时，会进行扩容。扩容后，新数组的大小是旧数组的1.5倍。原数组不会立即被GC，因为旧数组中的元素可能还被引用。

      4. GC流程：

         • 标记阶段：标记出所有可达对象。

         • 清除阶段：清除未被标记的对象。

         • 整理阶段：移动活动对象以减少内存碎片。

   6. SpringBoot自动配置：

      1. SpringBoot通过@EnableAutoConfiguration注解启用自动配置。

      2. 它会读取classpath下的META-INF/spring.factories文件，加载所有可用的配置类。

      3. 这些配置类会被SpringBoot的自动配置机制识别，并根据条件进行相应的配置。

   7. Spring IoC：

      1. IoC（Inversion of Control，控制反转）是Spring的核心理念之一。

      2. 通过依赖注入（DI），实现了将对象的创建和绑定交给Spring容器管理。

      3. 容器在运行时动态地将依赖关系注入到对象中，而不是由程序代码直接创建和绑定依赖关系。

   8. Spring Bean生命周期，循环依赖：

      1. 生命周期：

         • 实例化（Instantiation）：当容器第一次使用Bean时，会创建一个新的Bean实例。

         • 属性设置（Population）：如果Bean需要依赖其他Bean，Spring容器会在实例化后，根据依赖注入规则，将这些依赖注入到Bean中。

         • 初始化（Initialization）：如果Bean实现了InitializingBean接口或使用@PostConstruct注解，会在属性设置后执行初始化方法。

         • 使用（Usage）：Bean可以被Spring容器或应用程序使用。

         • 销毁（Destruction）：如果Bean实现了DisposableBean接口或使用@PreDestroy注解，会在使用后被销毁。

      2. 循环依赖：如果两个或多个Bean之间存在循环依赖，Spring容器会通过三级缓存（singletonFactories、earlySingletonObjects、singletonObjects）来解决循环依赖问题。

   9. SpringMVC工作流程：

      1. 接收请求：客户端发送HTTP请求到SpringMVC前端控制器（DispatcherServlet）。

      2. 解析请求：DispatcherServlet解析请求，提取请求路径和参数。

      3. 查找HandlerMapping：根据请求路径查找对应的HandlerMapping。

      4. 执行Handler：根据HandlerMapping找到对应的Handler（通常是Controller中的方法）。

      5. 处理返回值：Handler处理请求，返回ModelAndView。

      6. 渲染视图：DispatcherServlet将ModelAndView发送给视图解析器（ViewResolver）。

      7. 响应客户端：视图解析器找到对应的视图，渲染视图并返回给客户端。

   10. JWT（JSON Web Tokens）如何工作：

       1. 三部分组成：

          • 头部（Header）：包含类型（Type）、算法（Algorithm）等信息。

          • 载荷（Payload）：包含用户信息、创建时间、过期时间等。

          • 签名（Signature）：使用HMAC算法

          • 对称加密：使用相同的密钥进行加密和解密

          • 密钥泄露怎么办：

          • 如果密钥泄露，需要立即更换密钥，并通知所有使用该密钥的服务和客户端

          • 对所有已签名的Token进行重新签名，以保证安全。

          • 确保新密钥的安全存储，防止再次泄露

          • 监控Token的使用情况，及时发现异常。

7.腾讯全栈一面

1. 算法题：

     高精度加法通常用于处理超出普通数据类型（如int, long）能表示范围的整数加法。可以使用vector或string来表示大整数，并实现加法。

   vector<int> add(vector<int>& a, vector<int>& b) { vector<int> result; int carry = 0; for (size_t i = 0; i < a.size() || i < b.size() || carry; ++i) { int sum = carry; if (i < a.size()) sum += a[i]; if (i < b.size()) sum += b[i]; result.push_back(sum % 10); // 取模得到当前位的值 carry = sum / 10; // 进位 } return result; }

       注意：这里的vector<int>是按逆序存储数字的，即vector[0]是数字的个位。

     使用栈来匹配括号是一种常见的方法。对于每个左括号，将其推入栈中；对于每个右括号，检查栈顶元素是否是相应的左括号，如果是则弹出栈顶元素，否则括号不匹配。

   public boolean isValid(String s) { Stack<Character> stack = new Stack<>(); for (char c : s.toCharArray()) { if (c == '(' || c == '{' || c == '[') { stack.push(c); } else { if (stack.isEmpty()) return false; char top = stack.pop(); if ((c == ')' && top != '(') || (c == '}' && top != '{') || (c == ']' && top != '[')) { return false; } } } return stack.isEmpty(); }

   1. 高精度加法：

   2. 括号匹配：

2. Java内容：

     数组是连续的内存空间，因此它支持通过索引快速访问元素，但插入和删除操作需要移动大量元素。链表由节点组成，每个节点包含数据和指向下一个节点的指针，因此链表插入和删除操作效率较高，但不支持快速随机访问。

     Java中的List接口有多种实现，包括ArrayList、LinkedList、Vector和Stack。ArrayList基于动态数组实现，LinkedList基于双向链表实现，Vector与ArrayList类似但线程安全，Stack是Vector的一个子类，用于实现栈数据结构。

     Java集合框架包括Set、List、Queue和Map等接口及其实现类。常见的实现类包括HashSet、TreeSet、ArrayList、LinkedList、PriorityQueue、HashMap、TreeMap等。

     可以使用TreeSet，它基于红黑树实现，能够保证元素的有序性和唯一性。

     ConcurrentHashMap是线程安全的Map实现。它通过分段锁（Segmentation）来降低锁的粒度，提高并发性能。每个Segment相当于一个小的HashMap，内部维护着一个独立的锁。扩容时，会创建一个新的数组，并将旧数组中的元素重新映射到新数组中。

   1. 2.1 数组和链表的区别：

   2. 2.2 List的实现：

   3. 2.3 常见的集合类：

   4. 2.4 存储有序且不重复的数据：

   5. 2.5 线程安全的Map及实现原理、扩容机制：

   6. 2.6 Java的锁：

      • synchronized：内置锁，可重入，通过monitor对象实现。

      • 乐观锁：通常通过版本号实现，假设没有冲突，在更新数据前检查版本号是否变化。

      • 悲观锁：如ReentrantLock，它是一个显式锁，提供比synchronized更丰富的功能，如可中断的锁获取、尝试非阻塞地获取锁等。

3. Redis内容：

   1. 3.1 Redis的数据类型：

      • String：简单的键值对。

      • List：按照插入顺序排序的字符串列表。

      • Set：无序集合，元素唯一。

      • ZSet（Sorted Set）：有序集合，每个元素都有一个分数，根据分数排序。

      • Hash：键值对的集合，适合表示对象。

   2. 3.2 分布式锁实现的原理和方案，程序崩了怎么办：

      • 原理：使用Redis的SETNX命令（现在推荐使用SET命令带NX和PX选项）来设置一个键，如果键不存在则设置成功，返回1，否则设置失败返回0。设置成功后，该键就代表获取了锁。为了防止程序崩溃导致锁无法释放，通常会为锁设置一个过期时间（使用PX参数），这样即使程序崩溃，锁也会在过期后自动释放。

• 3.3 Zset设计用户行为限流：

可以使用Redis的ZSet来设计一个简单的限流系统。为每个用户维护一个ZSet，以时间戳作为分数，将用户的行为作为成员。当用户进行操作时，可以检查ZSet中最早的行为是否在时间窗口之外，如果是，则移除，然后添加新的行为。通过这种方式，可以限制用户在特定时间窗口内的行为次数。

• 3.4 命令查看Redis信息：

使用INFO命令可以查看Redis服务器的各种信息和统计数据，如内存使用情况、客户端连接数、持久化状态等。

1. MySQL内容：

   1. SQL题目：由于没有具体的题目，无法提供具体的SQL语句。但一般来说，UPDATE语句用于修改表中的数据，GROUP BY语句用于对结果集进行分组。

   2. 索引有哪些、什么时候加索引、怎么加索引：

      • 索引类型：主键索引、唯一索引、普通索引、全文索引、复合索引等。

      • 何时加索引：在经常需要搜索、排序、分组的列上添加索引，可以提高查询效率。

      • 如何加索引：使用CREATE INDEX语句来创建索引，例如：

        CREATE INDEX idx_column1 ON table_name (column1);

   3. 如何提高查询效率：

      • 优化SQL语句，避免使用子查询和复杂的连接。

      • 使用合适的索引。

      • 减少数据检索量，如使用LIMIT限制返回结果的数量。

      • 分析查询计划，使用EXPLAIN语句查看查询的执行计划。

   4. MySQL的锁：

      • 表锁：锁定整张表，适用于MyISAM存储引擎。

      • 行锁：只锁定需要的行，适用于InnoDB存储引擎。

2. 简历上的和其它：

     创建一个Spring Boot Starter通常需要以下步骤：

   1. 创建一个包含自动配置类的项目。

   2. 在src/main/resources/META-INF/spring.factories文件中指定自动配置类。

   3. 编写自动配置逻辑，使用@Conditional注解来根据条件自动配置Bean。

     RocketMQ提供了消息幂等性保证，可以通过以下方式避免重复消费：

   1. 使用RocketMQ的幂等性插件。

   2. 在业务逻辑中实现幂等性，例如通过数据库的唯一约束或者使用Redis等缓存来记录已处理的消息ID。

     Java虚拟机中的垃圾回收主要包括以下几个阶段：

   • 标记（Marking）：标记出所有活动的对象。

   • 清除（Sweeping）：清除未被标记的对象，释放内存。

   • 整理（Compacting）：移动所有活动的对象，以减少内存碎片。

   • 分配（Allocation）：为新对象分配内存。

     线程池的主要参数包括：

   • 核心线程数（Core Pool Size）：线程池中始终存活的线程数。

   • 最大线程数（Maximum Pool Size）：线程池中允许的最大线程数。

   • 线程空闲时间（Keep Alive Time）：非核心线程空闲时的存活时间。

   • 工作队列（Work Queue）：用于存放等待执行的任务队列。

       使用线程池时，可以通过Executors工厂类来创建不同类型的线程池，或者直接使用ThreadPoolExecutor类进行更细致的配置。

   1. 通信协议、TCP的好处：

      • 可靠传输：通过序列号、确认应答、重传机制等确保数据的可靠传输。

      • 流量控制：通过滑动窗口算法来控制发送方的发送速率，避免网络拥塞。

      • 拥塞控制：通过慢启动、拥塞避免、快速重传和快速恢复等算法来避免网络拥塞。

   2. 如何自定义Starter：

   3. RocketMQ如何避免重复消费：

   4. GC垃圾回收的流程、原理：

   5. 线程池的参数有哪些，怎么用：

   6. AOP是什么，有什么用，怎么用，口述一个记录日志的使用过程，如何设计一个AOP，设计模式：

      • AOP（Aspect-Oriented Programming）：面向切面编程，是一种编程范式，用于将横切关注点（如日志、事务、安全）与业务逻辑分离。

      • 用途：用于在不修改业务逻辑代码的情况下，增加额外的功能。

      • 使用：在Spring框架中，可以通过定义切面（Aspect）、通知（Advice）、切点（Pointcut）来使用AOP。

      • 日志记录使用

过程示例：

// 定义一个切面 @Aspect @Component public class LoggingAspect { // 定义切点 @Pointcut("execution(* com.example.service.*.*(..))") public void serviceLayerMethods() {} // 定义通知 @Before("serviceLayerMethods()") public void logMethodEntry(JoinPoint joinPoint) { // 获取方法签名 String methodName = joinPoint.getSignature().getName(); // 获取方法参数 Object[] args = joinPoint.getArgs(); // 记录日志 System.out.println("Entering method: " + methodName + " with arguments " + Arrays.toString(args)); } @AfterReturning(pointcut = "serviceLayerMethods()", returning = "result") public void logMethodExit(JoinPoint joinPoint, Object result) { // 获取方法签名 String methodName = joinPoint.getSignature().getName(); // 记录日志 System.out.println("Exiting method: " + methodName + " with result " + result); } }

在这个例子中，我们定义了一个切面LoggingAspect，它包含一个切点serviceLayerMethods，这个切点匹配com.example.service包下的所有方法。我们定义了两个通知：logMethodEntry在方法执行前记录日志，logMethodExit在方法执行后记录日志。

如何设计一个AOP：

1. 确定切面：识别出需要在哪些地方添加横切关注点。

2. 定义切点：使用AspectJ表达式语言定义切点，以确定哪些方法将被拦截。

3. 实现通知：根据需要实现@Before、@After、@AfterReturning、@AfterThrowing、@Around等通知。

4. 绑定通知和切点：将通知与切点关联起来，确保在正确的时机执行通知逻辑。

1. 设计模式：

1. AOP本身就是一种设计模式，它通常与以下设计模式结合使用：

• 代理模式（Proxy Pattern）：通过代理对象来控制对原始对象的访问。

• 责任链模式（Chain of Responsibility Pattern）：通过一系列处理者来处理请求，每个处理者都有机会处理请求。

• 策略模式（Strategy Pattern）：定义了一系列算法，并将每个算法封装起来，使它们可以互相替换。

在实现AOP时，Spring框架使用了代理模式，通过代理对象来拦截方法调用，并执行通知逻辑。

以上是对AOP相关内容的详细解释。在实际应用中，AOP提供了一种非常灵活的方式来增加和维护横切关注点，从而使得业务逻辑代码更加简洁和聚焦。

8.moka一面

1. 线程池的使用与原理：

   1. 实习业务中使用线程池：在实习中，我使用线程池来处理大量的异步任务，如数据处理、文件上传下载等，以提高系统的响应速度和吞吐量。

   2. 如何复用线程池：通过配置核心线程数和最大线程数，线程池可以在不销毁核心线程的情况下复用线程，从而减少线程创建和销毁的开销。

   3. 确保线程正常执行任务：通过实现Runnable或Callable接口，并将任务提交给线程池执行。

   4. 线程池底层原理：线程池通过维护一个线程集合和一个任务队列（通常是阻塞队列）来工作。当任务提交时，线程池会根据当前线程数和任务队列的情况来决定是创建新线程还是复用已有线程。

   5. 为什么使用阻塞队列：阻塞队列可以有效地将任务的生产者和消费者分离，同时支持线程间的协作和资源的合理利用。

   6. 单线程优先级调节：在Java中，可以通过Thread.setPriority()方法调节线程的优先级，但实际效果依赖于操作系统的调度策略。

   7. 阻塞队列的作用：提供线程安全的任务队列，并支持阻塞操作，确保生产者和消费者之间的同步。

2. 线程池相关问题：

   1. 任务超时解决：可以设置任务执行的超时时间，使用Future对象来取消或检查任务的状态。

   2. CountDownLatch操作：CountDownLatch可以在任何地方调用countDown()方法来减少计数，通常在线程完成任务后调用。它是局部的，可以在局部变量中使用。

   3. 红锁算法：Redis分布式锁的红锁算法通过多个Redis实例上的锁来实现分布式环境下的锁，确保在多个节点上锁的原子性。

3. Redis分布式锁与看门狗机制：

   1. SETNX原理：SETNX（Set If Not Exists）是一个原子操作，如果键不存在，则设置键值对并返回1，否则返回0。

   2. 看门狗机制：用于自动续期锁的过期时间，防止任务未完成时锁过期。

4. 订单操作一致性：保持订单操作一致性是为了确保数据的一致性和准确性，避免出现数据冲突和错误。

5. 复用样式对象方案：可能使用的是享元模式（Flyweight Pattern），通过共享相同或相似的对象来减少内存使用。

6. 架构设计问题：为了防止静态变量被修改，可以将其设置为私有并通过公共方法提供访问，或者使用枚举类型来定义常量。

7. MQ（消息队列）相关：

   1. 基础模型：生产者-消费者模型，生产者发送消息，消费者接收消息。

   2. 消息可靠性：通过消息确认机制、持久化存储、事务消息等手段保证消息的可靠性。

   3. 消息刷盘时机：通常在消息被确认消费后或在特定时间间隔后刷盘。

   4. 死信队列：用于处理无法正常消费的消息。

   5. 延迟队列：用于延迟处理消息。

8. Java数据类型与集合：

   1. Java数据类型：基本数据类型（如int, float, double）和引用数据类型（如类、接口、数组）。

   2. 常见集合：ArrayList、LinkedList、HashMap、HashSet等。

   3. LinkedList与ArrayList效率：ArrayList在随机访问上效率更高，LinkedList在插入和删除操作上效率更高。

9. 锁结构与JUC工具类：

   1. 锁结构：如synchronized、ReentrantLock、ReadWriteLock等。

   2. JUC工具类：如Semaphore、CountDownLatch、CyclicBarrier、Exchanger等。

10. 线程安全性与锁：

      9.TP-link云计算一面

    1. 线程安全性：当多个线程访问同一资源时，不会出现数据不一致或错误的情况。

    2. 线程安全问题防范：使用同步机制、锁、原子变量等。

    3. synchronized使用：通常锁住共享资源或方法。

    4. 锁失效场景：如锁定的对象发生变化。

    5. ReentrantLock底层数据结构与原理：基于AQS（AbstractQueuedSynchronizer）实现，通过一个状态变量来控制锁的获取和释放。

    6. 锁的深入讨论：

       1. 公平锁与非公平锁：ReentrantLock的公平锁和非公平锁通过构造函数中的参数来区分。公平锁保证等待时间最长的线程先获取锁，非公平锁则允许新来的线程抢占锁。

       2. 锁竞争优先级：在非公平锁中，新来的线程可能会抢占已经在等待的线程，而在公平锁中，则是先来先服务的原则。

       3. 其他锁：除了ReentrantLock，还有ReentrantReadWriteLock、StampedLock等。

       4. 信号量保证线程安全：Semaphore可以用来限制对某个资源的访问数量，从而在一定程度上保证线程安全。

    7. MySQL的隔离级别与索引：

       1. 隔离级别：MySQL支持以下隔离级别：

          • READ UNCOMMITTED

          • READ COMMITTED

          • REPEATABLE READ（默认隔离级别）

          • SERIALIZABLE

       2. 索引创建条件：索引通常在以下情况下创建：

          • 经常用于查询的列

          • 经常用于排序或分组的列

          • 经常用于连接的列

       3. 索引创建原则：选择区分度高的列，避免过度索引，考虑索引维护的成本等。

       4. 联合索引失效：如果查询条件不满足联合索引的最左前缀原则，则可能导致索引失效。

       5. 索引下推：索引下推（Index Condition Pushdown）是MySQL的一种优化技术，它将部分过滤条件下推到存储引擎层，减少数据访问量。

    8. 线程安全与锁的深入讨论：

       1. 线程锁住的对象变化：如果锁住的对象发生变化，可能会导致锁失效或出现线程安全问题。通常应该锁住不会变化的对象，或者使用不可变对象。

       2. 如果不是锁住对象实例：可以考虑锁住一个特定的锁对象，比如Lock实例，或者使用类锁（Class对象锁）。

       3. ReentrantLock的底层数据结构与原理：ReentrantLock底层依赖于AbstractQueuedSynchronizer（AQS），它使用一个int类型的变量来表示同步状态，并通过队列来管理等待的线程。

    9. JUC工具类与线程安全：

       1. JUC工具类：Java并发工具类，如Semaphore、CountDownLatch、CyclicBarrier、Exchanger等，提供了丰富的并发编程工具。

       2. 线程安全：当多个线程访问同一个对象时，如果不需要考虑线程间的同步问题，那么这个对象就是线程安全的。

    10. synchronized的深入讨论：

        1. synchronized锁住的是什么：synchronized可以锁住代码块或方法，实际上锁住的是对象监视器（monitor），对于同步方法，锁的是当前对象实例；对于静态同步方法，锁的是类的Class对象。

        2. 锁住对象实例的变化：如果对象实例在锁住期间发生变化，可能会导致锁的粒度不正确或锁失效。

        3. 使用ReentrantLock：ReentrantLock提供了比synchronized更灵活的锁操作，可以显式地获取和释放锁，还可以实现公平锁等。

        4. MySQL索引与性能优化：

           1. 索引失效的情况：除了不满足最左前缀原则外，以下情况也可能导致索引失效：

              • 使用函数或计算表达式导致索引列无法直接使用。

              • 在WHERE子句中使用不等于（<>）或IS NULL可能会导致索引失效。

              • 使用LIKE操作符时，如果通配符不在字符串的开头，例如LIKE '%value'，可能会导致索引失效。

           2. 索引优化的原则：

              • 选择合适的索引类型，如BTREE或HASH。

              • 避免过多的索引，因为每个索引都会增加写操作的成本。

              • 定期分析查询日志和执行计划，优化慢查询。

        5. 线程锁的深入讨论：

           1. 锁的粒度：选择合适的锁粒度是重要的，过粗的锁可能导致不必要的阻塞，而过细的锁可能导致复杂的代码逻辑和性能开销。

           2. 锁竞争和线程饥饿：在高并发环境下，锁竞争可能导致某些线程长时间无法获取锁，造成线程饥饿。

           3. 锁的公平性和非公平性：公平锁虽然可以避免线程饥饿，但可能会降低系统的吞吐量；非公平锁可以提高吞吐量，但可能导致某些线程长时间等待。

        6. Java集合类的深入讨论：

           1. LinkedList和ArrayList的选择：

              • ArrayList适合随机访问操作，因为它的时间复杂度为O(1)。

              • LinkedList适合插入和删除操作，因为它的时间复杂度为O(1)。

           2. Java中复用链表的数据结构：除了LinkedList，还有LinkedHashMap和LinkedHashSet等，它们在哈希表的基础上增加了链表结构，以保持元素的插入顺序。

        7. 数据结构与算法的深入讨论：

           1. 支持二分查找的链表：理论上，链表不支持高效的二分查找，因为链表不支持随机访问。但是，可以通过平衡二叉搜索树（如AVL树或红黑树）来实现类似的功能，这些树结构可以在O(log n)时间内进行查找、插入和删除操作。

        8. 锁结构与JUC工具类的深入讨论：

           1. JUC工具类Semaphore：Semaphore可以用来实现资源池，限制同时访问资源的线程数，从而保证线程安全。

           2. CountDownLatch和CyclicBarrier：这两个类可以用于线程间的协作，CountDownLatch用于等待多个线程完成任务，而CyclicBarrier则用于多个线程在某个点上同步。

        9. 线程安全性的深入讨论：

           1. 线程安全性问题的防范：除了使用锁，还可以通过以下方式来防范线程安全性问题：

              • 使用原子变量，如AtomicInteger、AtomicReference等。

              • 使用线程安全集合类，如ConcurrentHashMap、CopyOnWriteArrayList等。

              • 使用不可变对象，如String、Integer等。

        10. synchronized的深入讨论：

            1. synchronized锁住的对象实例变化：如果对象实例在锁住期间被修改，可能会导致锁的粒度不正确或锁失效。为了避免这种情况，可以锁住一个不可变的对象或使用final关键字确保对象引用不会改变。

        11. ReentrantLock的深入讨论：

            1. ReentrantLock的公平锁和非公平锁的实现：公平锁在tryAcquire方法中会检查队列中是否有等待的线程，而非公平锁则可能会直接尝试获取锁。

            2. 锁竞争的优先级：在非公平锁中，新来的线程可能会抢占已经在等待的线程，这取决于线程调度和锁的实现。

1: Kafka的版本需要查看具体的部署配置。在Kafka 2.8.0版本之前，Kafka使用Zookeeper来维护集群的元数据。从Kafka 2.8.0开始，引入了KRaft模式（Kafka Raft Metadata mode），这是一种不依赖Zookeeper的元数据管理方式。具体使用哪种模式，需要根据部署的Kafka版本和配置来确定。

2. ISR（In-Sync Replicas）列表是Kafka为了保证数据不丢失的机制。ISR列表包含了与Kafka主题分区leader副本保持同步的所有副本。如果一个副本由于网络问题或者机器故障不能及时与leader副本同步数据，那么它将被踢出ISR列表。ISR列表的作用是确保在发生副本选举时，新的leader拥有所有已确认的消息，从而保证数据的一致性和可靠性。

3: 消费者组的Coordinator是Kafka集群中的broker。每个消费者组都会被分配一个Coordinator，通常是该消费者组第一个成员加入时所在的broker。Coordinator的选举是通过Kafka集群内部机制自动完成的，主要是基于消费者组的ID进行哈希，然后映射到对应的broker上。

4: Kafka的生产者可以通过配置来保证消息不丢失：

• At Least Once（至少一次）：确保消息不会因为网络问题等丢失，但可能会重复发送。

• At Most Once（最多一次）：消息可能会丢失，但不会重复。

Kafka默认是至少一次的保证，通过开启幂等性或者事务功能可以避免消息的重复。

5: Kafka消费者组默认是自动提交offset的，但也可以配置为手动提交。自动提交在某些情况下可能会导致消息的重复消费，而手动提交可以更精确地控制offset的提交时机。

6: Kafka消费者组可能会重复消费消息，特别是在发生再平衡时。防止重复消费可以通过以下机制：

• 使用具有唯一标识的消息。

• 在应用层面实现幂等处理。

• 手动管理offset提交，确保消息处理完成后再提交。

7: Zookeeper通过以下机制来避免脑裂：

• 使用原子广播协议（Zab协议）来保证集群中所有节点的数据一致性。

• 集群中的节点需要获得多数节点的投票才能成为新的领导者。

• 配置合适的超时时间，防止网络分区导致的服务中断。

8.: 集群的部署方式可以是虚拟机、物理机或者Kubernetes（K8s）。CI/CD流程通常用于自动化部署和管理，具体使用哪种部署方式和是否有CI/CD流程取决于公司的实际需求和技术栈。

9： Redis Cluster的槽位是一个分布式的概念，它将所有的键空间分成16384个槽位，每个Redis节点负责一部分槽位。槽位用于在多个节点之间分配和定位键值对。

10： 在Redis中可以为key设置TTL（Time To Live），这样key在指定的时间后会自动被删除。

11: KEYS命令会一次性返回所有匹配的key，可能导致服务阻塞，不适用于大数据量的场景。而SCAN命令则是通过游标分批返回匹配的key，不会阻塞服务，适用于大数据量查询。

12: Redis的持久化通常使用RDB（快照）和AOF（追加文件）两种方式。RDB+AOF混合持久化结合了两者的优点，RDB提供了数据恢复的快速性，而AOP确保了数据的持久性。这种混合模式可以在数据恢复速度和数据安全性之间取得平衡。

13: Keepalived是一个高可用解决方案，它底层使用VRRP（Virtual Router Redundancy Protocol）协议来实现。Keepalived通过模拟路由器的功能，在多个节点之间进行健康检查和虚拟IP的漂移，以确保服务的连续性。

14: 集群扩容通常涉及到以下步骤：

• 增加新的节点到集群中。

• 重新分配槽位或者数据分区，确保数据均衡分布在所有节点上。

• 更新集群配置信息，让所有节点识别新的集群拓扑。

15: 如果是自己设计权限模型，通常会包括以下方面：

• 用户认证：确保只有合法用户可以访问系统。

• 权限控制：定义不同的角色和权限，限制用户可以执行的操作。

• 访问控制：基于角色和权限的访问控制列表（ACL）。

• 审计日志：记录用户的操作行为，用于监控和审计。

10.华为od一面

1、继承和多态

继承是面向对象编程中的一个基本概念，它允许我们根据一个已有的类创建一个新的类，新类继承了原有类的属性和方法。多态是指同一个行为具有多个不同表现形式或形态的能力。在Java中，多态可以通过继承和接口实现。继承实现多态的方式是通过子类重写父类的方法，然后通过父类引用指向子类对象，调用重写的方法。

2、方法重写和重载的区别

方法重写（Overriding）是指子类重写继承自父类的方法，要求方法名、参数列表、返回类型（或子类）都相同。方法重载（Overloading）是在同一个类中存在多个方法名相同但参数列表不同的方法。重写是子类和父类之间的关系，而重载是同一个类中方法之间的关系。

3、双亲委派类加载原理

双亲委派模型是Java类加载器的一种机制。当一个类需要被加载时，类加载器首先将请求委托给父类加载器去完成，只有当父类加载器无法完成这个加载请求时，才自己去加载。这种方式防止了类的重复加载，保护了Java核心API不被随意篡改。

4、ArrayList和LinkedList底层原理

ArrayList底层是基于动态数组实现的，具有查询快、增删慢的特点。LinkedList底层是基于双向链表实现的，具有增删快、查询慢的特点。

5、增删改查效率

• 增：LinkedList的增效率高于ArrayList，因为LinkedList在添加元素时只需在链表中插入节点。

• 删：同样，LinkedList的删除效率高于ArrayList，因为不需要移动其他元素。

• 改：两者修改效率相差不大，因为都是通过索引直接访问。

• 查：ArrayList的查询效率高于LinkedList，因为ArrayList可以直接通过索引访问，而LinkedList需要从头节点开始遍历。

6、代码原子性

代码原子性指的是一个操作在执行过程中不会被中断，要么全部执行，要么都不执行。在多线程环境中，保证代码原子性是非常重要的。可以通过synchronized关键字、Lock接口及其实现类、原子类等手段保证代码的原子性。

7、ConcurrentHashMap底层实现

ConcurrentHashMap底层采用了分段锁技术，将数据分成一段段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。在Java 8中，ConcurrentHashMap摒弃了分段锁，而是采用CAS算法+Synchronized保证并发安全。

8、对try/finally/return理解

try块中存放正常执行的代码，finally块中存放必须执行的代码，如资源释放。无论try块中的代码是否抛出异常，finally块都会执行。如果在try或finally块中有return语句，finally块会在return之前执行。需要注意的是，如果finally块中也有return语句，它会覆盖try块中的return。

9、OOM内存泄露有遇到过或者解决过吗

是的，我遇到过OutOfMemoryError（OOM）问题。解决方法包括：

• 使用内存分析工具（如VisualVM、MAT）分析堆转储文件，找出内存泄漏的原因。

• 优化代码，避免创建大量无用对象。

• 增加JVM启动参数，如-Xmx、-Xms等，提高堆内存。

10、使用redis三方件缓存如何保证一致性

为了保证缓存一致性，可以采取以下措施：

• 使用发布/订阅模式，当数据库更新时，发布消息通知缓存更新或失效。

• 设置合理的缓存过期时间，让缓存数据定期失效，从数据库重新加载。

• 在更新数据库的同时，直接更新缓存。

• 使用分布式锁，确保在更新数据库和缓存时，操作的原子性。

11.小米日常实习一面

1. 项目中采用了多种设计模式，介绍一下你了解的设计模式。

设计模式是软件工程中的最佳实践，以下是一些常见的设计模式：

• 单例模式（Singleton）：确保一个类只有一个实例，并提供一个全局访问点。

• 工厂模式（Factory Method）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

• 抽象工厂模式（Abstract Factory）：创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

• 建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

• 原型模式（Prototype）：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

• 适配器模式（Adapter）：将一个类的接口转换成客户期望的另一个接口。

• 装饰器模式（Decorator）：动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式比生成子类更为灵活。

• 代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。

• 观察者模式（Observer）：对象间的一对多依赖关系，当一个对象改变状态，所有依赖于它的对象都会得到通知并自动更新。

• 策略模式（Strategy）：定义一系列的算法,把它们一个个封装起来,并且使它们可以互相替换。

1. 了解动态代理吗？了解反射吗？java 中有哪些技术应用到了反射技术。

是的，动态代理和反射都是Java的高级特性。动态代理允许在运行时创建一个实现了一组给定接口的新类。反射则是在运行时分析或调用类的属性和方法的能力。Java中用到反射的技术包括：

• 动态代理：如Java的java.lang.reflect.Proxy类。

• 框架和库：如Spring框架的依赖注入、Hibernate的ORM映射。

• 调试和分析工具：能够分析类和对象信息的工具。

1. 从输入一条 url 地址到显示，经历了什么过程。

这个过程大致包括以下步骤：

• DNS解析：将URL中的域名解析为IP地址。

• 建立连接：通过TCP三次握手与目标服务器建立连接。

• 发送HTTP请求：浏览器发送一个HTTP请求到服务器。

• 服务器处理请求：服务器接收到请求后处理并返回响应。

• 浏览器解析渲染：浏览器解析HTML文档，构建DOM树，加载CSS样式和JavaScript脚本，渲染页面。

• 关闭连接：通过TCP四次挥手断开与服务器连接。

1. GET请求和POST请求有什么不同?还有什么请求类型。

GET请求和POST请求的不同点包括：

• 用途：GET用于请求数据，POST用于提交数据。

• 数据大小：GET请求通过URL传输数据，数据大小有限制；POST请求将数据放在请求体中，理论上不受限制。

• 安全性：GET请求的数据暴露在URL中，不如POST安全。

• 缓存：GET请求可以被缓存，POST请求不会被缓存。

其他请求类型包括：

• PUT：更新资源。

• DELETE：删除资源。

• HEAD：类似于GET请求，但只返回响应头，不返回响应体。

• OPTIONS：用于描述目标资源的通信选项。

• PATCH：用于对资源进行部分更新。

1. 类加载机制。

Java类加载机制包括以下几个步骤：

• 加载：通过类加载器读取类的字节码文件，生成一个Class对象。

• 验证：确保被加载的类的正确性。

• 准备：为类变量分配内存，并设置默认初始值。

• 解析：将符号引用替换为直接引用。

• 初始化：执行类的初始化代码，包括静态代码块和对静态变量的赋值。

1. 怎么避免加载重复的类（双亲委派机制）。

Java通过双亲委派机制避免加载重复的类。当一个类需要被加载时，类加载器首先将请求委托给父类加载器去完成，只有当父类加载器无法完成这个加载请求时，才自己去加载。这样可以确保每个类只被加载一次。

1. 介绍一下 Java 堆栈。除了堆栈 JVM 内存里面还有哪些区域。

Java堆栈是线程私有的内存区域，用于存储局部变量、方法调用的上下文等。JVM内存还包括以下区域：

• 堆（Heap）：所有线程共享的内存区域，用于存储Java对象实例。

• 方法区（Method Area）：所有线程共享的内存区域，用于存储已被虚拟机加载的类信息、常量、静态变量等。

• 程序计数器（Program Counter Register）：线程私有的内存区域，存储当前线程执行的字节码指令地址。

• 本地方法栈（Native Method Stack）：为虚拟机使用到的Native方法服务。

1. 遇到过死锁吗，形成的死锁得条件

条件有哪些。

死锁是指两个或多个线程永久阻塞，每个线程等待其他线程释放资源的情况。形成死锁的四个必要条件如下：

• 互斥条件：资源不能被多个线程共同使用，只能由一个线程独占。

• 占有和等待条件：线程至少持有一个资源，并且正在等待获取其他线程持有的资源。

• 不可抢占条件：已经分配给一个线程的资源在该线程完成任务前不能被强制抢占。

• 循环等待条件：存在一种线程资源的循环等待链，每个线程都在等待下一个线程所持有的资源。

1. Java 加锁有哪些方式？ synchronized 关键字使用场景。 Java中加锁的方式主要包括：

• 内置锁（synchronized）：通过synchronized关键字实现，可以修饰方法或代码块。

• 重入锁（ReentrantLock）：实现了Lock接口，提供了比内置锁更丰富的功能，如可中断的锁获取、尝试非阻塞地获取锁等。

synchronized关键字的使用场景包括：

• 同步方法：当一个方法被声明为synchronized时，同一时间只有一个线程能够执行该方法。

• 同步代码块：当一个代码块被synchronized关键字包围时，同一时间只有一个线程能够执行该代码块。

1. 了解对象头吗？ 是的，对象头是Java对象结构的一部分，存在于每个Java对象中。对象头包含以下信息：

• Mark Word：存储对象的运行时数据，如哈希码、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID等。

• 类型指针：指向对象的类元数据的指针，确定这个对象所属的类型。

• 数组长度（如果对象是数组）：记录数组的长度。

1. 介绍一下 ConcurrentHashMap 底层原理。ConcurrentHashMap 怎么保证线程安全的（加锁方式） ConcurrentHashMap的底层原理如下：

• 分段锁：ConcurrentHashMap内部使用Segment数组结构和HashEntry数组结构，Segment继承自ReentrantLock，从而实现了分段锁。

• CAS操作：在Java 8中，ConcurrentHashMap摒弃了分段锁，而是使用CAS操作和synchronized关键字来保证线程安全。

• Node数组：存储键值对，当发生哈希冲突时，形成链表。

• 红黑树：当链表长度超过一定阈值时，链表会转换为红黑树，以提高搜索效率。

ConcurrentHashMap保证线程安全的方式：

• 在Java 7中，通过分段锁，每个Segment独立加锁，减少锁竞争。

• 在Java 8及以后版本，通过synchronized关键字加锁，但只对链表或红黑树的头节点进行加锁，这样锁的粒度更细，减少了锁的竞争。

1. 了解线程池吗？ 是的，线程池是一种管理和复用线程的机制，可以减少创建和销毁线程的开销，提高系统性能。Java中的线程池是通过java.util.concurrent包中的ExecutorService接口和其实现类（如ThreadPoolExecutor）来实现的。线程池的主要参数包括：

• 核心线程数：线程池中始终保持存活的线程数。

• 最大线程数：线程池中允许的最大线程数。

• 存活时间：当线程数大于核心线程数时，多余的空闲线程在终止前等待新任务的最长时间。

• 工作队列：用于存放待执行任务的队列。

1. 介绍一下 MySQL 数据库中的连接（JOIN） MySQL中的连接（JOIN）用于根据两个或多个表中的相关列之间的关系，从这些表中查询数据。常见的连接类型包括：

• INNER JOIN：返回两个表中都有匹配的行。

• LEFT JOIN（或LEFT OUTER JOIN）：返回左表的所有行，即使右表中没有匹配的行。

• RIGHT JOIN（或RIGHT OUTER JOIN）：返回右表的所有行，即使左表中没有匹配的行。

• FULL JOIN（或FULL OUTER JOIN）：返回左表和右表中的所有行，当某行在另一表中没有匹配时，会以NULL填充。

1. 了解过 RPC 框架吗 是的，RPC（Remote Procedure Call）框架是一种允许程序调用另一个地址空间（通常是一个远程服务器上）的过程或函数，而无需了解底层网络通信细节的技术。常见的RPC框架包括：

• gRPC：由Google开发，使用Protocol Buffers作为接口描述语言，支持多种编程语言。

• Apache Thrift：由Facebook开发，支持多种编程语言，使用自己的接口定义语言（IDL）。

• Dubbo：由阿里巴巴开发，是一款高性能、轻量级的开源Java RPC框架。

• Spring Cloud：提供了基于Spring Boot的微服务框架，其中包括服务发现、配置管理、负载均衡、断路器等组件，支持RESTful风格的RPC调用。

12.字节一面

1. B+树为什么范围查询比B树快：

1. B+树的所有数据都在叶子节点，并且叶子节点之间是通过指针相连的，这样在进行范围查询时，可以快速地通过指针遍历叶子节点，而不需要回到树的上层。而B树的非叶子节点也存储数据，范围查询时可能需要多次回到树的上层，导致查询效率降低。

1. InnoDB索引类型：

1. InnoDB支持以下几种索引类型：

   • 聚簇索引（Clustered Index）：数据行存放在索引的叶子节点上。

   • 二级索引（Secondary Index）：数据行不存放在索引的叶子节点上，而是存放指向聚簇索引的指针。

   • 全文索引（Full-Text Index）：用于全文搜索。

1. 聚簇索引和非聚簇索引的区别：

   1. 聚簇索引的叶子节点存储了数据行，而非聚簇索引的叶子节点存储的是指向数据行的指针。

   2. 一个表只能有一个聚簇索引，但可以有多个非聚簇索引。

   3. 聚簇索引通常查询效率更高，因为可以直接定位到数据行。

2. Mysql事务隔离级别，分别解决什么问题：

   1. READ UNCOMMITTED：存在脏读、不可重复读、幻读问题。

   2. READ COMMITTED：解决脏读问题，存在不可重复读、幻读问题。

   3. REPEATABLE READ（默认）：解决脏读、不可重复读问题，存在幻读问题。

   4. SERIALIZABLE：解决脏读、不可重复读、幻读问题，但性能最低。

3. 什么时候使用varchar，tinytext，Text，mediumtext，longtext：

   1. varchar：用于存储可变长度的字符串，当字符串长度不确定，但不会超过一定范围时使用。

   2. tinytext：用于存储小文本，最大长度为255字节。

   3. text：用于存储普通文本，最大长度为65,535字节。

   4. mediumtext：用于存储中等长度文本，最大长度为16,777,215字节。

   5. longtext：用于存储极大文本，最大长度为4,294,967,295字节。

4. Mediumtext和text哪个大：

1. Mediumtext比text大，mediumtext最大长度为16,777,215字节，而text最大长度为65,535字节。

1. 数据库连接池的配置有什么使用心得吗：

   1. 合理设置连接池的大小，避免过大或过小。

   2. 设置合适的连接超时时间。

   3. 监控连接池的使用情况，及时调整配置。

   4. 使用连接池时，确保正确地关闭连接。

2. Java的集合类介绍一下：

1. Java集合类主要分为以下几类：

   • List：有序、可重复的集合，如ArrayList、LinkedList。

   • Set：无序、不可重复的集合，如HashSet、TreeSet。

   • Map：键值对集合，如HashMap、TreeMap。

   • Queue：队列集合，如PriorityQueue、LinkedList。

1. map如果要实现线程安全需要怎么做：

   1. 使用Collections.synchronizedMap()方法包装一个Map。

   2. 使用ConcurrentHashMap，它提供了更好的并发性能。

2. java的运行时内存区域介绍一下：

   1. 方法区（Method Area）：存储类信息、常量、静态变量等。

   2. 堆（Heap）：存储对象实例和数组。

   3. 栈（Stack）：存储局部变量和方法调用。

   4. 程序计数器（Program Counter Register）：存储当前线程执行的字节码行号。

   5. 本地方法栈（Native Method Stack）：为本地方法服务。

3. 内存溢出了该怎么排查：

   1. 使用JVM监控工具，如VisualVM、JProfiler。

   2. 分析堆栈信息，查找大对象或内存泄漏。

   3. 使用MAT（Memory Analyzer Tool）分析堆转储文件。

4. Io分为哪几种：

   1. 同步IO和异步IO。

   2. 阻塞IO和非阻塞IO。

   3. BIO（Blocking IO）、NIO（Non-blocking IO）、AIO（Asynchronous IO）。

5. 设计一个线程安全的自增id该怎么做：

   1. 使用AtomicInteger类。

   2. 使用synchronized关键字或ReentrantLock。

   3. 使用数据库的序列或自增字段。

6. AtomicInteger怎么实现线程安全，哪些地方用到了cas：

   1. AtomicInteger通过CAS（Compare And Swap）操作实现线程安全。

   2. 在AtomicInteger的incrementAndGet、decrementAndGet等方法中用到了CAS。

7. 介绍一下BIO，NIO,AIO：

     连接，通过选择器（Selector）来实现非阻塞IO操作。

     IO多路复用发生在“等待数据准备好”的阶段。它允许一个线程同时监视多个文件描述符，一旦某个文件描述符准备好进行IO操作，线程就可以进行相应的处理，从而提高IO操作的效率。

     （17）计算机网络每层有哪些协议：

     （18）http1.0，1.1，2.0，3.0的区别：

     （19）ipv4和ipv6的区别：

   1. BIO（Blocking IO）：传统的IO模型，每个请求都会阻塞线程。

   2. NIO（Non-blocking IO）：基于事件的IO模型，使用选择器（Selector）处理多个通道（Channel）

   3. AIO（Asynchronous IO）：异步IO模型，基于事件和回调机制，不需要阻塞等待IO操作完成。

   4. （16）Io分为哪几个阶段，io多路复用发生在哪个阶段： IO操作通常分为以下阶段：

   5. 等待数据准备好

   6. 数据从内核空间拷贝到用户空间

   7. 应用层：HTTP, HTTPS, FTP, SMTP, DNS等。

   8. 传输层：TCP, UDP。

   9. 网络层：IP, ICMP, IGMP。

   10. 数据链路层：ARP, RARP, IEEE 802.3/802.11等。

   11. 物理层：各种物理硬件标准，如以太网、光纤等。

   12. HTTP/1.0：每次请求/响应后，连接关闭；没有持久连接的概念。

   13. HTTP/1.1：引入持久连接（Keep-Alive），允许在一个连接中传输多个请求/响应；引入管道化（Pipelining），但服务器可能需要按顺序响应；引入了缓存控制机制。

   14. HTTP/2.0：引入了多路复用，一个连接内可以并行处理多个请求；引入了头部压缩；支持服务器推送。

   15. HTTP/3.0：基于QUIC协议，提供了更好的性能，包括更快的连接建立、更好的拥塞控制和更强的安全性。

   16. 地址长度：IPv4地址长度为32位，IPv6地址长度为128位。

   17. 地址表示：IPv4使用点分十进制表示，IPv6使用冒号分隔的十六进制表示。

   18. 地址空间：IPv4地址空间较小，IPv6地址空间巨大，几乎可以无限分配。

   19. 配置：IPv6简化了地址配置，支持无状态地址自动配置（SLAAC）。

   20. 安全性：IPv6在设计时考虑了安全性，内置了IPsec支持。

   21. 首部格式：IPv6的首部格式更简单，提高了数据包处理效率。

13.高顿教育一二面：

Java 集合类

1. List：接口，允许重复和 null 值，常用实现类有 ArrayList 和 LinkedList。

   1. ArrayList：基于动态数组，适合查找和更新操作。

   2. LinkedList：基于双向链表，适合插入和删除操作。

2. Set：接口，不允许重复元素，常用实现类有 HashSet 和 TreeSet。

   1. HashSet：基于 HashMap，存储无序且不重复的元素。

   2. TreeSet：基于红黑树，元素有序。

3. Map：接口，存储键值对，常用实现类有 HashMap 和 TreeMap。

   1. HashMap：基于散列桶，适合快速查找。

HashMap 的实现原理

• HashMap 使用数组加链表（或红黑树）的结构存储数据。

• 通过 hash 函数计算键的 hash 值，确定元素在数组中的位置。

• 如果发生 hash 冲突，则使用链表或红黑树解决。

注解的实现原理

• 注解是通过 Java 的反射机制实现的。

• 注解本身不会做任何事情，它只是一种标记。

• 在运行时，通过反射读取注解信息，并根据这些信息执行相应的操作。

反射的原理

• 反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法。

• 反射机制主要提供以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法。

异常处理

• 使用 try-catch-finally 结构进行异常处理。

• try 块中放置可能抛出异常的代码。

• catch 块用于捕获并处理异常。

• finally 块用于执行必要的清理工作，无论是否发生异常都会执行。

数据库的最左匹配原则

• 最左匹配原则是指 SQL 语句中的 WHERE 条件按照索引的顺序从左到右进行匹配。

• 只有当查询条件满足最左边的索引字段时，索引才会被使用。

MySQL 事务的隔离级别

• READ UNCOMMITTED：读未提交

• READ COMMITTED：读已提交

• REPEATABLE READ：可重复读

• SERIALIZABLE：串行化

• 常用的是 **REPEATABLE READ**。

分布式锁的使用场景

• 当多个节点需要访问同一资源，并且要保证操作的一致性时，会使用分布式锁。

为什么用 Redis？它为什么快？

• Redis 是基于内存的键值数据库，支持多种数据结构。

• 它快的原因包括：单线程模型避免了线程切换开销，数据结构简单，直接操作内存。

如何实现分布式锁

• 可以使用 Redis 的 SETNX 命令实现分布式锁。

• 锁的键值可以是一个唯一标识，设置过期时间防止死锁。

锁失效的解决

• 可以通过守护线程定期续期来防止锁失效。

MQ 的使用

• MQ（消息队列）用于解耦系统组件，处理异步任务，实现系统间的通信。

• 使用场景包括：订单处理、日志收集等。

消息中间件的好处

• 提高系统吞吐量，降低系统耦合度，实现异步通信。

Docker 的使用

• Docker 用于创建、部署和运行容器。

• 使用 Dockerfile 定义应用环境，通过 docker build 命令构建镜像，使用 docker run 运行容器。

Shell 脚本和 Lua 脚本的使用

• Shell 脚本常用于自动化部署、日志分析等。

• Lua 脚本在某些场景下（如 Redis）用于复杂的数据处理。

杀掉进程的命令

• kill -9 <进程ID>：强制杀掉进程。

ConcurrentHashMap 底层实现

• 使用分段锁（Segment），每个 Segment 相当于一个小的 HashMap。

扩容机制

• 当元素数量达到容量阈值时，会进行扩容操作，通常是创建一个新的数组，并将旧数组中的元素重新 hash 到新数组中。

分段锁的加锁机制

• 分段锁通过 ReentrantLock 实现，每个 Segment 对应一个锁。

分段锁是否可重入

• 是的，ReentrantLock 是可重入锁。

使用 synchronized 和 CAS 的原因

• synchronized 用于保证操作的原子性。

• CAS 用于实现无锁编程，提高并发性能。

ConcurrentHashMap 使用的锁

• ConcurrentHashMap 主要是使用乐观锁（通过 CAS 操作）来提高并发性能。

ConcurrentHashMap 的锁机制

• 乐观锁（CAS）：在 ConcurrentHashMap 中，主要使用乐观锁机制，通过 Compare And Swap（CAS）操作来更新数据，以减少锁的使用，提高并发性能。

• 分段锁（Segment）：在 JDK 1.7 及之前版本中，ConcurrentHashMap 使用分段锁技术，将内部数据分为多个 Segment，每个 Segment 对应一把锁，这样可以在多线程环境下减少锁竞争。

• synchronized：在 JDK 1.8 中，ConcurrentHashMap 放弃了分段锁，转而使用 synchronized 来控制对桶（bucket）的访问，同时在扩容和统计数据时使用 CAS 操作。

ConcurrentHashMap 的扩容机制

• 动态扩容：当元素数量达到容量阈值（即装载因子乘以当前容量）时，会触发扩容操作。

• 并发扩容：ConcurrentHashMap 支持并发扩容，多个线程可以同时参与扩容过程，通过转移元素到新的桶数组来提高效率。

• 转移链表：扩容时，会遍历旧桶中的链表，并将链表中的节点重新 hash 到新桶中。

分段锁的加锁机制

• 在 JDK 1.7 中，每个 Segment 对应一个 ReentrantLock，当操作某个 Segment 时，需要先获取该 Segment 的锁。

• 分段锁使得不同的 Segment 可以并行操作，从而提高了并发性能。

分段锁是否可重入

• 是的，分段锁是基于 ReentrantLock 实现的，因此它是可重入的。

已经用了 synchronized，为什么还要用 CAS 呢？

• 性能：在某些操作中，CAS 可以比锁更高效，因为它不需要上下文切换和线程状态变更。

• 粒度：CAS 允许更细粒度的并发控制，尤其是在 ConcurrentHashMap 中，通过 CAS 可以实现无锁的更新操作。

ConcurrentHashMap 用了悲观锁还是乐观锁？

• 乐观锁：在大多数情况下，ConcurrentHashMap 使用乐观锁机制，通过 CAS 操作来更新数据。

• 悲观锁：在必要时，如初始化 Segment 或扩容时，也会使用 synchronized 来保证操作的原子性。

ConcurrentHashMap 的其他细节

• 计数：ConcurrentHashMap 使用一个 baseCount 变量和一个 counterCells 数组来记录元素的数量，以支持并发计数。

• 搜索：在进行查找操作时，ConcurrentHashMap 不会加锁，而是通过 volatile 关键字确保可见性。

• 迭代器：ConcurrentHashMap 的迭代器是弱一致性的，它们不会抛出 ConcurrentModificationException，但可能不会立即反映出其他线程的结构修改。

以上是对 ConcurrentHashMap 及相关概念的详细解释。在实际应用中，理解这些原理有助于更好地使用 Java 的并发工具类，并优化并发程序的性能。

14.25届影石正式批一面

OSI 七层模型及其作用

1. 物理层（Physical Layer）：

   1. 负责在物理媒体上实现原始的比特流传输，例如电缆、光纤。

2. 数据链路层（Data Link Layer）：

   1. 负责在相邻节点之间的可靠链接，处理帧的传输，错误检测和修正。

3. 网络层（Network Layer）：

   1. 负责数据包从源到目的地的传输和路由选择，例如 IP 协议。

4. 传输层（Transport Layer）：

   1. 负责提供端到端的数据传输服务，如 TCP 和 UDP。

5. 会话层（Session Layer）：

   1. 负责建立、管理和终止会话，例如 SSL。

6. 表示层（Presentation Layer）：

   1. 负责数据的转换、加密和压缩，确保数据在网络中传输的正确表示。

7. 应用层（Application Layer）：

   1. 为应用程序提供服务，例如 HTTP、FTP、SMTP。

HTTP 协议内容

• 请求行：包括方法、URL 和 HTTP 版本。

• 请求头：包括一系列的键值对，如 Host、User-Agent、Accept 等。

• 空行：请求头和请求体之间的分隔。

• 请求体（可选）：包含请求的数据，如 POST 请求中的表单数据。

GET 和 POST 协议

• GET：通常用于请求服务器发送资源，请求参数附加在 URL 之后，大小有限制，数据暴露在 URL 中。

• POST：通常用于提交数据给服务器，请求参数包含在请求体中，大小无限制，数据不会暴露在 URL 中。

TCP 交互过程

• 握手：三次握手建立连接（SYN, SYN-ACK, ACK）。

• 数据传输：在建立连接后进行数据传输。

• 挥手：四次挥手断开连接（FIN, ACK, FIN, ACK）。

如果是 HTTPS：

• 在 TCP 握手之后，会进行 TLS 握手，用于加密通信。

• TLS 握手：包括证书交换、密钥交换等步骤，确保加密通道的建立。

ConcurrentHashMap 底层数据结构

• ConcurrentHashMap 在 JDK 1.8 中使用数组 + 链表 + 红黑树的数据结构。

• 使用这种结构是为了在并发环境下提供更高的性能，通过分段锁或 synchronized 保证线程安全，同时使用红黑树优化搜索效率。

MySQL 索引结构

• 聚簇索引（Clustered Index）：叶节点包含完整的数据行。

• 非聚簇索引（Secondary Index）：叶节点包含索引列和指向数据行的指针。

索引结构除了 B+ 树

• 哈希索引：通过哈希表实现，适用于等值查询。

• 全文索引：用于全文搜索。

• R-Tree：用于空间数据类型。

B+ 树索引自增与随机的区别

• 自增：写入效率高，不会产生页分裂，适用于插入操作频繁的场景。

• 随机：可能导致页分裂，写入效率低，适用于更新操作频繁的场景。

索引是 ID 自身写入效率

• 如果索引是自增的 ID，写入通常会更为高效，因为新记录总是插入到 B+ 树的末尾。

B+ 树与二叉树的区别

• B+ 树：是一种多路平衡查找树，所有的数据都在叶子节点出现，叶子节点之间通过指针连接，适合大量数据的磁盘存储。

• 二叉树：每个节点最多有两个子节点，不一定是平衡的，适用于内存中数据的查找。

Redis 数据结构

• 字符串（Strings）：可以存储字符串、整数或浮点数。

• 列表（Lists）：按照插入顺序排序的字符串列表。

• 集合（Sets）：无序集合，元素具有唯一性。

• 哈希（Hashes）：键值对集合。

• 有序集合（Sorted Sets）：集合中每个元素都会关联一个分数，可以根据分数排序。

• 位图（Bitmaps）：以位为单位进行操作。

• HyperLogLog：用于估计集合的基数。

• 流（Streams）：支持消息队列功能。

B+ 树整体结构描述

B+ 树是一种自平衡的树结构，它通常用于数据库和操作系统的文件系统中。以下是 B+ 树的主要特点：

• 根节点：位于树的最顶层，可能包含多个键和子节点指针。

• 内部节点：包含多个键和子节点指针，但不像叶子节点那样存储数据记录。

• 叶子节点：包含所有数据记录，并且叶子节点之间是通过指针连接的双向链表。

• 键：每个节点包含多个键，这些键用于在树中进行查找操作。

• 平衡：在插入或删除操作后，B+ 树会进行必要的分裂或合并，以保持树的平衡。

与二叉树相比，B+ 树的优势在于：

• 节点存储更多键：B+ 树节点可以有多个子节点，这意味着树的高度比二叉树低，从而减少了磁盘 I/O 操作。

• 更好的磁盘 I/O 性能：由于节点存储了多个键，每次磁盘 I/O 可以读取更多的键，减少了查找操作的磁盘访问次数。

• 范围查询：由于叶子节点是链表，B+ 树支持高效的区间查询。

Redis 数据结构（续）

继续描述 Redis 的一些其他数据结构：

• 地理空间索引（Geospatial Indexes）：用于存储地理位置信息并进行距离和范围查询。

• 位图（Bitmaps）：可用于实现高效的位数组操作，如统计活跃用户等。

• HyperLogLog：用于估算集合中不同元素的数量，具有非常高的空间效率。

• 发布订阅（Pub/Sub）：实现消息发布和订阅功能，类似于消息队列系统。

• 事务（Transactions）：允许执行一组命令作为一个单独的操作，保证原子性。

• Lua 脚本：可以使用 Lua 脚本来编写复杂的操作，这些操作可以在 Redis 服务器端原子性地执行。

其他数据库索引结构

除了 B+ 树，数据库系统可能还会使用以下索引结构：

• 哈希索引：通过哈希表实现，适用于等值查询，但不支持范围查询。

• 全文索引：用于文本搜索，通常使用倒排索引来实现。

• R-Tree：用于空间数据类型，如地理信息系统（GIS）中的数据。

• Trie（前缀树）：用于处理字符串前缀匹配的查询，例如自动补全功能。

索引是自增与随机的适用场景

• 自增索引：

  • 适用于插入操作频繁的场景，如日志记录和时间序列数据。

  • 由于新记录总是追加到索引的末尾，可以减少页分裂，提高插入性能。

• 随机索引：

  • 适用于更新操作频繁的场景，如用户信息表，其中用户 ID 不一定是自增的。

  • 随机索引可能导致页分裂，但可以更好地处理非顺序的数据插入。

B+ 树结构下索引是 ID 自身写入效率

如果索引是基于自增的 ID，写入操作通常更高效，因为：

• 顺序写入：新记录可以直接追加到现有数据的末尾，减少了页分裂。

• 减少页分裂：减少了因插入操作导致的页分裂，从而提高了写入效率。

B+ 树与二叉树的区别（续）

• 节点度数：B+ 树的节点可以有多个子节点（度数大于 2），而二叉树的节点最多有两个子节点。

• 数据存储：B+ 树只在叶子节点存储数据，而二叉树可能在内部节点也存储数据。

• 搜索效率：B+ 树由于节点度数高，通常树的高度比二叉树低，从而提高了搜索效率。

• 范围查询：B+ 树支持高效的区间查询，而二叉树不支持。

这些概念和结构是数据库和缓存系统设计中的关键组成部分，理解它们可以帮助开发人员在设计高效的数据存储和检索系统时做出更好的决策。

15.得物后端Java一面

gRPC代替HTTP的时间降低取决于多种因素，包括网络条件、数据大小、请求的复杂性等。gRPC使用二进制协议（如Protocol Buffers）进行序列化和反序列化，并且通常使用HTTP/2进行传输，这可以显著减少数据传输的大小和延迟。相比HTTP/1.1，gRPC可以降低大约30%到50%的延迟，但这只是一个大致的范围，具体数值会根据实际情况有所不同。

gRPC的调用过程

1. 服务定义：使用Protocol Buffers定义服务接口和消息类型。

2. 服务端实现：服务端实现定义的接口，并启动gRPC服务器。

3. 客户端调用：

   1. 客户端使用gRPC stub（客户端存根）来调用服务端的方法。

   2. 客户端通过服务发现机制（如DNS、Consul、Zookeeper等）获取到服务端地址。

   3. 客户端与服务端建立HTTP/2连接。

   4. 客户端发送RPC请求，服务端接收请求并处理。

   5. 服务端返回响应给客户端。

RPC底层通信

RPC（远程过程调用）底层通信通常涉及以下步骤：

1. 序列化：将请求对象转换为字节流。

2. 网络传输：通过网络将序列化后的字节流传送到服务端。

3. 反序列化：服务端接收到字节流后，将其还原为请求对象。

4. 执行：服务端执行请求指定的方法。

5. 序列化响应：将执行结果序列化。

6. 网络传输响应：将序列化后的响应传回客户端。

7. 反序列化响应：客户端接收到响应字节流后，将其还原为结果对象。

Netty

Netty是一个异步事件驱动的网络应用框架，用于快速开发高性能、高可靠性的网络服务器和客户端程序。它提供了多路复用、事件通知和线程管理等功能。

多路复用模型

多路复用模型是指单个线程可以同时处理多个网络连接（或文件描述符）的I/O事件。在Java中，NIO（非阻塞I/O）提供了Selector组件，用于实现多路复用。

TCP粘包和拆包问题

TCP粘包和拆包问题可以通过以下方法解决：

• 固定长度：每个数据包大小固定。

• 分隔符：在每个数据包末尾添加特殊分隔符。

• 长度字段：在数据包头部添加表示数据长度的字段。

TCP拥塞控制

TCP拥塞控制是TCP协议用来避免网络拥塞的一系列算法，常见的算法包括：

• 慢启动：逐渐增加发送窗口的大小。

• 拥塞避免：当拥塞窗口接近阈值时，线性增加窗口大小。

• 快速重传：在接收方连续收到三个重复的ACK时，无需等待重传计时器到期，立即重传丢失的报文段。

• 快速恢复：在快速重传后，不是立即执行慢启动，而是将阈值设置为当前窗口的一半，然后执行拥塞避免算法。

常见垃圾回收算法

• 标记-清除：标记出所有活动的对象，然后清除未被标记的对象。

• 标记-整理：标记出所有活动的对象，然后将所有活动对象移动到内存的一端，清除边界以外的内存。

• 复制：将内存分为两个半区，每次只使用一个，在垃圾回收时，将活动的对象复制到另一个半区，清理掉旧半区。

垃圾标记和三色标记法

垃圾标记是通过可达性分析来确定哪些对象是垃圾。三色标记法将对象分为三种颜色：

• 白色：未被访问过的对象。

• 灰色：正在访问的对象。

• 黑色：已经访问完毕的对象。

记忆集

记忆集是一种用于记录从非收集区域指向收集区域指针的数据结构，它用于处理跨代引用问题。

G1垃圾回收器

G1垃圾回收器通过划分多个区域（Region）来避免全堆扫描，使用Remembered Sets来解决跨代引用问题。

ZGC

ZGC（Z Garbage Collector）是一种低延迟垃圾回收器，它使用染色指针和读屏障技术来实现。

染色指针

染色指针是ZGC中的一种技术，它将指针分为多个部分，其中包括标记位，用于表示对象的存活状态。

常见限流算法

• 令牌桶：按照固定的速率生成令牌，请求需要消耗令牌才能执行。

• 漏桶：请求按照固定的速率流出，如果请求过多，会暂存在漏桶中。

Redis分布式锁

Redis分布式锁是用于在分布式系统中保持数据一致性的锁机制。

如果分布式锁到期了但没有完成锁内部的逻辑调用，可以采取以下措施：

1. 锁续期：在锁快要到期时，由持有锁的进程或线程自动延长锁的过期时间。

2. 超时重试：当锁过期后，尝试重新获取锁，可能需要配合额外的逻辑来处理并发冲突。

3. 业务补偿：如果无法重新获取锁，执行一些补偿逻辑，比如回滚操作或者标记任务为失败，稍后重新执行。

Redis分布式锁能实现可重入吗？

是的，Redis分布式锁可以实现可重入。这通常通过在锁的值中存储线程或进程的标识以及重入次数来实现。每次进入锁时，增加重入次数；每次退出锁时，减少重入次数。只有当重入次数为零时，锁才会被释放。

了解Redlock吗？Redlock主要解决哪些问题？

Redlock是一个基于Redis的分布式锁算法，由Redis的作者提出。它主要解决了以下问题：

1. 容错性：即使部分Redis节点失败，锁仍然有效。

2. 安全性：确保锁在任意时间点只有一个客户端持有。

3. 可用性：即使系统部分不可用，客户端仍然能够获取和释放锁。

Redlock通过在多个独立的Redis节点上获取锁来实现高可用性和容错性。

JDK框架中的ReentrantLock应用多吗？

是的，ReentrantLock在JDK框架中应用广泛，尤其是在并发编程中。它是一个可重入的互斥锁，提供了比synchronized更丰富的功能，如可中断的锁获取、尝试非阻塞地获取锁以及支持多个条件变量。

了解ReentrantLock内部的实现吗？

ReentrantLock内部主要基于AQS（AbstractQueuedSynchronizer）实现。它维护了一个同步状态来表示锁的持有情况，并使用一个FIFO队列来管理等待获取锁的线程。ReentrantLock支持公平锁和非公平锁两种模式：

• 公平锁：按照线程请求锁的顺序来获取锁。

• 非公平锁：允许线程插队获取锁，可能会造成线程饥饿。

了解synchronized的锁升级过程吗？

synchronized的锁升级过程如下：

1. 偏向锁：当锁第一次被线程获取时，会设置为偏向模式，假设将来只有该线程会访问该锁，减少不必要的同步开销。

2. 轻量级锁：当偏向锁的锁有竞争时，会升级为轻量级锁，通过CAS操作来避免线程阻塞。

3. 重量级锁：当轻量级锁竞争激烈时，会升级为重量级锁，此时会涉及操作系统层面的线程阻塞和唤醒。

能简单介绍一下轻量级锁的实现吗？轻量级锁更新的是哪个对象的哪个字？

轻量级锁通过CAS操作尝试将锁对象的对象头中的Mark Word更新为指向锁记录的指针。轻量级锁更新的是持有锁的线程栈中的Lock Record（锁记录）的指针，这个指针指向锁对象的对象头。

了解Mark Word吗？

Mark Word是Java对象头的一部分，用于存储对象的运行时数据，如对象的哈希码、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。

你对交易平台了解吗？从导购到订单再到履约的整个过程是怎样的？

交易平台通常涉及以下过程：

1. 导购：用户通过网站或APP浏览商品，系统推荐商品，提供商品信息、评价、价格比较等。

2. 下单：用户选择商品，加入购物车，确认订单信息，包括商品、数量、价格、收货地址等，然后提交订单。

3. 支付：用户选择支付方式，完成支付操作。

4. 订单处理：系统确认支付后，处理订单，包括库存扣减、订单状态更新等。

5. 履约：商家根据订单信息进行商品打包、发货，物流公司负责配送至用户手中。

6. 售后：用户收到商品后，如有问题，可以通过平台进行售后服务，如退换货、投诉等。

整个交易过程需要多个系统的协同工作，包括商品管理系统、订单系统、支付系统、库存系统、物流系统等，以确保交易的顺利进行。

16.高德出行一面

1. 自我介绍

2. mysql引擎了解吗

是的，我对MySQL的引擎有所了解。MySQL支持多种存储引擎，常见的有InnoDB、MyISAM、Memory等。

1. 你觉得不同引擎有什么区别？我们经常用innodb，innodb好在哪里？我们一般什么时候不用innodb？

不同引擎的主要区别在于它们支持的特性、性能和用途。以下是InnoDB与其他引擎的一些对比：

• InnoDB支持事务、行级锁定和外键，适合处理高并发、需要事务支持的场景。

• MyISAM不支持事务和行级锁定，但查询速度快，适合读多写少的场景。可以加锁，但是全表锁，锁的粒度较粗

• Memory存储引擎将数据存储在内存中，读写速度非常快，但数据易丢失，适用于临时表或缓存表。

InnoDB的优点：

• 支持事务，保证数据的一致性。

• 支持行级锁定，减少锁争用，提高并发性能。

• 支持外键，维护数据完整性。

• 有着较好的崩溃恢复能力。

不使用InnoDB的场景：

• 数据读多写少，且不需要事务支持时，可以考虑使用MyISAM。

• 需要高速读写的临时数据，可以考虑使用Memory。

1. mysql死锁了解吗？

是的，我了解MySQL死锁。死锁是指两个或多个事务在执行过程中，因争夺资源而造成的一种互相等待的现象，如果没有外力干预，这些事务都无法继续执行。

1. 自己建张表，写两个事务，写出死锁的例子。

CREATE TABLE account ( id INT PRIMARY KEY, balance DECIMAL(10, 2) ); -- 事务A START TRANSACTION; UPDATE account SET balance = balance - 100 WHERE id = 1; UPDATE account SET balance = balance + 100 WHERE id = 2; COMMIT; -- 事务B START TRANSACTION; UPDATE account SET balance = balance - 100 WHERE id = 2; UPDATE account SET balance = balance + 100 WHERE id = 1; COMMIT;

这两个事务如果同时执行，可能会发生死锁。

1. 你觉得有个服务有2个接口，调用这两个事务，这会发生什么？业务层上监控的指标会有什么变化，能想到啥说啥？你觉得XX指标变化的量级会是多少？

如果服务中的两个接口分别调用这两个事务，可能会发生以下情况：

• 事务执行成功率降低，因为可能会发生死锁导致事务回滚。

• 服务响应时间变长，因为死锁检测和处理需要时间。

• 数据库CPU使用率上升，因为死锁检测和处理会增加CPU开销。

• 业务层的错误日志可能会增加，记录死锁相关的错误信息。

具体指标变化的量级取决于业务的具体情况，如请求量、并发度等，难以给出精确数值。

1. 业务上一般怎么处理mysql死锁？

处理MySQL死锁的方法有：

• 优化索引，减少锁的范围。

• 尽量减少长事务，缩短事务的执行时间。

• 调整事务隔离级别，减少锁的竞争。

• 在业务层捕获死锁异常，并进行重试。

1. 现在一个服务，有10个接口，其中2个高qps（1w）的接口分布调了上面的两个事务，其他8个接口（qps1k）也读这个库，那8个接口你觉得监控指标会发生什么变化？你觉得XX指标变化的量级会是多少？

在这种情况下，其他8个读操作的接口监控指标可能会发生以下变化：

• 响应时间可能会增加，因为高QPS的事务可能导致锁等待。

• 错误率可能会上升，因为读操作可能会受到死锁检测的影响。

具体指标变化的量级难以预测，但可以预期的是，响应时间可能会有所增加，错误率可能会有所上升。

1. 它在mysql底层是为什么呢？

在MySQL底层，死锁发生的原因通常是因为：

• 事务之间争夺相同的资源（如行锁）。

• 事务执行顺序不当，导致互相等待对方释放锁。

1. mysql一般我们用事务用什么隔离级别？

在MySQL中，事务的默认隔离级别是REPEATABLE READ。但在实际应用中，可能会根据业务需求选择不同的隔离级别，如：

• READ COMMITTED：适用于大多数场景，可以减少幻读问题。

• SERIALIZABLE：适用于对数据一致性要求极高的场景，但性能开销较大。

1. 可重复读和可串行化的区别是啥？

可重复读（REPEATABLE READ）和可串行化（SERIALIZABLE）是SQL标准定义的四种事务隔离级别中的两种。它们的区别主要在于：

• 可重复读：在一个事务内，多次读取同样的记录结果是一致的，即使这些记录在其他事务中被修改过。它通过行锁和MVCC（多版本并发控制）来避免幻读问题，但仍然可能出现幻读。

• 可串行化：确保事务执行的结果与这些事务以某种顺序一个接一个地执行时的结果相同。这是最高的隔离级别，通过锁定事务涉及的所有数据行来防止脏读、不可重复读和幻读，但可能会导致大量的锁竞争和降低并发性能。

1. 它在MySQL底层是为什么呢？换句话说可重复读的实现原理是什么？可串行化的实现原理是什么？是什么导致了它们的区别

• 可重复读的实现原理：

  • MySQL通过MVCC（多版本并发控制）来实现可重复读。当读取数据时，系统会提供一个快照，事务在执行过程中会一直读取这个快照，即使其他事务修改了数据，也不会影响当前事务的读取结果。

  • 为了实现这个级别，MySQL使用了行锁和间隙锁（next-key locking）来锁定事务涉及的行和这些行之间的间隙。

• 可串行化的实现原理：

  • 可串行化通过锁定事务涉及的所有数据行来实现，确保事务执行时不会受到其他事务的影响。

  • 在这个级别下，MySQL会使用范围锁，锁定一个范围内的所有索引记录，从而防止其他事务插入或修改这些记录。

区别的原因：

• 可重复读允许一定程度的并发操作，因为它不会锁定事务中未涉及的数据。

• 可串行化则不允许任何形式的并发操作，因为它会锁定所有可能影响事务的数据，这导致了并发性能的降低。

1. 讲讲MySQL下索引。

MySQL索引是一种数据结构，用于快速查找表中的数据，类似于书籍的目录。索引可以大幅提高查询速度，但也会增加插入、删除和更新记录时的开销。MySQL支持多种索引类型，包括：

• B-Tree索引：最常用的索引类型，适用于全键值、键值范围和键值排序的搜索。

• Hash索引：只能用于精确匹配，不支持排序和部分匹配查找。

• Full-Text索引：用于全文检索，适用于InnoDB和MyISAM存储引擎。

• R-Tree索引：用于空间数据类型，如GIS数据。

1. 聚簇索引底层和非聚簇索引底层是什么？

• 聚簇索引（Clustered Index）：

  • 底层结构是B-Tree，其中叶节点直接包含数据行。

  • 每个表只能有一个聚簇索引，通常默认为主键。

• 非聚簇索引（Secondary Index）：

  • 也是B-Tree结构，但叶节点包含索引值和指向数据行的指针。

  • 表可以有多个非聚簇索引，它们不影响数据行的物理存储顺序。

1. 现在我们有张表用uuid建表，有张表用自增id建表，1kw行记录，添加数据的效率谁更高？为什么？

使用自增ID建表的效率更高。原因如下：

• 自增ID在插入时不需要生成新的唯一值，插入操作更快。

• 自增ID的插入操作通常是在表的一端进行，不会引起页分裂，而UUID由于是无序的，可能会导致频繁的页分裂，影响插入性能。

1. 接着15的场景，我们建完表了，其他数据都一样，只是一张表是uuid作为主键，一张表是自增主键，谁的查询效率高？为什么？

自增主键的查询效率更高。原因如下：

• 自增主键的索引是顺序的，有利于范围查询和排序操作。

• UUID是无序的，导致索引结构更加复杂，增加了查询时的磁盘I/O，降低了查询效率。

1. 讲讲你对一般怎么排查慢查询SQL。

排查慢查询SQL的步骤通常包括：

• 使用慢查询日志（Slow Query Log）来记录执行时间超过设定阈值的查询。

• 分析慢查询日志，找出慢查询SQL。

• 使用EXPLAIN或EXPLAIN ANALYZE命令来分析查询的执行计划。

• 根据执行计划检查是否使用了索引、是否有全表扫描、是否数据量过大等问题。

• 优化SQL语句，如添加索引、重写查询、减少子查询和连接操作等。

1. 你提到了一个阈值，阈值一般怎么设置？慢查询优化阈值一般设定死的吗？

阈值的设置不是固定的，它应该根据系统的性能目标和实际运行情况来调整。以下是一些设置阈值的方法：

• 观察系统的正常响应时间，然后设置一个高于这个响应时间的值作为阈值。

• 考虑到系统负载的波动，阈值可以设置得稍微宽松一些，以便在高峰时段也能捕获慢查询。

• 阈值可以根据实际情况动态调整。例如，在业务高峰期，可能需要降低阈值以捕获更多的慢查询进行分析；在业务平稳期，可以适当提高阈值以减少日志记录的压力。慢查询优化阈值不一定是设定死的，它应该是根据系统性能监控和业务需求不断调整的。

1. 你在other提到了临时表，你觉得临时表什么时候会出现？ 临时表在以下情况下可能会出现：

• 查询包含ORDER BY和GROUP BY子句，并且没有使用索引来优化这些操作，导致MySQL需要创建临时表来存储中间结果。

• 查询中使用了DISTINCT关键字，并且MySQL认为使用临时表来去重更高效。

• 查询涉及多表连接，特别是某些类型的连接（如CROSS JOIN）可能会产生大量的中间结果集，需要使用临时表来存储。

• 某些子查询或派生表在优化过程中可能会被转换为临时表。

• 用户显式地使用了CREATE TEMPORARY TABLE语句来创建临时表。

1. 自己建张表，写个sql，写出单表查询的场景下出行临时表的例子。

   CREATE TABLE sales ( id INT AUTO_INCREMENT PRIMARY KEY, product_id INT, quantity INT, sale_date DATE ); -- 插入一些示例数据 INSERT INTO sales (product_id, quantity, sale_date) VALUES (1, 10, '2023-01-01'), (2, 5, '2023-01-02'), (1, 8, '2023-01-02'), (3, 3, '2023-01-03'), (2, 7, '2023-01-04'); -- 查询：找出每个产品的总销售量，按销售量降序排序 -- 这个查询可能会使用临时表，因为它需要计算每个产品的总销售量并进行排序 SELECT product_id, SUM(quantity) AS total_quantity FROM sales GROUP BY product_id ORDER BY total_quantity DESC;

在这个例子中，MySQL可能会创建一个临时表来存储每个product_id和对应的total_quantity，然后对这个临时表进行排序以生成最终的结果集。如果product_id列上没有适当的索引，或者数据量很大，使用临时表的可能性会更高。

1. 你用过redis吗？你一般用redis干什么？

是的，我了解Redis。Redis是一种高性能的键值数据库，通常用于以下场景：

• 作为缓存系统，减少数据库的读取压力，提高系统响应速度。

• 实现分布式会话（Session）存储，用于处理用户会话信息。

• 用作消息队列，支持发布/订阅模式，实现消息的异步处理。

• 实现分布式锁，协调分布式系统中的资源访问。

• 存储计数器和统计数据，如用户访问量、点赞数等。

1. Redis的数据结构你了解多少？

Redis支持多种数据结构，包括：

• 字符串（Strings）：用于存储字符串和整数。

• 列表（Lists）：按照插入顺序排序的字符串列表。

• 集合（Sets）：无序的字符串集合，元素具有唯一性。

• 有序集合（Sorted Sets）：字符串集合，每个元素都会关联一个double类型的分数，根据分数排序。

• 哈希（Hashes）：由键值对组成的映射表。

• 位图（Bitmaps）：以位为单位进行操作的数据结构。

• HyperLogLog：用于估计集合的基数。

• 流（Streams）：是一种支持多播的可持久化的消息队列，类似于Kafka。

1. 你如何利用Redis实现个分布式锁？现成的可以讲讲原理？用原生的Redis怎么做，讲讲加解锁的逻辑？

分布式锁可以通过Redis的SET命令与EXPIRE选项来实现。以下是使用Redis实现分布式锁的基本原理和步骤：

原理：

• 使用Redis的原子操作来确保锁的互斥性。

• 设置锁的过期时间，防止死锁。

原生Redis实现加解锁逻辑：

加锁（Lock）：

SET resource_name my_random_value NX EX timeout

• resource_name 是锁的名称。

• my_random_value 是一个唯一值，用于确保释放锁的安全性。

• NX 表示只有当键不存在时才设置键。

• EX 指定键的过期时间。

• timeout 是锁的过期时间。

解锁（Unlock）：

if redis.call("get", KEYS[1]) == ARGV[1] then return redis.call("del", KEYS[1]) else return 0 end

• 使用Lua脚本确保检查和删除操作的原子性。

• KEYS[1] 是锁的名称。

• ARGV[1] 是加锁时使用的随机值。

• 如果锁的值与随机值匹配，则删除锁。

1. 为什么跳表时间复杂度是log(N)？

跳表是一种数据结构，用于有序元素的快速搜索。它通过多层索引来加速查找操作。跳表的时间复杂度为O(log(N))，原因如下：

• 跳表在每一层都是一个有序链表，每一层的元素数量大约是下一层的一半。

• 在查找元素时，可以从最高层的链表开始，如果当前元素大于要查找的元素，就跳到下一层继续查找。

• 由于每一层的元素数量减半，查找操作可以快速跳过大量元素，从而减少查找的次数。

1. 自己举个跳表的例子，来说明他平均查询复杂度是log(N)，最好直接公式推导。

假设我们有一个包含8个元素的跳表，如下所示：

层4: 1 层3: 1 -> 3 -> 5 -> 7 层2: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 层1: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8

现在我们要查找元素6。

在层4，我们发现1小于6，所以我们下降到层3。

在层3，我们发现5小于6，所以我们下降到层2。

在层2，我们找到了6。

每次下降我们都跳过了大约一半的元素。如果我们有N个元素，在最坏的情况下，我们需要下降的层数是log₂(N)。这是因为每一层我们都是跳过一半的元素。

推导公式：

假设跳表有L层，最底层有N个元素，那么每一层的元素数量大约是上一层的1/2，即第i层的元素数量大约是N/(2^i)。

查找一个元素时，平均需要经过log₂(N)层，每层平均比较1次（假设元素均匀分布）。因此，平均查找次数是log₂(N)。

所以，跳表的平均查询复杂度是O(log(N))。

1. Redis里面我们经常提有大key和热key，你分别讲讲大key是啥，热key是啥？

• 大key（Big Key）：在Redis中，大key指的是存储的数据量非常大的单个key。这通常是因为这个key存储了一个非常大的字符串值、集合、列表、哈希或有序集合。例如，一个包含数百万成员的集合或一个非常大的序列化对象都可以被视为大key。

• 热key（Hot Key）：热key是指在短时间内访问频率非常高的key。这些key可能是由于频繁的业务逻辑访问或者是缓存了非常热门的数据，导致它们成为Redis中读写操作的热点。

1. 大key会导致什么，热key会导致什么？

• 大key会导致的问题：

  • 内存分配不均：大key可能会导致Redis实例的内存碎片化，影响内存使用效率。

  • 性能问题：读写大key可能会消耗更多的CPU和网络资源，导致操作延迟增加。

  • 阻塞问题：在处理大key时，可能会阻塞Redis服务，影响其他操作的响应时间。

• 热key会导致的问题：

  • 性能瓶颈：由于频繁访问，热key可能会导致Redis实例的CPU使用率升高，网络带宽饱和。

  • 资源竞争：多个客户端可能会同时访问热key，导致锁竞争和事务冲突。

  • 宕机风险：在高并发场景下，热key可能会导致Redis实例过载，甚至引发服务宕机。

1. 你觉得有个服务有1个接口，调用这个redis的大key/热key，这会发生什么？业务层上监控的指标会有什么变化，能想到啥说啥？你觉得XX指标变化的量级会是多少？

如果服务中的一个接口调用Redis的大key或热key，可能会发生以下情况：

• 响应时间增加：由于处理大key或频繁访问热key，接口的响应时间可能会显著增加。

• 错误率上升：如果Redis因大key或热key的处理而变得不稳定，可能会导致接口错误率上升。

• CPU使用率上升：Redis实例的CPU使用率可能会上升，特别是如果涉及到复杂的数据结构操作。

• 网络带宽使用增加：频繁的数据传输可能会导致网络带宽使用增加。

具体指标变化的量级取决于key的大小、访问频率、Redis实例的配置和硬件资源等因素，因此难以给出精确的量级预测。

1. 现在有一个服务，有10个接口，其中1个低qps（100）的接口调用了大key/热key，其他9个接口（qps1k）也读这个库，那8个接口你觉得监控指标会发生什么变化？你觉得XX指标变化的量级会是多少？

在这种情况下，其他9个接口的监控指标可能会发生以下变化：

• 响应时间波动：由于大key/热key的操作可能会影响Redis实例的整体性能，其他接口的响应时间可能会出现波动。

• 错误率轻微上升：如果Redis实例受到大key/热key的影响而变得不稳定，其他接口可能会偶尔遇到错误。

由于只有一个低QPS的接口操作大key/热key，且其他接口的QPS较高，整体影响可能相对较小。具体指标变化的量级可能不会非常显著，但可能会看到一些轻微的波动。

1. Redis支持持久化吗？

是的，Redis支持持久化。Redis提供了两种主要的持久化机制：

• RDB（Redis Database Backup）：在指定的时间间隔内生成数据集的时间点快照。

• AOF（Append Only File）：记录每个写操作命令，重启时通过重新执行这些命令来恢复数据。

这两种机制可以单独使用，也可以同时使用，以确保数据的安全性和持久性。

1. AOF在文件里面存什么？RDB在文件里面存什么？

• AOF（Append Only File）文件里面存储的是Redis服务器收到的每一个写命令，比如SET、RPUSH、SADD等，以及这些命令的参数。这样，当Redis重启时，可以通过重新执行AOF文件中的命令来恢复数据。

• RDB（Redis Database Backup）文件里面存储的是Redis在某个时间点上的数据快照。它包含了数据库中的所有键值对，以一种紧凑的二进制格式存储。RDB文件非常适合用于备份和灾难恢复。

1. 你觉得AOFRDB混合持久化会丢数据吗？会在哪个范围丢数据，为什么？一个redis实例一般会丢失多少数据，这个数量级是多少？

AOFRDB混合持久化仍然可能会丢失数据，但丢失的数据量通常很小。以下是可能发生数据丢失的情况：

• 在RDB快照和最近的AOF重写之间：如果Redis在执行RDB快照后，但在下一次AOF重写之前崩溃，那么在RDB快照之后、AOF重写之前的写操作将会丢失。

数据丢失的量级取决于以下因素：

• RDB快照的频率。

• AOF重写的频率。

• 服务器崩溃的频率。

一般情况下，如果Redis配置得当，数据丢失的量级应该是很小的，可能是几秒到几分钟的数据。然而，具体的数据丢失量级很难量化，因为它依赖于上述提到的多个因素。

1. AOF持久化的时间有哪些？

AOF持久化的时间主要包括以下几个方面：

• appendfsync 配置：这个配置决定了AOF文件同步到磁盘的时间。有三个选项：

  • always：每个写命令都会同步到磁盘。

  • everysec（默认）：每秒同步一次。

  • no：让操作系统决定何时同步。

• AOF重写时间：AOF文件会定期进行重写以压缩文件大小，这个重写过程可以在后台进行，但仍然会消耗CPU资源。

1. 现有个redis cluster，8个主，有个宕机了，缓存命中率会下降多少，为什么？

如果在一个由8个主节点组成的Redis Cluster中有一个节点宕机，缓存命中率可能会下降，但具体下降多少取决于以下因素：

• 宕机节点存储的数据在整个集群数据中的比例。

• 宕机节点负责的哈希槽中的数据访问频率。

如果宕机的节点负责的数据被频繁访问，那么缓存命中率可能会显著下降。然而，由于其他节点仍然可用，理论上缓存命中率不会下降超过该宕机节点负责的数据比例。例如，如果每个节点负责相同数量的哈希槽，那么缓存命中率可能会下降大约12.5%（1/8）。

1. 你了解一致性哈希吗？

是的，我了解一致性哈希。一致性哈希是一种分布式哈希算法，用于在分布式系统中分配和定位数据。它的目标是当系统中的节点数量发生变化时，能够尽可能少地重新分配已存储的数据。

1. 一致性哈希的话，有个宕机了，缓存命中率会下降多少，为什么？

在一致性哈希中，如果有一个节点宕机，理论上缓存命中率不会显著下降，因为一致性哈希算法会将数据均匀地分布在所有的节点上。当一个节点宕机时，只有原本映射到该节点的数据会失效，而这些数据会重新映射到其他存活的节点上。

缓存命中率的下降取决于以下因素：

• 宕机节点存储的数据在整个数据集中的比例。

• 宕机节点上的数据访问频率。

如果宕机节点上的数据不是热点数据，那么缓存命中率可能只会轻微下降。

1. 一般一致性哈希中会提到一个虚拟节点，虚拟节点是用来干什么？

虚拟节点（Virtual Node）是在一致性哈希中用来提高数据分布均匀性的概念。它的工作原理如下：

• 每个物理节点被映射为多个虚拟节点，每个虚拟节点都有自己的哈希值。

• 数据根据其哈希值被映射到这些虚拟节点上，而不是直接映射到物理节点上。

• 这样可以使得数据更加均匀地分布在物理节点上，即使物理节点的数量较少。

虚拟节点的主要目的是解决物理节点数量有限时可能出现的哈希分布不均匀问题，通过增加虚拟节点的数量，可以更细粒度地控制数据的分布，提高系统的负载均衡能力。

1. 加了虚拟节点的一致性哈希，有个宕机了，缓存命中率和不加虚拟节点一不一样，为什么？

加了虚拟节点的一致性哈希与不加虚拟节点的一致性哈希在节点宕机时的缓存命中率理论上应该是相似的。原因在于，无论是虚拟节点还是物理节点，一致性哈希算法的目的都是将数据均匀地分布在所有的节点上。当某个节点（无论是物理节点还是虚拟节点）宕机时，只有原本映射到该节点上的数据会受到影响，这些数据会重新映射到其他存活的节点上。因此，缓存命中率的变化主要取决于受影响的数据在总数据中的比例，而不是是否使用了虚拟节点。

1. 你一般用Kafka干什么？

Kafka通常用于以下场景：

• 消息队列：用于解耦系统组件，实现异步通信。

• 流处理：作为实时数据处理和流计算平台，如Apache Flink和Apache Spark。

• 日志聚合：收集不同系统的日志数据，进行集中处理和分析。

• 事件源：记录和存储数据变更的历史，支持事件溯源。

1. Kafka如何实现顺序消费？Kafka本身内部实现讲讲？业务层有什么保证顺序的手段讲讲？

Kafka实现顺序消费的主要机制如下：

• 分区有序：Kafka中的每个分区（Partition）内部保证消息的顺序性。生产者向特定分区发送的消息会按照发送顺序存储，消费者从这个分区读取消息也是按照存储顺序。

Kafka内部实现：

• 生产者将消息发送到特定的分区，Kafka的Broker确保消息在分区内的顺序。

• 消费者通过Offset来跟踪已经消费的消息，确保按照顺序读取。

业务层保证顺序的手段：

• 业务层可以通过确保消息发送到同一个分区来保证顺序性。

• 使用Kafka的顺序保证特性，确保消息处理顺序与发送顺序一致。

• 在业务逻辑中维护状态，处理消息时根据业务逻辑保证顺序性。

1. 现在有一个Kafka，消息堆积了，你觉得为什么会消息堆积？业务层一般会怎么处理消息堆积问题？

消息堆积的原因可能包括：

• 消费者处理能力不足：消费者的处理速度跟不上生产者的生产速度。

• 网络问题：导致消费者无法及时从Kafka拉取消息。

• 消费者代码问题：如消费者代码出现异常，导致消费暂停。

处理消息堆积的常见手段：

• 增加消费者实例：提高消费能力，分散负载。

• 优化消费者代码：提高消息处理效率，减少处理时间。

• 扩展Kafka集群：增加分区数，提高吞吐量。

• 检查网络和配置问题：确保消费者与Kafka集群之间的网络连接稳定。

1. 接着42，它消息堆积，我把它扩容了，原来20台机器我扩容成40台，但是消费者的TPS没变，这是为什么呢？想想所有可能的原因，能讲多少是多少。

扩容后消费者的TPS没有变化，可能的原因包括：

• 消费者配置未更新：扩容后，消费者的配置（如分区分配）可能未相应更新。

• 资源瓶颈：可能是其他系统组件（如数据库、网络）成为新的瓶颈。

• 消费者代码问题：消费者代码可能存在性能问题，即使扩容也无法提高TPS。

• 消息处理逻辑复杂：消息处理逻辑可能非常复杂，导致每个消费者的处理能力有限。

• 分区数不足：如果分区数没有增加，扩容消费者并不会提高TPS。

• 系统配置问题：如JVM参数、操作系统限制等未正确配置。

1. Kafka一个分区可以被多少个消费者组内不同消费者消费吗？一个消费者可以同时消费多个Topic吗？

• 一个分区只能被消费者组内的一个消费者消费。这是Kafka为了保证分区内的消息顺序性而设计的。

• 一个消费者可以同时消费多个Topic。消费者可以订阅多个Topic，并从这些Topic的不同分区中读取消息。

1. 你讲讲对线程安全的理解吧。

线程安全是指多个线程访问同一资源时，能够保证资源的正确性和一致性，不会出现数据竞争和状态不一致的问题。要实现线程安全，通常需要考虑以下几个方面：

• 原子性：确保操作是原子性的，不会被其他线程中断。

• 可见性：一个线程对共享变量的修改，能够及时被其他线程看到。

• 有序性：保证线程内代码的执行顺序与程序代码顺序一致。

1. 比如说现在有个ConcurrentHashMap，你不对他加锁就进行一些叠加操作，这个可能会有问题吗？为什么？

在ConcurrentHashMap中进行叠加操作（如增加计数器）通常是线程安全的，因为ConcurrentHashMap内部使用了分段锁（Segmentation）来保证并发访问时的线程安全。然而，如果叠加操作不是原子性的，或者涉及到多个键值对的复合操作，那么仍然可能存在线程安全问题。例如，如果两个线程同时修改同一个键的值，那么叠加操作的结果可能会不一致。为了确保线程安全，应该使用ConcurrentHashMap提供的方法，如`putIfAbsent`，或者在操作中使用`synchronized`关键字来手动加锁。

1. 你用过哪些锁？

- 互斥锁（Mutex）：确保同一时刻只有一个线程能够访问共享资源。

- 读写锁（ReadWriteLock）：允许多个读线程同时访问共享资源，但写线程需要独占访问。

- 信号量（Semaphore）：控制对共享资源的访问数量，可以设置最大访问数量。

- 乐观锁（Optimistic Locking）：在执行写操作前不加锁，而是在提交时检查数据是否被其他线程修改过。

- 悲观锁（Pessimistic Locking）：在访问共享资源前就加锁，确保数据的一致性。

- 死锁检测锁（Deadlock Detection Locks）：在运行时检测和解决死锁问题。

- 轻量级锁（Lightweight Locks）：在Java中，轻量级锁用于减少重量级锁（如synchronized）的性能开销。

- 重入锁（Reentrant Locks）：允许同一个线程多次获得同一把锁，不会导致死锁。

在Java中，最常用的锁是`synchronized`关键字和`ReentrantLock`类。`synchronized`是Java语言的关键字，而`ReentrantLock`是Java标准库中的一个类，提供了比`synchronized`更灵活的锁机制。

1. ReentrantLock相比于syn在使用上有哪些更优秀的地方？

ReentrantLock相比synchronized有以下更优秀的地方：

• 灵活的获取和释放方式：ReentrantLock提供了tryLock()方法，可以尝试获取锁，避免长时间阻塞，如果锁不可用则立即返回。

• 响应中断：ReentrantLock可以在持有锁的线程被中断时响应中断，而synchronized锁持有者不会响应中断。

• 公平锁和非公平锁：ReentrantLock支持公平锁和非公平锁的切换，而synchronized锁默认是非公平的。

• 支持多个条件变量：ReentrantLock可以关联多个Condition对象，而synchronized锁只有一个内置的条件变量。

• 获取锁的状态：ReentrantLock可以检查是否已经获取了锁，而synchronized锁没有这个能力。

1. ReentrantLock底层原理展开讲讲。

ReentrantLock的底层原理基于AQS（AbstractQueuedSynchronizer），这是一个用于构建锁和同步器的框架。ReentrantLock的内部类Sync实现了AQS，它使用一个int类型的变量来表示持有锁的状态。

• 获取锁：当一个线程尝试获取锁时，它会首先检查锁是否已经被持有。如果未被持有，线程会通过CAS操作来设置同步状态为1，表示持有锁。如果同步状态已经被设置，线程会进入等待队列。

• 释放锁：当持有锁的线程释放锁时，它会将同步状态减1，如果同步状态变为0，表示锁已经被释放，等待队列中的第一个线程会被唤醒并尝试获取锁。

• 非公平锁：非公平锁的实现是允许当前持有锁的线程在释放锁后立即再次获取锁，这样可以提高性能，但可能导致某些线程长时间等待。

• 公平锁：公平锁的实现是按照等待队列中的线程顺序来获取锁，这样可以避免某些线程长时间等待，但可能会降低性能。

1. 讲讲ReentrantLock支持可重入锁特性的源码是怎么设计的？

ReentrantLock支持可重入锁特性的源码设计如下：

• 同步状态变量：使用一个int类型的变量来表示持有锁的状态，这个变量可以看作是持有锁的次数。

• 获取锁：当一个线程尝试获取锁时，它会检查同步状态。如果同步状态为0，表示锁未被持有，线程会通过CAS操作将同步状态设置为1。如果同步状态不为0，表示锁已经被持有，线程会通过CAS操作将同步状态增加1，表示可重入。

• 释放锁：当持有锁的线程释放锁时，它会将同步状态减1。如果同步状态为0，表示锁已经被释放，等待队列中的第一个线程会被唤醒并尝试获取锁。如果同步状态不为0，表示锁仍然被持有，线程会继续持有锁。

1. 讲讲ReentrantLock支持区分公平和非公平特性的源码是怎么设计的？

ReentrantLock支持区分公平和非公平特性的源码设计如下：

• 同步状态变量：使用一个int类型的变量来表示持有锁的状态，这个变量可以看作是持有锁的次数。

• 获取锁：非公平锁的实现是允许当前持有锁的线程在释放锁后立即再次获取锁，这样可以提高性能，但可能导致某些线程长时间等待。公平锁的实现是按照等待队列中的线程顺序来获取锁，这样可以避免某些线程长时间等待，但可能会降低性能。

• 释放锁：当持有锁的线程释放锁时，它会将同步状态减1。如果同步状态为0，表示锁已经被释放，等待队列中的第一个线程会被唤醒并尝试获取锁。如果同步状态不为0，表示锁仍然被持有，线程会继续持有锁。

1. 由你设计一个动态线程池，你会怎么设计？

设计一个动态线程池时，需要考虑以下几个方面：

• 线程池大小：可以根据系统负载动态调整线程池的大小，以适应不同的业务需求。

• 线程生命周期：线程可以有多种生命周期状态，如创建、运行、阻塞、死亡等。

• 任务队列：用于存储等待执行的任务，可以采用优先队列、阻塞队列等数据结构。

• 任务执行：线程从任务队列中获取任务并执行，执行完成后释放锁。

• 线程监控：监控线程的运行状态，如线程数、任务队列长度等。

• 线程销毁：当线程执行完成后，需要释放相关资源，如锁、内存等。

1. Java线程池过程？Java线程池原理？ Java线程池的过程和原理可以概括如下：

• 初始化：创建一个线程池时，会初始化一个核心线程池大小。

• 任务提交：当有新任务提交时，线程池会检查当前线程数是否达到核心线程数。

  • 如果达到核心线程数，任务会被添加到任务队列中。

  • 如果任务队列已满，线程池会创建新的线程来处理任务。

• 任务执行：线程从任务队列中取出任务并执行。

• 任务完成：执行完成后，线程会释放锁并返回任务队列，等待下一次任务。

• 线程销毁：当线程空闲时间超过设置的存活时间时，线程会被销毁。

• 线程池调整：根据任务队列长度和线程空闲时间，线程池会动态调整线程数，以提高资源利用率。

Java线程池的原理基于线程池管理器（ThreadPoolExecutor），它实现了ExecutorService接口。线程池管理器负责线程的创建、管理、销毁等操作。

1. ThreadLocal，怎么用？什么东西在栈上？什么东西在堆上？为什么设计成弱引用，不是容易内存泄漏吗？ ThreadLocal是一个线程局部变量，用于在多线程环境中存储线程私有数据。它通常用在需要线程隔离的场景，例如存储线程级别的会话信息、线程级别的配置等。

• 使用方式：通过get()和set()方法来获取和设置ThreadLocal的值。

• 栈上与堆上：ThreadLocal的值存储在栈上，而ThreadLocal对象本身存储在堆上。

• 弱引用设计：ThreadLocal的设计为弱引用是为了避免内存泄漏。当ThreadLocal对象不再被其他对象引用时，垃圾收集器会回收它。但是，如果ThreadLocal的值是一个强引用对象，而没有手动清除，那么这个强引用对象就会一直存在，直到ThreadLocal对象被垃圾收集器回收。为了避免这种情况，需要手动调用remove()方法来清除ThreadLocal的值。

1. MyBatis星号和井号有什么区别？ MyBatis中的星号（*）和井号（#）是两种不同的参数传递方式，它们的主要区别在于参数的类型和安全性。

• 星号（*）：星号表示MyBatis会将整个查询结果集（包括列名和列值）作为对象属性来映射。这种方式通常用于查询结果集较小的情况，因为它可以减少代码量。但是，由于星号会将所有列名和列值作为对象属性，可能会导致MyBatis无法正确解析列名和列值，从而导致映射错误。

• 井号（#）：井号用于传递参数，它将参数值作为对象属性来映射。这种方式可以提高代码的可读性和安全性，因为它不会将所有列名和列值作为对象属性。但是，由于井号需要指定列名和列值，可能会增加代码量。

在实际应用中，应该根据具体情况选择合适的参数传递方式。如果查询结果集较小，可以使用星号；如果查询结果集较大，可以使用井号来提高代码的可读性和安全性。

1. redis的单线程，redis的多路复用，epoll poll原生的多路复用有啥区别

Redis的单线程模型、Redis的多路复用以及epoll和poll原生的多路复用之间的区别主要在于它们如何处理并发和I/O操作。

1. Redis的单线程模型：

   1. Redis的单线程模型意味着它只有一个线程来处理所有的请求，包括网络I/O、磁盘I/O、CPU计算等。

   2. 它使用非阻塞I/O来处理网络连接，这意味着它可以同时处理多个客户端的连接，而不会因为线程切换或上下文切换而产生性能开销。

   3. 事件驱动模型使得Redis能够等待事件的发生（如网络请求），并在事件发生时处理它们，最大限度地减少CPU的闲置时间。

   4. 由于Redis将所有数据存储在内存中，并且能够以极快的速度访问这些数据，即使它是单线程的，也能处理大量的请求。

2. Redis的多路复用：

   1. Redis的多路复用是指它使用高效的网络I/O多路复用机制（如epoll）来处理网络连接。

   2. 这使得Redis能够同时处理多个客户端的连接，并利用单核CPU的性能。

   3. 多路复用并不改变Redis的单线程模型，而是增强了其处理并发网络请求的能力。

3. epoll和poll原生的多路复用：

   1. epoll和poll是操作系统提供的网络I/O多路复用机制。

   2. epoll是Linux特有的，而poll是跨平台的。

   3. 它们允许一个进程同时处理多个文件描述符上的事件，如读、写、连接等。

   4. epoll和poll通过一个事件表来跟踪文件描述符的状态，当事件发生时，它们能够快速地通知应用程序，而不会产生线程上下文切换的开销。

   5. epoll和poll通常被应用程序（如Redis）用来提高网络I/O的性能，尤其是在处理大量并发连接时。

  总结来说，Redis的单线程模型指的是它只有一个线程来处理所有请求，而多路复用是指它使用高效的网络I/O多路复用机制来处理网络连接。epoll和poll是操作系统提供的网络I/O多路复用机制，它们被Redis等多路复用应用程序用来提高网络I/O的性能。

1. epoll和poll的区别：

     epoll和poll是操作系统提供的两种不同的I/O多路复用机制，它们用于处理大量的并发网络连接和I/O操作。这些机制允许一个进程同时监控多个文件描述符，并等待它们变为就绪状态。当某个文件描述符变为就绪状态时，操作系统会通知应用程序，应用程序可以立即执行相应的I/O操作。

     epoll

     epoll（Event Poll）是Linux操作系统提供的一种I/O多路复用机制。它的主要特点包括：

     poll

     poll是Unix系统提供的一种I/O多路复用机制。它的主要特点包括：

     区别

     总的来说，epoll和poll都是用于处理大量并发I/O操作的机制，但epoll在Linux系统上通常更高效，因此被广泛使用。

   1. 高效的文件描述符事件通知机制，能够处理大量的并发连接。

   2. 事件驱动模型，应用程序只需等待事件的发生，并在事件发生时进行处理。

   3. 支持水平触发（LT）和边缘触发（ET）两种模式。

   4. 支持异步通知，可以提高应用程序的响应速度。

   5. 支持用户空间的事件通知机制，减少了系统调用的次数。

   6. 支持多种类型的文件描述符，包括文件、套接字等。

   7. 允许应用程序指定文件描述符的最大数量。

   8. 支持水平触发（LT）和边缘触发（ET）两种模式。

   9. 支持同步和异步操作。

   10. 适用于广泛的操作系统，包括Linux、Unix等。

   11. 效率：epoll通常比poll更高效，因为它使用了更先进的通知机制，减少了系统调用的次数。

   12. 事件通知：epoll使用边缘触发和水平触发两种模式，而poll只支持水平触发。

   13. 系统调用：epoll使用更少的系统调用，因为它在用户空间进行事件通知，而poll需要在每次系统调用时传递大量的文件描述符。

   14. 文件描述符数量：epoll可以支持更多的文件描述符，而poll受限于文件描述符的数量。

17.字节一面

1. 操作系统文件里读数据，数据拷贝过程是怎么样的？

1. 当操作系统从文件中读取数据时，数据首先从磁盘读取到文件系统的缓冲区（称为页面缓存）。然后，如果数据不在内存中，它会从页面缓存复制到内核缓冲区。最后，数据从内核缓冲区复制到应用程序的地址空间。这个过程可能涉及到多级缓存，包括磁盘缓存、页面缓存和进程缓存。

1. 内存映射文件mmap的原理和优点？

   1. 原理：mmap允许将文件内容直接映射到进程的内存地址空间，这样就可以通过内存操作（如读取或写入）来操作文件内容，而不需要通过文件系统的缓存或系统调用。

   2. 优点：

      • 提高了文件读写的效率，因为避免了数据在用户空间和内核空间之间的复制。

      • 简化了内存管理，因为内存映射区域的大小和位置可以与文件大小和位置相同。

      • 提供了更加灵活的内存访问方式，例如可以通过指针直接访问文件内容。

2. TCP通过哪些机制保证可靠的？

   1. 序号和确认：TCP使用序号来标记数据的字节，并确保所有数据都能正确到达。接收方会发送确认（ACK）来通知发送方数据已被成功接收。

   2. 重传机制：如果发送方没有收到ACK，它会重传数据。

   3. 流量控制：通过滑动窗口机制，接收方控制发送方的发送速度，以避免接收缓冲区溢出。（这就是为什么百度云盘的限速可以在客户端破解,因为本质是在客户端限制TCP传输的速度,也就是接收方）

   4. 拥塞控制：TCP通过慢启动、拥塞避免、快速重传和快速恢复等机制来控制网络拥塞。

3. 两道MySQL语句判断是否会走联合索引，存在联合索引(b, a)：

   1. select id from table where a = 1 and b < 3;：这个查询会走联合索引，因为它首先按索引a进行过滤，然后按索引b进行排序。

   2. select id from table where b = 3 and a = 1;：这个查询也会走联合索引，因为它首先按索引b进行过滤，然后按索引a进行排序。

4. 为什么MySQL主键不建议用非自增的，比如随机数，会有什么问题？

   1. 性能问题：非自增的主键会增加插入操作的复杂性，因为MySQL需要为每个新插入的记录生成一个唯一的键值。

   2. 数据一致性问题：非自增的主键可能会导致数据不一致，因为它们不是顺序生成的。

   3. 查询效率：非自增的主键可能会影响查询效率，因为它们无法利用索引的最左前缀原则。

5. MySQL InnoDB工作在什么事务隔离级别，能解决幻读吗？

   1. InnoDB工作在REPEATABLE READ事务隔离级别，可以解决不可重复读，但无法解决幻读。

6. MVCC为什么不能解决幻读？

   1. MVCC（多版本并发控制）允许每个事务看到一个一致的数据快照，但无法防止幻读，因为幻读是由不加锁的数据读取引起的。

      什么是幻读？

      如果某个操作序列满足如下时序，则发生了幻读

      1. 事务T1读取满足某<查询条件>的一组数据项

      2. 事务T2做了写入（这里的写入可以是insert/delete/update），使得满足T1中<查询条件>的数据项发生了变化，并将该写入做了提交；

      3. T1使用相同的<查询条件>重复读取，获得了与第一次读取不同的数据项（这里的不同可以是数据项增加、减少或变化）

      所以题目中描述的第一种情况"前后两次查到的数据条数不一样"属于幻读。

      MVCC可以解决绝大多数情况下的幻读

      MVCC是如何解决幻读的？

      MVCC通过保留对象的多个版本解决幻读问题。事务读取之前，先确定数据最新的一致性快照（对应数据的某个版本），然后该事务会一直读取这个快照，哪怕在读事务运行过程中对象提交了新的版本。在这种方式下，上文的操作序列中的第3步"T1使用相同的<查询条件>重复读取时"，因为事务T1读的仍然是第一次读取时的快照，所以与第一次读取时的结果一致。

      MVCC有没有彻底解决幻读？

      严格意义上，MVCC并没有完全解决幻读问题。例如，第3步"T1使用相同的<查询条件>重复读取时"，主动加了锁（lock in share mode或for update），此时就会读取最新数据（当前读），使得与第1次读取时的数据不一致。

7. Redisson的底层是怎么实现的？

   1. Redisson是一个Redis客户端库，它提供了更高级的抽象，允许开发者以对象的形式操作Redis数据。

   2. 底层实现涉及Java代码与Redis命令的交互，以及对Redis数据结构的封装。

8. 怎么解决Redis和数据库的缓存一致性问题？

     版本号

     时间戳

     乐观锁

     Redis事务：也可以使用Redis事务来保证原子性操作，减少数据不一致的可能性。

   1. 版本号机制：每次数据更新时，同时更新数据的版本号。

      1. 读取操作：先从Redis读取数据及其版本号。

      2. 更新操作：在更新数据库时，检查版本号是否与Redis中的版本号一致。如果一致，则更新数据库，并同步更新Redis及其版本号；如果不一致，拒绝更新。

   2. 时间戳机制：类似于版本号，但使用时间戳来标识数据的新旧。

      1. 读取操作：从Redis读取数据及其时间戳。

      2. 更新操作：更新数据库时，检查数据库中的时间戳是否早于或等于Redis中的时间戳。如果是，则进行更新并同步Redis；如果不是，说明数据库中的数据较新，应使用数据库中的数据覆盖Redis。

   3. 乐观锁机制：假设数据在大多数时间不会发生冲突，只在数据提交时检查是否有冲突。

      1. 读取操作：从Redis读取数据。

      2. 更新操作：在更新数据库前，检查数据是否被其他操作修改过（通常是通过版本号或时间戳）。如果没有，则进行更新并同步Redis；如果数据已经被修改，则拒绝当前操作或进行重试。

9. ThreadLocal会导致内存泄露吗？

   1. 如果ThreadLocal的值是强引用，并且没有在适当的时候被清除，那么当线程结束时，这些强引用对象可能会导致内存泄露。

   2. 因此，应该在不再需要ThreadLocal的值时，通过调用remove方法来清除这些值。

10. Redis集群怎么做？

    1. Redis集群通过将数据分布在多个Redis实例上，并通过Gossip协议进行通信来实现高可用性和扩展性。

    2. 每个Redis集群可以通过使用Redis Sentinel和Redis Cluster来提高系统的可用性和扩展性。

11. 切片集群模式中，客户端怎么知道数据存在哪个节点？

• 在切片集群模式中，客户端通常通过服务发现机制（如Zookeeper、Consul、Eureka等）来动态获取数据所在节点的信息。

• 客户端在每次请求时都会查询服务发现机制，以获取最新的数据位置信息。

1. 思维题：计算机内存只有 2 G，磁盘空间无限，如何对 100 G 大小的文件进行排序（外部归并排序）？

   1. 在这种情况下，可以使用外部归并排序（External Merge Sort）算法。

   2. 首先，将文件分割成多个小文件，每个小文件的大小不超过内存限制（2 G）。

   3. 然后，对每个小文件进行排序。

   4. 将排序好的小文件合并成更大的文件，直到合并成一个完整的排序文件。

   5. 在合并过程中，可以使用外部存储（如磁盘）来存储中间结果。

2. 讲讲临键锁：

临键锁（Next-Key Locking）是一种用于数据库中的锁机制，它结合了间隙锁（Gap Locking）和行锁（Record Locking）的特点，用于实现可重复读（Repeatable Read）和序列化（Serializable）事务隔离级别。

在InnoDB存储引擎中，临键锁的目的是为了防止幻读（Phantom Reads），即在同一个事务内，由于其他事务的插入操作，导致查询结果集发生变化，从而使得同一查询在不同时间点返回不同结果的情况。

产生幻读的原因有三个：update/insert/delete

行锁只能解决update和delete这个针对某一个行的修改操作

间隙锁可以解决insert的问题

临键锁的工作原理如下：

1. 范围查询：当执行一个范围查询（如SELECT * FROM table WHERE key >= X AND key <= Y）时，InnoDB不仅会对查询范围内的每个记录进行行锁（Record Locking），还会对查询范围外的间隙（Gap）进行间隙锁（Gap Locking）。

2. 避免幻读：通过这种方式，即使其他事务在这个间隙中插入新的记录，也不会影响到当前事务的查询结果，从而避免了幻读。

3. 性能考虑：临键锁可能会导致性能下降，因为锁的粒度更细，需要更多的锁资源。在某些情况下，它可能会阻止其他事务在这个间隙中插入记录。

4. 事务隔离级别：临键锁主要用于支持可重复读和序列化事务隔离级别。在可重复读事务隔离级别下，临键锁可以防止幻读；在序列化事务隔离级别下，临键锁是必须的，因为它可以确保事务的执行顺序。

临键锁是一种复杂的锁机制，它旨在提供高并发性和数据一致性之间的平衡。在设计数据库系统和应用程序时，需要根据具体的业务需求和性能目标来决定是否使用临键锁。

18.得物一面

1. InnoDB索引结构和分类：

   1. InnoDB使用B+树作为索引的数据结构，这种结构使得数据库能够快速进行数据的检索。

   2. 索引分类如下：

      • 主键索引（Primary Key）：每张表通常有一个主键索引，用于唯一标识表中的每一行。

      • 唯一索引（Unique Index）：索引中的值必须是唯一的，但可以包含NULL值。

      • 普通索引（Index）：允许索引列包含重复的值。

      • 全文索引（Full-Text Index）：用于全文搜索，适用于文本搜索的优化。

      • 复合索引（Composite Index）：也称为联合索引，是在表的多个列上创建的索引。

2. 联合索引的最左前缀匹配原则：

   1. 最左前缀匹配原则是指，对于复合索引，查询条件必须从索引的最左边的列开始，并且不跳过索引中的列。

   2. 例如，对于(A, B, C)的联合索引，查询条件可以只使用A，或者A和B，或者A、B和C，但是不能跳过A直接使用B或C。

3. 联合索引的索引树结构及查询流程：

   1. 索引树结构：联合索引的B+树结构中，每个节点包含了索引列的值，按照(A, B, C)的顺序排列。叶子节点包含了索引列的值和对应行的指针。

   2. 对于条件“A >= 0 AND B = 7”，联合索引不能完全命中，因为查询没有遵循最左前缀匹配原则。InnoDB查询流程如下：

      联合索引的最左前缀匹配原则是指，在查询中使用索引时，必须按照索引定义的列的顺序，从最左边的列开始匹配。如果查询条件没有按照这个顺序来，那么数据库可能无法利用整个联合索引。

      以联合索引 (A, B) 为例，以下是对最左前缀匹配原则和InnoDB查询流程的解释：

      1. 最左前缀匹配原则：

         1. 联合索引 (A, B) 实际上可以看作是先按照 A 列排序，然后在 A 列相同的情况下，再按照 B 列排序。

         2. 当执行查询时，数据库能够使用这个索引的情况包括：

            • 查询条件只包含 A。

            • 查询条件包含 A 和 B，且 A 的条件是范围查询（如 A >= 0）或者等值查询（如 A = 1），B 也是等值查询（如 B = 7）。

         3. 如果查询条件不包含 A 而直接查询 B，或者查询条件中的 A 不是最左边的列，那么数据库不能使用 (A, B) 索引的最左前缀。

      2. 为什么条件 “A >= 0 AND B = 7” 不能完全命中联合索引：

         1. 条件 A >= 0 是一个范围查询，它没有指定一个具体的值，而是一个范围。数据库可以使用索引来找到所有 A >= 0 的记录，但是因为这是一个范围，所以数据库无法利用索引中关于 B 的排序信息。

         2. 虽然条件 B = 7 是一个等值查询，它可以利用索引来快速定位 B 的值，但是因为它不是最左边的列，数据库不能在 A 的范围查询之后直接使用 B 的索引。数据库首先需要根据 A 的范围条件筛选出所有可能的记录，然后在这些记录中再查找 B = 7 的记录。

         3. 因此，查询 “A >= 0 AND B = 7” 会先使用索引 (A, B) 中的 A 列来找到所有满足 A >= 0 的记录，然后对这些记录进行回表操作（即回到聚簇索引或主键索引中查找完整的记录），最后在这些记录中过滤出 B = 7 的记录。

      总结来说，查询条件没有遵循最左前缀匹配原则，导致联合索引不能被完全利用，查询效率可能会降低。在这种情况下，数据库可能需要执行额外的查找和过滤操作，这会增加查询的成本。

      当然，以下是一个支持完全命中联合索引 (A, B) 的查询例子：

      假设我们有一个表 my_table，并且在这个表上有一个联合索引 (A, B)，则以下查询可以完全利用这个联合索引：

      这个查询遵循了最左前缀匹配原则，并且具有以下特点：

      1. 查询条件包含了联合索引 (A, B) 的所有列，并且按照索引定义的顺序（先 A 后 B）。

      2. 对于 A 列，查询条件是一个等值查询 A = 1，这意味着数据库可以使用索引来直接定位到 A 列值为 1 的记录。

      3. 对于 B 列，查询条件也是一个等值查询 B = 7，在 A 列的值已经确定的情况下，数据库可以进一步使用索引来定位到 B 列值为 7 的记录。

      SELECT * FROM my_table WHERE A = 1 AND B = 7;

      • 使用索引A列的范围条件找到对应的叶子节点。

      • 在这些叶子节点中，筛选出B=7的记录。

      • 最后，如果还有其他条件，则在筛选出的记录上应用这些条件。

4. 索引下推（Index Condition Pushdown, ICP）：

   1. 索引下推是一种查询优化技术，它允许在存储引擎层使用索引来过滤数据，而不是在MySQL服务器层。

   2. 方式：当执行一个查询时，如果WHERE条件可以使用索引中的列来过滤，那么这些条件会被下推到存储引擎层，减少不必要的数据读取。

5. InnoDB可重复读隔离级别及幻读：

   1. 可重复读隔离级别解决了脏读和不可重复读的问题。

   2. 幻读是指在同一个事务中，连续执行两次同样的查询语句，第二次返回的记录比第一次多，好像发生了“幻觉”。

   3. InnoDB通过MVCC和next-key锁来解决幻读问题。

6. 锁的类型：

   1. 如果A是主键，查询“A=0”时，加的是record锁。

   2. 如果A不是主键而是非唯一索引，InnoDB会使用next-key锁，这包括了record锁和gap锁。

7. 非唯一索引的锁互斥性：

   1. 对于非唯一索引，如果表里只有“A=1”和“A=10”，执行“SELECT * FROM ... WHERE A=5 FOR UPDATE”和“SELECT * FROM ... WHERE A=6 FOR UPDATE”不会互斥，因为它们在索引的不同位置上。

   2. 当两个事务试图锁定相同索引位置的记录时，它们会互斥。

8. binlog、redolog、undolog及其使用场景：

   1. binlog（二进制日志）：

      • 形式：STATEMENT、ROW、MIXED。

      • 使用场景：数据备份、恢复和主从复制。

      • 优点：可用于数据恢复和复制。

      • 缺点：占用磁盘空间，可能存在安全问题。

   2. redolog（重做日志）：

      • 使用场景：确保事务的持久性，在系统崩溃后恢复未写入磁盘的数据。

   3. undolog（回滚日志）：

      • 使用场景：事务回滚，确保事务的原子性。

9. binlog、redolog、undolog的详细解释及binlog的形式优缺点：

• binlog（二进制日志）：

  • 详细解释：binlog记录了所有更改数据的SQL语句，不包括查询语句。它是MySQL服务器层维护的日志，用于数据备份、恢复和主从复制。

  • 形式：

    • STATEMENT：记录SQL语句本身。

      • 优点：日志文件较小，节省磁盘空间。

      • 缺点：某些非确定性的SQL操作（如当前时间函数）可能导致复制不一致。

    • ROW：记录数据行的实际变化。

      • 优点：可以精确复制数据变化，适用于复杂的复制场景。

      • 缺点：日志文件较大，可能会增加网络传输负担。

    • MIXED：根据SQL语句的情况自动选择STATEMENT或ROW格式。

      • 优点：结合了STATEMENT和ROW的优点。

      • 缺点：在某些情况下可能仍然存在复制不一致的问题。

• redolog（重做日志）：

  • 详细解释：redolog是InnoDB存储引擎特有的日志，用于记录事务对数据页所做的修改。在系统崩溃时，可以使用redolog来恢复这些修改，确保事务的持久性。

  • 使用场景：系统崩溃后的数据恢复。

• undolog（回滚日志）：

  • 详细解释：undolog用于记录事务中的回滚操作，当事务需要回滚时，InnoDB可以使用undolog来撤销事务对数据的所有修改。

  • 使用场景：事务回滚，保证事务的原子性。

1. 总结：

   1. binlog、redolog和undolog是MySQL数据库中三种不同的日志，它们各自有不同的作用和使用场景，共同保障了数据库的ACID特性。

   2. binlog主要用于数据备份、恢复和主从复制，其不同的形式有不同的优缺点。

   3. redolog和undolog则是InnoDB存储引擎特有的日志，分别用于确保事务的持久性和原子性。

2. 手撕：131分割回文串

   import java.util.ArrayList; import java.util.List; public class Solution { public List<List<String>> partition(String s) { List<List<String>> result = new ArrayList<>(); backtrack(s, 0, new ArrayList<>(), result); return result; } private void backtrack(String s, int start, List<String> current, List<List<String>> result) { // 如果起始位置已经到达字符串末尾，则将当前组合加入结果集 if (start == s.length()) { result.add(new ArrayList<>(current)); return; } // 从起始位置尝试分割出所有可能的子串 for (int end = start; end < s.length(); end++) { // 如果子串是回文，则继续递归尝试后面的子串 if (isPalindrome(s, start, end)) { current.add(s.substring(start, end + 1)); // 添加回文子串 backtrack(s, end + 1, current, result); // 递归 current.remove(current.size() - 1); // 回溯，移除上一步添加的子串 } } } // 判断字符串s在左闭右闭区间[start, end]内是否为回文串 private boolean isPalindrome(String s, int start, int end) { while (start < end) { if (s.charAt(start++) != s.charAt(end--)) { return false; } } return true; } public static void main(String[] args) { Solution solution = new Solution(); String s = "aab"; List<List<String>> partitions = solution.partition(s); for (List<String> partition : partitions) { System.out.println(partition); } } }

19.广立微电子一面

问题1：如果单次输出超限度，自动开启第二次输出线程池的参数有哪些？拒绝策略有哪些？

回答1：线程池的关键参数包括核心线程数（corePoolSize）、最大线程数（maximumPoolSize）、存活时间（keepAliveTime）、时间单位（unit）、工作队列（workQueue）和线程工厂（threadFactory）。当任务提交时，如果当前线程数少于核心线程数，则创建新线程来执行任务；如果线程数等于或大于核心线程数，则将任务加入工作队列；如果工作队列已满，并且线程数未达到最大线程数，则创建新线程来执行任务。一旦线程数达到最大线程数，新的任务将会被拒绝。

拒绝策略（RejectedExecutionHandler）有以下几种：

1. AbortPolicy：默认策略，抛出RejectedExecutionException异常。

2. CallerRunsPolicy：由调用线程处理该任务。

3. DiscardPolicy：丢弃当前任务。

4. DiscardOldestPolicy：丢弃工作队列中最旧的任务，然后重新尝试执行任务。

问题2：线程工厂用过吗，主要用来干什么（举了线程重命名的例子）

回答2：是的，线程工厂（ThreadFactory）在创建线程池时可以使用。它主要用于创建新线程，允许自定义线程的创建过程，例如设置线程的名称、优先级、守护状态等。线程重命名的作用在于，在系统监控和日志分析时，有助于更清晰地识别和追踪各个线程的执行情况。

追问：那线程重命名有什么作用？

线程重命名的作用在于提高日志的可读性和问题追踪的效率。当多个线程并发执行时，默认的线程名称可能不足以区分不同的线程。通过重命名，可以为每个线程分配一个有意义的名称，这样在查看日志时，可以更容易地识别出是哪个线程执行了哪些操作，特别是在分析问题时，这可以大大提高诊断的效率。

问题3：一个父任务下有很多子任务，如果把父任务和小任务都放在同一个线程池里执行，这样做有什么问题。

回答3：如果父任务和子任务都放在同一个线程池中执行，可能会出现线程饥饿死锁的问题。极端情况下，如果线程池的所有线程都被父任务占用，而这些父任务又都在等待其子任务完成，那么子任务将无法获得线程资源去执行，导致父任务也无法完成，从而形成死锁。

问题4：ThreadLocal 作用（结合电子书项目讲了讲）

回答4：ThreadLocal提供了线程局部变量，即每个线程都有自己独立的变量副本。在多线程环境下，ThreadLocal保证了线程安全，因为它为每个线程提供了单独的变量副本，从而避免了线程间的数据共享和竞争条件。在电子书项目中，ThreadLocal可以用来存储用户会话信息，确保每个线程处理的请求都能够访问到正确的用户数据。

问题5：使用 TheadLocal 有没有需要注意的点（回答了 ThreadLocal Key 的弱引用）

回答5：是的，使用ThreadLocal需要注意内存泄漏的问题。ThreadLocal内部使用的是ThreadLocalMap，它的Key是弱引用，Value是强引用。如果ThreadLocal没有外部强引用来引用它，那么Key在垃圾回收时会被清理掉，而Value则不会，这可能导致内存泄漏。因此，在使用完ThreadLocal后，应该调用remove()方法来清除线程中的数据。

问题6：线程池的子任务能不能拿到父任务的 ThreadLocal（不能）？如果想拿到该怎么办

回答6：线程池的子任务不能直接拿到父任务的ThreadLocal值，因为ThreadLocal变量是线程私有的。如果需要传递ThreadLocal值，可以通过以下方法：

• 在父任务中将ThreadLocal值作为参数传递给子任务。

• 使用InheritableThreadLocal，它允许子线程继承父线程的ThreadLocal值。

问题7：堆是怎么划分的（结合分代垃圾回收的分代讲了讲）

回答7：Java堆（Heap）在分代垃圾回收机制下主要分为三个区域：年轻代（Young Generation）、老年代（Old Generation）和永久代（PermGen，Java 8之后被元空间Metaspace取代）。年轻代又分为三个部分：一个Eden区和两个Survivor区（通常称为From区和To区）。大部分新创建的对象首先在Eden区分配，当Eden区满时，进行Minor GC，存活的对象会被复制到一个Survivor区，而非存活对象则被清除。

问题8：为什么年轻代的比例是 8:1:1（1:1是因为 from 和 to 区使用的是“标记-复制”算法，8:1没回答出来）

回答8：年轻代的比例通常是8:1:1，其中8代表Eden区，1代表每个Survivor区。这个比例是因为大部分对象生命周期短暂，在第一次GC时就会被回收，因此Eden区需要相对较大。Survivor区比例较小是因为经过一次GC后存活的对象相对较少，两个Survivor区足够用于存放这些存活的对象，并通过“标记-复制”算法进行高效的内存回收。Survivor区分为From区和To区，在Minor GC时，Eden区和From区存活的对象会被复制到To区，然后交换From区和To区的角色。这种设计使得Survivor区能够以较小的空间容纳存活对象，并且能够快速地进行垃圾回收。

问题9：g1 和 CMS 的区别（回答了 g1 的区域划分）

回答9：G1（Garbage-First）和CMS（Concurrent Mark Sweep）是两种不同的垃圾回收器，它们的区别主要体现在以下几个方面：

1. 分区策略：G1将堆划分为多个大小相等的独立区域（Region），而CMS使用的是传统的固定年轻代和老年代。

2. 回收方式：G1的目标是在满足停顿时间的前提下，尽可能回收更多的垃圾。它通过预测模型来选择垃圾回收价值最大的区域进行回收。CMS则主要关注最短回收停顿时间，它在老年代进行并发标记清除。

3. 并发与停顿：G1可以在与应用程序并发执行的同时，进行垃圾回收，减少停顿时间。CMS也以并发方式进行标记和清除，但它的初始标记和最终标记阶段需要停顿。

4. 内存碎片：G1通过压缩来减少内存碎片，而CMS则可能会产生内存碎片，导致Full GC的发生。

追问：g1 能管理的内存范围（❌没回答出来）

回答10：G1垃圾回收器能够管理的内存范围是整个Java堆。G1不要求Java堆是连续的内存空间，因此它可以处理大内存容量，并且适用于多核心机器，能够有效地利用多个CPU进行并行垃圾回收。

问题11：双亲委派机制能解决什么问题？你在重写类的时候，jvm 怎么识别应该生效的是你写的类，而不是框架中的类（❌没回答出来，面试官叫我看一下 Tomcat 的加载原理了解一下）

回答11：双亲委派机制是Java类加载的一种策略，它可以解决以下问题：

1. 避免类的重复加载：当父类加载器已经加载了该类时，子类加载器无需再次加载。

2. 保护程序安全：防止核心API被随意篡改，例如，用户自定义的java.lang.Object类不会被加载，因为Bootstrap ClassLoader已经加载了核心库中的Object类。

当重写类时，JVM通过类加载器来确定哪个类应该生效。如果自定义的类加载器加载了重写的类，那么JVM会使用这个自定义类加载器加载的类。在Tomcat等Web容器中，通常会实现自定义类加载器，以确保Web应用程序的类与容器自身的类库隔离。

问题12：MySQL 建了（a, b, c）的联合索引，如果用 where 条件里有 b 和 c，这时候会走索引吗

回答12：是的，如果查询条件中包含联合索引中的列b和c，并且查询条件是索引列的非前缀匹配，MySQL查询优化器通常会使用联合索引来执行查询。但是，如果查询条件中的列顺序与索引列的顺序不一致，或者查询条件使用了范围查询（如b > 1），则可能无法完全利用联合索引。

问题13：什么是覆盖索引？

回答13：覆盖索引是指一个索引包含了查询中所需要的所有列，这样在查询时不需要回表去获取其他列的数据。使用覆盖索引可以显著提高查询性能，因为它减少了数据访问量。

问题14：什么情况下会导致慢 SQL，有什么方法能够优化慢 SQL？

回答14：以下情况可能导致慢SQL：

1. 没有使用索引或者索引使用不当。

2. 数据量过大，查询返回的结果集很大。

3. 不合理的查询逻辑，如嵌套子查询、笛卡尔积等。

4. 锁等待或死锁。

优化慢SQL的方法包括：

1. 为查询条件添加合适的索引。

2. 优化查询逻辑，减少不必要的表连接和子查询。

3. 使用查询缓存。

4. 分析执行计划，优化SQL语句。

5. 适当分批处理大数据量的查询。

问题15：使用 LoadingCache、CaffeineCache 这种本地缓存的时候有什么要注意的地方

回答15：使用本地缓存时需要注意以下事项：

1. 缓存失效策略：确保缓存数据能够在适当的时候失效，避免数据过时。

2. 缓存大小：设置合适的缓存大小，避免内存溢出。

3. 线程安全：确保缓存的线程安全性，避免并发访问问题。

4. 锁策略：合理使用锁，避免缓存操作成为性能瓶颈。

5. 监控与统计：监控缓存命中率、缓存大小、过期时间等，以便及时调整缓存策略。

问题16：Spring 如何使用三级缓存解决循环依赖问题

回答16：Spring通过以下三级缓存来解决循环依赖问题：

循环依赖分为字段循环依赖和构造器的循环依赖，三级缓存只能解决注入字段的循环依赖，构造器注入的循环依赖只能抛出异常

1. 一级缓存（singletonObjects）：存放已经初始化完成的单例对象。

2. 二级缓存（earlySingletonObjects）：存放早期暴露的对象，即已实例化但未完全初始化的对象。

3. 三级缓存（singletonFactories）：存放能够生成对象的工厂对象，用于创建早期暴露的对象。

当Spring容器创建Bean时，如果检测到循环依赖，它会按照以下步骤解决：

1. Spring首先创建一个Bean实例，并将其工厂对象放入三级缓存。

2. 当其他Bean需要依赖这个尚未初始化完成的Bean时，Spring会从三级缓存中获取工厂对象，并创建一个早期引用，然后将其放入二级缓存。

3. 一旦Bean完全初始化，它会被移到一级缓存，此时二级缓存中的早期引用会被移除。

通过这种方式，Spring能够在不破坏单例模式的前提下，解决循环依赖问题。

问题17：使用雪花算法有什么注意点（说了使用数值类型返回 id 给前端的情况下，因为 js 的 number 最多只有 53 位，如果 id 很大前端会溢出，所以要使用 String 返回）

回答17：使用雪花算法生成分布式唯一ID时，需要注意以下几点：

1. 时钟回拨：确保系统时钟的稳定性，避免时钟回拨导致ID重复。

2. 数据类型：如前所述，雪花算法生成的ID可能非常大，超过JavaScript的Number类型能表示的最大安全整数（2^53 - 1），因此在前后端交互时应使用字符串类型。

3. 位数分配：根据业务需求和数据量合理分配时间戳、机器ID和序列号的位数，确保ID在足够长的时间内不会重复。

4. 性能考虑：在高并发场景下，确保生成ID的操作不会成为系统的性能瓶颈。

问题18：JWT 是什么？

回答18：JWT（JSON Web Token）是一种用于在网络应用环境间安全地传输信息的一种基于JSON的开放标准（RFC 7519）。它可以在各方之间以JSON对象的形式安全地传输信息，因为它可以被签名（使用HMAC算法或使用RSA/ECDSA公钥/私钥对）和加密。

JWT通常包含三部分：头部（Header）、载荷（Payload）和签名（Signature）。头部包含令牌类型和使用的签名算法；载荷包含声明，声明是关于实体（通常是用户）和附加数据的声明；签名用于验证消息的发送者，并确保在传输过程中消息不被篡改。 xxxx.wwww.yyyyy

问题19：Cookie 和 Session 怎么建立联系（❌没回答出来）

回答19：Cookie和Session之间的联系通常是通过会话标识符（Session ID）来建立的。以下是它们如何建立联系的步骤：

1. 当用户首次访问服务器时，服务器会创建一个Session对象，并为该Session分配一个唯一的ID，即Session ID。

2. 服务器将Session ID作为Cookie发送到用户的浏览器，并存储在本地。

3. 当用户后续发送请求时，浏览器会自动将包含Session ID的Cookie附加到请求中发送给服务器。

4. 服务器接收到请求后，会从Cookie中提取Session ID，然后使用这个ID来查找对应的Session对象，从而获取用户的会话信息。

这样，通过Session ID，服务器就能够将用户的请求与会话状态关联起来，即使是在无状态的HTTP协议下也能维持用户的会话状态。

20.快手Java一面

1. 问题：讲讲如何进行查询优化？

答案：查询优化是提高数据库性能的关键，以下是一些常用的查询优化方法：

• 索引优化：为经常作为查询条件的列创建索引，避免全表扫描。同时，要注意索引的选择性，复合索引的使用，以及索引维护的成本。

• 查询重写：优化SQL语句，减少不必要的表连接，使用 EXISTS 代替 IN，避免使用 SELECT *，只查询需要的列。

• 查询分析：使用 EXPLAIN 或其他数据库提供的分析工具来查看查询的执行计划，根据执行计划进行优化。

• 数据分区：对于非常大的表，可以考虑使用分区来提高查询效率。

• 缓存使用：利用数据库的查询缓存或外部缓存（如Redis）来存储重复查询的结果。

• 批量操作：对于大量数据的插入、更新操作，使用批量操作减少数据库交互次数。

• 避免复杂计算：在数据库中进行复杂计算可能会降低查询性能，尽量在应用层处理。

• 合理使用存储过程：存储过程可以减少网络交互，对于复杂的业务逻辑，使用存储过程可以提高效率。

1. 问题：视图的概念，逻辑视图，物化视图，实现的原理是什么，mysql没有物化视图怎么办？

答案：视图是一个虚拟表，它基于SQL查询的结果。它有以下两种类型：

• 逻辑视图：逻辑视图不存储数据，它只在查询时动态生成数据。实现原理是，当查询视图时，数据库会执行视图定义中的SQL查询。

• 物化视图：物化视图存储了查询结果，它类似于一个表。实现原理是，物化视图在创建时会执行定义的查询，并将结果存储在数据库中，后续查询直接访问这些存储的数据。

MySQL本身不直接支持物化视图，但可以通过以下方式模拟：

• 使用普通表：创建一个表来存储视图的查询结果，定期更新这个表。

• 使用触发器：创建触发器来同步视图和表的数据。

• 使用外部工具：例如使用Apache Hive或Oracle等支持物化视图的数据库，或者使用缓存解决方案。

1. 问题：你项目中redis缓存数据一致性的方案是什么？

答案：在我项目中，为了保证Redis缓存与数据库数据的一致性，采用了以下方案：

• 缓存更新策略：使用“写后读”策略，即先更新数据库，然后使缓存失效或更新缓存。

• 延时双删：在更新数据库后，先删除缓存，然后通过延时任务再次删除缓存，确保缓存数据不会因为并发读写而出现不一致。

• 发布/订阅模式：数据库更新操作通过发布消息到消息队列，订阅者监听到消息后更新或删除缓存。

1. 问题：项目中如果IO紧张了，有什么解决方案？

答案：如果项目中遇到IO紧张的情况，可以采取以下解决方案：

• 读写分离：将数据库的读操作和写操作分离到不同的服务器上，减轻单台服务器的IO压力。

• 增加缓存：使用更多的缓存来减少对数据库的直接访问。

• 异步处理：将一些非实时性要求的操作改为异步执行，如消息队列。

• 硬件升级：增加磁盘的读写速度，如使用SSD替换HDD。

• 优化数据存储结构：减少数据冗余，优化表结构，减少不必要的IO操作。

1. 问题：搜索的相关问题，MySQL的全文检索怎么实现？跟ES有啥区别？ES怎么计算查询结果的匹配度的？

答案：MySQL的全文检索是通过FULLTEXT索引实现的，可以在InnoDB和MyISAM存储引擎的表上创建。使用MATCH()和AGAINST()函数进行全文搜索。

与Elasticsearch（ES）的区别：

• 功能丰富度：ES提供了更高级的搜索功能，如模糊查询、聚合分析、地理位置搜索等。

• 扩展性：ES是为分布式设计，可以轻松扩展到成百上千的服务器节点。

• 性能：ES在处理大量数据和高并发搜索时性能更优。

ES计算查询结果的匹配度：

• 相关性得分：ES使用BM25算法来计算文档与查询的相关性得分，这涉及到词频（TF）、逆文档频率（IDF）和字段长度归一化等因素。

1. 问题：ES数据一致性方案怎么做的？

答案：ES保证数据一致性的方案包括：

• 副本同步：ES通过主副节点之间的副本同步来保证数据一致性。

• 写入前确认：在写入数据时，可以设置等待一定数量的副本确认后再返回成功。

• 读取时的版本控制：ES支持乐观锁，通过文档的版本号来确保读取的数据是一致的。

1. 问题：数据一致性用到了MQ，那是怎么选择MQ的（RabbitMQ，Kafka）？

答案：选择消息队列（MQ）时，可以根据以下因素进行决策：

• 消息保证：RabbitMQ提供更强的消息保证，如事务性和消息确认（acknowledgments），适用于对消息可靠性要求较高的场景。

• 特性需求：RabbitMQ支持更复杂的消息路由和模式，如果需要这些特性，RabbitMQ可能是更好的选择。

• 易用性和维护：RabbitMQ相对容易部署和维护，而Kafka的集群管理较为复杂。

• 系统架构：如果系统已经使用了某种MQ，为了减少复杂性和维护成本，可能会倾向于继续使用相同的MQ。

• 吞吐量：如果系统需要高吞吐量，比如处理大量的消息，Kafka通常是一个更好的选择，因为它是为高吞吐量设计的。

1. 问题：RabbitMQ的顺序性、可靠性怎么保证的，重复消费问题怎么解决？

答案：

• 顺序性保证：通过使用单一队列和消费者，或者通过消息的correlation ID和chaining保证顺序性。还可以通过使用RabbitMQ的死信队列和优先级队列特性来维持消息的顺序。

• 可靠性保证：通过设置消息持久化、使用事务或者发送方确认（publisher confirms）和接收方确认（consumer acknowledgments）来保证消息的可靠性。

• 重复消费问题解决：可以通过以下方式解决重复消费问题：

  • 使用幂等性操作：确保消息处理逻辑是幂等的，即多次执行同一操作的结果是一致的。

  • 使用唯一标识：为每条消息设置唯一标识，处理前检查该标识是否已被处理过。

  • 利用RabbitMQ的消息唯一性特性：通过设置队列和交换机的属性来确保消息的唯一性。

1. 问题：你做的大文件导入导出怎么实现的，MQ起到什么作用，为啥要用多线程，怎么用的？

答案：

• 大文件导入导出的实现通常涉及将大文件分割成小块，然后并行处理这些小块。

• MQ的作用：MQ用于解耦系统的各个组件，保证数据传输的可靠性，以及支持异步处理。

• 为什么用多线程：多线程可以提高处理效率，尤其是在IO密集型操作中，可以利用CPU和IO资源的并行性。

• 怎么用的：

  • 分割文件：将大文件分割成多个小文件或数据块。

  • 任务分发：通过MQ分发这些小文件或数据块的处理任务到不同的消费者（线程或进程）。

  • 并行处理：消费者并行处理各自的数据块，完成导入导出操作。

  • 结果汇总：处理完成后，将结果汇总或合并，形成最终的导入导出结果。

10.问题：手撕：链表中一段的翻转

public class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } public ListNode reverseBetween(ListNode head, int m, int n) { if (head == null) return null; ListNode dummy = new ListNode(0); dummy.next = head; ListNode pre = dummy; for (int i = 1; i < m; i++) { pre = pre.next; } ListNode start = pre.next; ListNode then = start.next; for (int i = 0; i < n - m; i++) { start.next = then.next; then.next = pre.next; pre.next = then; then = start.next; } return dummy.next; }

21领星科技

1. 问题：自我介绍

答案：您好，我是一名具有多年工作经验的Java软件开发工程师。我擅长使用Java及相关技术栈进行系统设计和开发，具有丰富的项目经验。我对微服务架构、分布式系统、大数据处理等领域有深入的理解和实践。此外，我也关注软件性能优化、系统稳定性保障和新技术的研究与应用。

1. 问题：介绍项目的重难点

答案：在我参与的项目中，重难点主要包括：

• 系统高并发处理：确保系统在高并发场景下的稳定性和性能，采用了多种技术手段，如分布式缓存、消息队列、数据库分库分表等。

• 数据一致性问题：在分布式环境下，保证数据的一致性是一个挑战。我们通过使用分布式锁、事务消息、最终一致性等技术方案来解决这个问题。

• 系统可用性保障：通过冗余部署、故障转移、限流降级等措施，提高系统的可用性。

• 复杂业务逻辑处理：针对复杂的业务逻辑，我们进行了合理的模块划分和设计，确保系统的可维护性和可扩展性。

1. 问题：看你用了CompletableFuture，你知道他底层用的线程池是什么吗？

答案：CompletableFuture在默认情况下使用的是公共的ForkJoinPool，这个线程池的默认线程数是CPU的核心数（可以通过Runtime.getRuntime().availableProcessors()获得）。这个线程池是专为可以递归分解的任务设计的，适合于计算密集型任务。

1. 问题：这个线程池它的核心线程数，最大核心线程数，你了解吗？

答案：ForkJoinPool的核心线程数默认是CPU的核心数，而最大线程数则是无穷大（Integer.MAX_VALUE）。这意味着理论上它可以创建非常多的线程，但实际上受限于系统资源和任务特性，并不会无限制创建。

1. 问题：你知道他内部有个folkjoin线程吗？

答案：是的，ForkJoinPool内部的工作线程被称为ForkJoinWorkerThread，它们是ForkJoinPool的专用线程，用于执行ForkJoinTask。这些线程可以递归地分解任务，并且可以窃取（steal）其他工作线程的任务，以提高整体效率。

1. 问题：redis分布式锁的实现。

答案：Redis分布式锁通常是通过SET命令结合NX（只在键不存在时设置键）和PX（设置键的过期时间）选项来实现。基本步骤包括：尝试获取锁（SET key value NX PX timeout），释放锁时通过DEL命令删除键。

1. 问题：redisson实现分布式锁，lock锁的实现是怎样的，这把锁有设置过期时间吗？持有锁的任务执行时间过长该怎么办？

答案：Redisson实现分布式锁是通过其提供的RLock接口来实现的。这把锁确实可以设置过期时间，以防止锁因为某些原因未能正常释放而导致的死锁问题。具体实现如下：

• 设置过期时间：在获取锁时，Redisson会为锁设置一个过期时间，这个时间可以在创建RLock时指定。

• 持有锁的任务执行时间过长处理：如果持有锁的任务执行时间过长，超过了锁的过期时间，锁会被自动释放。为了避免这种情况，可以采取以下措施：

  • 在业务逻辑中设置合理的锁过期时间，确保任务能够在锁过期前完成。

  • 使用lockWatchdogTimeout配置项，它会在锁快要过期时自动延长锁的过期时间。

  • 在释放锁之前，检查锁是否仍然由当前线程持有，以避免在锁已经过期的情况下误释放其他线程持有的锁。

1. 问题：讲讲数据库和缓存之间怎么达到一致性？

答案：数据库和缓存之间达到一致性的常用策略包括：

• 缓存更新策略：在更新数据库后，立即更新或失效缓存，确保缓存数据与数据库数据一致。

• 读取修复：在读取缓存时，如果发现数据不一致，则从数据库加载最新数据并更新缓存。

• 写入时缓存失效：在写入数据库时，使相关缓存失效，下次读取时从数据库加载最新数据。

• 消息队列：通过消息队列异步更新缓存，保证最终一致性。

1. 问题：我看你在读缓存用了Double Check。控制只有一个线程去访问数据库是吧，那我问问你，你知道数据库到什么程度会奔溃吗？

答案：使用Double Check确实可以控制只有一个线程去访问数据库，以减少数据库的压力。数据库是否会崩溃取决于多种因素，如数据库的配置、硬件资源、系统负载等。以下是一些可能导致数据库崩溃的情况：

• 资源耗尽：如内存不足、磁盘空间不足或连接数超出数据库配置的最大值。

• 硬件故障：如磁盘损坏或网络中断。

• 系统配置不当：如不合理的索引、缓存设置或并发控制参数。

• 异常操作：如大量删除操作或大事务导致的数据一致性问题。

数据库的崩溃通常是逐步发生的，不会突然发生，因此监控和预警系统对于预防崩溃至关重要。

1. 问题：你知道Redis的IO有多快吗？

答案：Redis的IO速度非常快，因为它是一个基于内存的键值存储系统，其读写操作的平均时间复杂度为O(1)。在普通的硬件上，Redis能够达到每秒数百万次的读写操作，具体速度取决于具体的硬件配置和网络环境。

1. 问题：我看到你用了AOP做了什么缓存的自动存储，你能讲讲这个AOP主要做了什么吗？

答案：在项目中使用AOP（面向切面编程）来实现缓存的自动存储，主要做了以下几件事情：

• 方法拦截：拦截目标方法，判断是否需要访问缓存。

• 缓存读取：如果缓存中有数据，直接返回缓存数据，避免访问数据库。

• 缓存更新：如果缓存中没有数据或数据已过期，从数据库加载数据，更新缓存，并返回数据。

• 缓存失效：在数据更新操作后，使相关缓存失效，确保下次访问时能够获取最新数据。

1. 问题：你说了减少代码的冗余是吧，你觉得用AOP真的能减少冗余吗？AOP用多了有什么坏处吗？

答案：是的，使用AOP可以减少代码冗余，因为它允许我们将横切关注点（如日志、事务、缓存等）与业务逻辑分离。但是，AOP使用过多可能会带来以下坏处：

• 复杂性增加：AOP增加了系统的复杂性，理解和使用AOP需要一定的专业知识。

• 调试困难：AOP可能会使得代码的执行流程变得不那么直观，增加了调试的难度。

• 性能影响：AOP的动态代理机制可能会对性能产生一定的影响，尤其是在高并发场景下。

1. 问题：接下来是拷打数据库，你知道联表的规则吗？

答案：联表规则是指在进行多表连接查询时需要遵循的规则。以下是一些常见的联表规则：

• 笛卡尔积：当没有指定连接条件时，会发生笛卡尔积，即每个表中的每行与其他表中的每行进行组合。

• 内连接：只有满足连接条件的记录才会出现在结果集中。

• 外连接：分为左外连接（LEFT JOIN）、右外连接（RIGHT JOIN）和全外连接（FULL JOIN），它们分别保留了左表、右表或两表中所有的记录。

1. 问题：那你说说索引吧，ABC建立索引，我按ACB这样的查询，索引会生效吗？

答案：当您按照ACB的顺序建立索引（假设索引是按照字母顺序建立的），那么这个索引在查询时会生效。MySQL的查询优化器会使用索引来加速查询。然而，如果查询是按照ACB的顺序进行的，但索引是按照ABC的顺序建立的，查询优化器可能不会使用这个索引，因为它认为查询的顺序与索引的顺序不匹配。

为了确保索引在ACB的查询顺序中生效，您应该确保索引是按照ACB的顺序建立的，或者使用索引覆盖查询（即查询中包含的所有列都在索引中），这样查询优化器就会选择使用这个索引。

1. 问题：你知道数据库的结构吗？我说大概说了下最上面是连接层，然后验证器，查询优化器，执行器。这样的。

答案：是的，数据库的结构通常包括以下几个层次：

• 连接层：负责与客户端建立连接，处理网络通信，提供数据传输的功能。

• 验证器：验证客户端发送的SQL语句的语法和语义正确性，确保客户端请求的数据访问权限。

• 查询优化器：负责生成查询计划的执行策略，包括选择最佳的索引、排序顺序和连接方式等。

• 执行器：根据查询优化器生成的查询计划，执行实际的SQL语句，并将结果返回给客户端。

1. 问题：你知道刚刚执行的这个查询为什么能用索引了吗？是因为查询优化器做了优化，我们都看得出来，你觉得MySQL看不出来吗？

答案：MySQL的查询优化器是智能的，它会自动分析查询语句，并选择最佳的执行计划。这个优化过程包括评估各种可能的索引使用情况，选择最有效的索引，以及确定数据访问的顺序。

尽管我们可能能够直观地看出查询优化器应该选择哪种索引，但MySQL的查询优化器通常会做得更好，因为它考虑了更多的因素，如表的大小、索引的统计信息、查询的成本模型等。因此，我们通常不需要手动指定索引，除非我们确信查询优化器做出了错误的决策。

1. 问题：再讲讲Redis的内存淘汰策略吧

答案：Redis提供了多种内存淘汰策略，以处理内存不足的情况。这些策略包括：

• volatile-lru：根据LRU（最近最少使用）算法，移除最近最少使用的键。

• allkeys-lru：对所有键都采用LRU算法。

• volatile-random：随机移除一个最近最少使用的键。

• allkeys-random：对所有键都采用随机算法。

• volatile-ttl：移除即将过期的键。

• noeviction：不删除任何键，而是返回一个错误。

1. 问题：你觉得这些淘汰策略会对系统有怎样的影响？

答案：不同的淘汰策略对系统的影响不同：

• noeviction：不删除任何键，适用于对响应时间要求非常高的场景，但可能导致内存溢出。

• volatile-lru：适用于有TTL（生存时间）的键，能够自动清理过期的键。

• allkeys-lru：适用于所有键，可以清理不经常使用的键。

• volatile-random：随机清理键，可能不太适合有TTL的键。

• allkeys-random：随机清理键，可能不太适合有TTL的键。

• volatile-ttl：适用于有TTL的键，可以清理即将过期的键。

选择合适的淘汰策略取决于具体的业务需求和系统设计。

1. 问题：接下来是问了一些线上问题。你们数据库的数据量有多大？

答案：我们数据库的数据量非常大，具体数值取决于业务需求和数据增长速度。我们通常会根据数据量和业务增长趋势来规划数据库的容量和架构。

1. 问题：那你们QPS有多大？

答案：我们的QPS（每秒查询数）也非常高，具体数值取决于业务高峰期的流量和系统的处理能力。我们通过优化数据库设计、使用缓存、进行读写分离等技术手段来保证系统在高QPS下的稳定性和性能。

1. 问题：知道CAS吗？

答案：CAS（Compare and Swap）是一种处理器指令，用于实现原子操作。它包括三个操作数：内存位置（V）、预期原值（A）和新值（B）。如果内存位置的值与预期原值相匹配，处理器会自动将内存位置的值更新为新值。

1. 问题：你知道在Java 1.7和Java 18中，synchronized有什么区别吗？

答案：Java 1.7和Java 1.8中，synchronized关键字的主要区别在于它们对内部锁（Intrinsic Lock）的实现方式。

• Java 1.7：内部锁是基于CMS（Concurrent Mark Sweep）垃圾回收器中的标记-清除（Mark-Sweep）算法实现的。这种实现方式在垃圾回收时可能会导致锁的竞争，从而影响性能。

• Java 1.8：内部锁是基于G1（Garbage-First）垃圾回收器中的标记-复制（Mark-Copy）算法实现的。这种实现方式在垃圾回收时不会导致锁的竞争，从而提高了性能。

此外，Java 1.8还对synchronized进行了优化，包括锁消除（Lock Elimination）和锁粗化（Lock Coarsening），以进一步提高性能。

1. 问题：如果你发现你们项目CPU的占用突然标高，你觉得会是什么问题？

答案：CPU占用突然标高可能是由多种原因引起的，以下是一些可能的问题：

• 高并发请求：系统突然接收了大量请求，导致CPU负载增加。

• 死循环或长时间运行的线程：某些线程或方法可能进入了死循环或长时间运行，消耗了CPU资源。

• 资源竞争：多个线程竞争同一资源，导致频繁的上下文切换，增加了CPU的使用。

• 内存泄漏：内存泄漏导致垃圾回收器需要更频繁地运行，增加了CPU的使用。

• 硬件故障：如CPU风扇故障或散热不良，导致CPU温度升高，性能下降。

1. 问题：你会如何排查？

答案：排查CPU占用高的方法通常包括以下步骤：

• 监控工具：使用JMX（Java Management Extensions）或第三方监控工具来监控CPU使用情况。

• 日志分析：检查系统日志和应用日志，寻找CPU使用异常的线索。

• 线程分析：使用JDK自带的jstack工具或其他线程分析工具，查看哪些线程消耗了CPU资源。

• 性能分析：使用JDK自带的jvisualvm或第三方性能分析工具，对应用程序进行性能分析。

• 代码审查：审查可能消耗CPU的代码，寻找死循环、长时间运行的代码或资源竞争问题。

1. 问题：我看你用了微服务，就问你一个Feign吧，讲讲Feign的底层吧？

答案：Feign是一个声明式的Web服务客户端，它允许你使用接口和注解来定义Web服务，然后通过简单的配置来生成客户端。Feign底层使用了多种HTTP客户端，如Apache HttpClient、Netty和JAX-RS。

Feign的核心是一个注解驱动的框架，它支持以下注解：

• @FeignClient：用于定义Web服务客户端，指定服务名、URL和配置。

• @RequestLine：用于定义请求行，指定请求方法和URL。

• @Param：用于绑定请求参数到URL或请求体。

• @Header：用于绑定请求头。

• @Body：用于绑定请求体。

Feign通过注解解析生成一个代理类，代理类实现了Web服务接口，通过代理类可以像调用本地方法一样调用Web服务。

1. 问题：那你知道Feign发送请求的时候，他是怎么去识别主机名的？

答案：Feign在发送请求时，会根据配置的@FeignClient注解中的url属性来识别主机名。如果url属性没有指定，Feign会根据@RequestLine注解中的请求方法和URL来确定主机名。

1. 问题：你刚刚说了注册中心对吧，注册中心是如何实时的获取到这些服务的信息的？

答案：注册中心通常通过心跳机制来实时获取服务信息。服务启动时，会向注册中心注册自己的信息，包括服务名、地址、端口等。服务运行过程中，会定期发送心跳包，注册中心通过这些心跳包来判断服务是否存活。当服务停止时，会向注册中心注销自己，注册中心会从服务列表中移除该服务。

1. 问题：如果你在请求别人的接口，你觉得请求的速度很慢，你觉得可能是因为什么？

答案：请求速度慢可能由多种原因引起，以下是一些可能的原因：

• 网络延迟：网络拥塞或距离远导致的延迟。

• 客户端问题：客户端的网络问题或代码问题，如大文件传输、客户端长时间等待等。

• 服务端问题：目标服务器处理请求的时间过长，可能是由于数据库查询、复杂计算或资源竞争导致的。

• 超时设置：客户端或服务端的超时设置过短，导致请求被中断。

1. 问题：如果别人在请求你的接口，你发现速度很慢，你觉得会是因为什么？

答案：如果别人在请求你的接口时速度很慢，可能的原因包括：

• 服务器负载：你的服务器正在处理大量请求，导致响应缓慢。

• 资源竞争：服务器上的其他服务或进程可能与请求你的接口的服务竞争资源，如数据库连接、文件系统访问等。

• 代码性能：你的服务端代码可能存在性能瓶颈，如长时间运行的循环、复杂的计算逻辑等。

• 硬件资源：服务器硬件资源不足，如CPU、内存或磁盘IO等。

1. 问题：你觉得如果让你解决这个问题，你会从什么地方去入手？

答案：解决请求速度慢的问题通常需要从以下几个方面入手：

• 监控和分析：使用监控工具分析请求的响应时间，找出慢请求的瓶颈。

• 代码优化：对服务端代码进行优化，减少不必要的计算和资源消耗。

• 资源分配：根据业务需求和流量情况，合理分配服务器资源，如增加CPU、内存或磁盘IO。

• 网络优化：优化网络配置，减少网络延迟和拥塞。

• 负载均衡：使用负载均衡器将请求分发到多个服务器，提高系统的可扩展性和可用性。

1. 问题：最后还看到你这个项目里面用了个MQ是吧，主要是用来干什么？

答案：是的，在我的项目中，我们使用了消息队列（MQ）来处理异步消息传递和系统解耦。主要用途包括：

• 异步处理：将耗时的操作异步处理，提高系统响应速度。

• 系统解耦：不同服务之间通过MQ进行通信，降低耦合度，提高系统的可维护性和可扩展性。

• 削峰填谷：在高并发场景下，MQ可以作为缓冲，减少系统压力。

• 分布式事务：通过MQ实现分布式事务，保证数据一致性。

1. 问题：那我想问问，怎么确保MQ消息发送的可靠性？

答案：确保MQ消息发送的可靠性通常包括以下措施：

• 消息确认：在消息发送方和接收方之间建立消息确认机制，确保消息成功发送和接收。

• 消息重试：当消息发送失败时，进行重试，直到消息成功发送或达到最大重试次数。

• 消息持久化：将消息存储在MQ的持久化存储中，确保消息不会因为系统故障而丢失。

• 死信队列：将无法正常处理的消息路由到死信队列，以便后续处理。

1. 问题：如果我消息发生积压，是你你怎么解决？

答案：当消息队列发生积压时，可以采取以下措施来解决问题：

• 增加消费者数量：增加处理消息的消费者数量，提高消息处理能力。

• 调整消息消费速度：根据实际情况调整消费者的消费速度，避免消费过快导致队列积压。

• 优化业务逻辑：对业务逻辑进行优化，减少处理消息的时间，提高消费速度。

• 限制生产者发送速度：在生产者端限制消息发送速度，避免消息生产过快导致队列积压。

1. 最后一个问题，那你讲讲HashMap在1.7和1.8直接有什么区别吧？

答案：HashMap在Java 1.7和Java 1.8之间的主要区别在于它们的底层实现：

• Java 1.7：HashMap在Java 1.7中使用数组+链表+红黑树的数据结构。当链表长度超过阈值（默认为8）时，链表会转换为红黑树，以提高查找效率。

• Java 1.8：在Java 1.8中，HashMap引入了红黑树，并将链表的长度阈值提高到了8。当链表长度超过阈值时，链表会转换为红黑树。此外，Java 1.8还对HashMap进行了其他优化，如使用位运算来减少计算量，以及引入了新的rehash算法。

22.腾讯后端一面

1. 问题：自我介绍

答案：您好，我是一名具有多年工作经验的软件工程师。我擅长使用Java技术栈进行系统设计和开发，具有丰富的项目经验。我对微服务架构、分布式系统、大数据处理等领域有深入的理解和实践。此外，我也关注软件性能优化、系统稳定性保障和新技术的研究与应用。

1. 问题：谈谈你对AQS的理解

答案：AQS（AbstractQueuedSynchronizer）是Java中的一个高级同步框架，它提供了一种基于队列的线程同步机制。AQS通过维护一个队列来管理对共享资源的访问，确保同一时间只有一个线程可以访问共享资源。AQS的核心是同步器（Sync）类，它继承自AQS，并实现了一个同步状态（state）和一个获取和释放同步状态的方法（tryAcquire、tryRelease等）。通过这些方法，AQS可以实现多种同步器，如ReentrantLock、CountDownLatch、Semaphore等。

1. 问题：lock和synchronized的区别

答案：

• 锁获取方式：lock是显式获取和释放锁，而synchronized是隐式获取和释放锁。

• 锁重入：lock支持可中断的锁获取，而synchronized不支持。

• 锁升级：lock支持锁的升级和降级，而synchronized不支持。

• 性能：lock提供了更灵活的性能优化，如锁消除和锁粗化，而synchronized的性能优化较为有限。

1. 问题：线程池如何知道一个线程的任务已经执行完成

答案：线程池中的线程在执行任务时，会通过任务对象（通常是Runnable或Callable）的run方法来执行任务。当任务执行完成后，线程会通知线程池任务已经完成。线程池会根据任务执行的结果（如果任务是Callable）或执行状态（如果任务是Runnable）来处理任务。

1. 问题：什么是阻塞队列的有界和无界

答案：阻塞队列（BlockingQueue）是有界和无界两种类型的。

• 有界阻塞队列：它有一个固定的大小，当队列满时，新来的元素会被阻塞，直到队列有空位。同样，当队列为空时，试图从中取元素的线程会被阻塞，直到队列中有新的元素加入。

• 无界阻塞队列：它没有固定的大小，可以无限扩展。当队列满时，新来的元素会被阻塞，直到队列中有元素被移除。当队列为空时，试图从中取元素的线程会被阻塞，直到队列中有新的元素加入。

1. 问题：了解ConcurrentHashMap底层具体实现吗？实现原理是什么

答案：ConcurrentHashMap是Java中一个线程安全的哈希表，用于存储键值对。它的底层实现主要包括数组、链表和红黑树。ConcurrentHashMap使用分段锁（Segment）来保证线程安全，每个Segment维护一个HashEntry数组和几个方法（如put、get等）的监视器（Monitor）。当对ConcurrentHashMap进行操作时，需要获取对应Segment的监视器。由于HashEntry数组被分割成多个Segment，可以减少锁竞争，提高并发性能。

1. 问题：能谈一下CAS机制吗

答案：CAS（Compare and Swap）是一种处理器指令，用于实现原子操作。它包括三个操作数：内存位置（V）、预期原值（A）和新值（B）。如果内存位置的值与预期原值相匹配，处理器会自动将内存位置的值更新为新值。CAS机制可以用来实现无锁编程，提高程序的并发性能。

1. 问题：死锁的发生原因和如何避免

答案：死锁是指两个或多个线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力干涉，它们都将无法继续执行下去。死锁的发生原因主要有以下几点：

• 竞争资源：多个线程同时请求多个资源，并按一定顺序请求资源。

• 占有等待：线程在占有资源的同时，又请求其他资源，而其他资源已被其他线程占有，导致线程无法继续执行。

• 不可剥夺：线程已获得的资源在未使用完之前，不可被其他线程强行剥夺。

• 循环等待：多个线程形成一种头尾相接的循环等待资源关系。

为了避免死锁，可以采取以下措施：

• 资源有序分配：按照一定的顺序分配资源，确保资源有序分配

和释放。

• 死锁检测：定期检测系统中是否存在死锁，如果发现死锁，可以采取相应措施（如强制结束某些线程）来解除死锁。

• 超时等待：在获取资源时设置超时时间，如果超过超时时间仍未获取到资源，则放弃获取资源。

• 预防死锁：在系统设计时，尽量避免死锁的发生，如合理分配资源、避免循环等待等。

1. 问题：lock和synchronized的区别

答案：lock和synchronized都是Java中用于实现线程同步的机制，但它们在用法和性能上有一些区别：

• 锁获取方式：lock是显式获取和释放锁，需要手动调用lock()和unlock()方法；synchronized是隐式获取和释放锁，使用同步块或同步方法。

• 锁重入：lock支持可中断的锁获取，即在获取锁的过程中可以被其他线程中断；synchronized也支持锁重入，但不可中断。

• 锁升级：lock支持锁的升级和降级，即从无锁状态升级到独占锁，再降级到共享锁；synchronized不支持锁的升级和降级。

• 性能：lock提供了更灵活的性能优化，如锁消除和锁粗化，而synchronized的性能优化较为有限。

1. 问题：讲一下wait和notify为什么要在synchronized代码块中

答案：wait()和notify()是Java中的两个线程通信方法，它们需要在synchronized代码块中使用，以确保线程安全。

• wait()：当一个线程调用wait()方法时，它会释放当前对象上的锁，并进入等待状态。等待状态的线程会等待其他线程调用该对象的notify()或notifyAll()方法。

• notify()和notifyAll()：当一个线程调用notify()或notifyAll()方法时，它会唤醒等待该对象的某个或所有线程。这些线程在从等待状态唤醒后，会重新尝试获取该对象上的锁。

如果在非同步代码块中使用wait()和notify()方法，可能会导致线程安全问题，因为锁可能已经被其他线程持有，导致唤醒的线程无法获取锁，从而无法继续执行。

1. 问题：你是怎么理解线程安全问题的

答案：线程安全问题是指在多线程环境下，多个线程同时访问共享资源时可能出现的并发问题，如数据竞争、死锁、活锁等。线程安全问题可能会导致程序出错、性能下降甚至系统崩溃。

为了解决线程安全问题，可以采取以下措施：

• 同步机制：使用synchronized、lock等同步机制来控制对共享资源的访问。

• 线程通信：使用wait()、notify()等线程通信方法来协调线程间的操作。

• 线程池：使用线程池来管理线程，避免线程频繁创建和销毁。

• 资源隔离：将共享资源隔离到单独的进程中，避免多线程直接访问。

1. 问题：什么是守护线程，它有什么特点

答案：守护线程（Daemon Thread）是一种特殊类型的线程，它是一种在后台运行的线程，主要用于执行系统级的任务，如垃圾回收、网络监控等。当所有非守护线程都结束时，JVM会自动结束，并终止所有守护线程。

守护线程的特点包括：

• 后台运行：守护线程在后台运行，不参与应用程序的主要任务。

• 系统级任务：通常用于执行系统级的任务，如垃圾回收、网络监控等。

• 自动终止：当所有非守护线程结束时，守护线程也会自动终止。

1. 问题：innoDB如何解决幻读

答案：幻读（Phantom Read）是指在多版本并发控制（MVCC）系统中，一个事务在执行过程中读取了某个范围的数据，但在执行过程中其他事务对该范围的数据进行了新增或删除操作，导致该事务再次读取时发现数据范围发生了变化。

InnoDB通过MVCC来解决幻读问题。当一个事务读取数据时，InnoDB会记录下当前的系统版本号。如果该事务在执行过程中发现系统版本号发生了变化，说明其他事务对该范围的数据进行了修改，InnoDB会返回错误，并重新执行查询。

1. 问题：b树和b+

树的理解

答案：

• B树：B树是一种自平衡的树形结构，它在数据库管理系统中用于支持快速的查找、顺序访问、插入和删除操作。B树的特点包括：

  • 每个节点最多有m个子节点，其中m是树的最大高度。

  • 每个节点至少有m/2个子节点。

  • 所有叶子节点都在同一层。

  • 每个非叶子节点都有至少m/2个键。

  • 每个节点（除了根节点和叶子节点）都有至少m/2-1个键。

  • 所有键都是有序的。

• B+树：B+树是B树的变种，它在数据库管理系统中广泛用于索引结构。B+树的特点包括：

  • 所有键值都在叶子节点，并且叶子节点按键值排序。

  • 所有叶子节点都指向同一个集合，称为叶子节点集合。

  • 每个节点都包含指向子节点的指针，除了叶子节点和根节点。

  • 每个节点包含的键值的数量比B树少，因此可以拥有更多的子节点，提高了查询效率。

B+树相比于B树，更适合作为索引结构，因为它的叶子节点包含了所有的键值，可以更容易地进行范围查询和顺序访问。此外，B+树的叶子节点集合可以方便地用于实现外部排序和缓存优化。

1. 问题：你是否在面试中也被问过MySQL优化相关的问题

答案：是的，面试中经常会被问到MySQL优化相关的问题。MySQL优化涉及到多个方面，包括查询优化、索引设计、数据库设计、硬件优化等。以下是一些常见的MySQL优化问题：

• 如何优化查询性能？

• 如何选择合适的索引？

• 如何设计合理的表结构？

• 如何进行数据库硬件优化？

• 如何使用慢查询日志分析性能瓶颈？

• 如何使用EXPLAIN分析查询执行计划？

1. 问题：CPU飙高系统反应慢怎么排查

答案：当CPU使用率过高导致系统反应慢时，可以采取以下步骤进行排查：

• 监控工具：使用系统监控工具（如top、htop、nmon等）查看CPU使用情况，找出占用CPU最多的进程。

• 性能分析：使用性能分析工具（如JProfiler、VisualVM等）对Java应用进行性能分析，找出耗CPU的代码段。

• 日志分析：检查系统日志和应用日志，寻找CPU使用异常的线索。

• 线程分析：使用线程分析工具（如jstack、jvisualvm等）查看CPU占用高的线程，分析线程堆栈信息。

• 代码审查：审查CPU占用高的代码，寻找耗CPU的操作，如循环、递归调用等。

1. 问题：什么是双亲委派

答案：双亲委派（Parent Delegation）是Java类加载器的一种加载策略。在Java中，类加载器分为Bootstrap ClassLoader、Extension ClassLoader、Application ClassLoader和自定义类加载器。双亲委派机制要求除了顶层的Bootstrap ClassLoader外，其余类加载器都应有自己的父类加载器。当一个类加载器收到类加载的请求时，它首先会尝试委派给父类加载器去加载。只有当父类加载器无法加载该类时，才会尝试自己去加载。

1. 问题：JVM如何判断一个对象可以被回收

答案：JVM判断一个对象是否可以被回收，主要依据以下几个条件：

• 引用计数：当一个对象不再被任何引用引用时，可以被回收。

• 可达性分析：JVM会进行可达性分析，如果一个对象不能通过根对象（如本地方法栈、方法区等）直接或间接访问，则可以被回收。

• 垃圾收集器：垃圾收集器会根据上述条件，选择合适的时间和策略进行垃圾回收。

1. 问题：G1垃圾收集的特点，为什么低延迟

答案：G1（Garbage-First）垃圾收集器是Java 9引入的一种垃圾收集器，它是为服务器端应用设计的，具有以下特点：

• 并行与并发：G1垃圾收集器可以与应用程序并发执行，降低了垃圾收集时的停顿时间。

• 分代收集：G1将堆分为多个大小相等的独立区域，每个区域独立进行垃圾收集，提高了垃圾收集的效率。

• 可预测的停顿时间：G1垃圾收集器可以

根据应用程序的需求，设置停顿时间的目标，并尽可能地满足这个目标。

• 低延迟：G1垃圾收集器通过并行与并发收集、分代收集和可预测的停顿时间，实现了低延迟的垃圾收集。

G1垃圾收集器低延迟的原因在于其能够充分利用多核CPU的并行处理能力，同时通过分代收集和可预测的停顿时间，减少垃圾收集对应用程序的影响。

1. 问题：Redis存在线程安全问题吗？为什么

答案：Redis本身是一个单线程的程序，所有的操作都是在一个线程上完成的。虽然Redis不是多线程的，但它使用了非阻塞IO（NIO）来提高性能。这意味着Redis可以在处理请求时不会阻塞，可以同时处理多个客户端的请求。

Redis不存在传统意义上的线程安全问题，因为它的操作都是顺序执行的，不会出现线程间的数据竞争。但是，如果Redis被用作多线程应用程序的共享存储，就需要考虑线程安全问题，因为多个线程可能会同时对Redis进行读写操作。

1. 问题：RDB和AOF的实现原理以及优缺点

答案：

• RDB（Redis Database）：RDB是Redis的一种持久化方式，它会将当前内存中的数据集以快照的形式写入磁盘。实现原理是Redis会定期（根据配置的save参数）将内存中的数据集写入磁盘。优点是恢复速度快，缺点是可能会丢失最后一次保存后的数据。

• AOF（Append Only File）：AOF是Redis的另一种持久化方式，它会将执行过的写操作记录下来，在Redis重新启动时，通过重放这些写操作来重建数据集。实现原理是Redis在执行写操作时，会将其写操作记录到AOF文件中。优点是数据安全性高，缺点是恢复速度慢。

1. 问题：Redis和Mysql如何保证数据一致性

答案：Redis和MySQL保证数据一致性的方法有所不同：

• Redis：Redis通过单线程模型和无阻塞IO来保证高并发下的数据一致性。Redis的命令是原子性的，但多个命令之间的原子性需要通过事务（MULTI/EXEC）来保证。此外，Redis还提供了WATCH命令来支持乐观锁，确保在执行事务前数据没有被其他客户端修改。

• MySQL：MySQL通过多线程模型和事务机制来保证数据一致性。MySQL支持事务的ACID属性，包括原子性、一致性、隔离性和持久性。通过合理使用锁机制（如行锁、表锁等）和隔离级别，可以防止数据不一致的情况发生。

1. 问题：Zookeeper如何实现分布式锁

答案：ZooKeeper通过其特有的数据模型和原子操作来实现分布式锁。分布式锁的实现原理如下：

• 创建锁节点：客户端在ZooKeeper的Znode（节点）上创建一个临时的顺序节点。

• 获取锁：客户端尝试获取锁节点，如果成功创建，则表示获得了锁。

• 等待锁：如果锁节点已经存在，客户端会等待其他客户端释放锁。

• 释放锁：当持有锁的客户端完成任务后，它会删除锁节点，释放锁。

ZooKeeper的分布式锁实现简单、高效，但需要客户端与ZooKeeper服务器之间的网络通信，因此在网络延迟或故障的情况下可能会影响性能。

1. 问题：谈谈你对Zookeeper的理解

答案：ZooKeeper是一个开源的分布式协调服务，它提供了一种简单的机制来分布式系统中进行配置管理、命名服务、分布式锁和队列管理。ZooKeeper的特点包括：

• 数据一致性：ZooKeeper保证客户端看到的数据是一致的，即使是在网络分区的情况下。

• 原子性操作：ZooKeeper的所有操作都是原子性的，不会因为网络问题而部分执行。

• 顺序一致性：客户端可以看到所有的更新操作，并且这些操作是有顺序的。

• 实时性：ZooKeeper提供了实时的数据变更通知，客户端可以实时获取数据变更。

• 简单性：ZooKeeper的设计非常简单，易于理解和使用。

ZooKeeper在分布式系统中扮演着重要的角色，可以用来解决分布式系统中的各种问题，如配置管理、服务发现、分布式锁和队列管理等。

23.美团到店一面

1. Java基础类

2. 问题：锁的分类以及各自特点（从乐观/悲观的角度答）

答案：锁可以分为乐观锁和悲观锁。

• 乐观锁：乐观锁假设没有冲突发生，在更新数据时不进行加锁，而是在更新时检查是否有其他线程同时修改了数据。如果发生冲突，则采取相应的回滚措施。特点包括：

  • 轻量级，没有加锁的开销。

  • 并发性能较高。

  • 实现方式通常是基于版本号或时间戳。

• 悲观锁：悲观锁假设冲突一定会发生，因此在操作数据前会先加锁，确保同一时间只有一个线程可以操作数据。特点包括：

  • 安全性高，能够避免并发冲突。

  • 并发性能相对较低，因为需要等待锁的释放。

  • 实现方式通常是通过synchronized关键字或ReentrantLock类。

1. 问题：乐观锁的实现、悲观锁的实现

答案：

• 乐观锁的实现：通常通过版本号机制实现。每次更新数据时，都会检查版本号是否与读取时的一致，如果一致则更新数据并递增版本号，否则放弃操作。

• 悲观锁的实现：在Java中，可以通过synchronized关键字或ReentrantLock类来实现。synchronized是隐式锁，而ReentrantLock是显式锁，提供了更多的锁控制功能。

1. 问题：多个线程同时争抢同一把锁阻塞的情况下，如何唤醒指定线程？

答案：可以使用Object类的notify()或notifyAll()方法来唤醒等待锁的线程。如果要唤醒指定的线程，可以在调用wait()方法前使用一个额外的对象作为锁，并在唤醒时使用该对象的notify()方法。

1. 问题：堆和栈的区别是什么？平时工作中有没有碰到过栈溢出和堆溢出的情况？有做过JVM调优吗？

答案：

• 堆和栈的区别：堆是Java内存管理中最大的一块区域，用于存储所有创建的对象和数组。栈是线程私有的，用于存储局部变量和方法调用的上下文信息。堆内存需要手动管理（垃圾回收），而栈内存自动分配释放。

• 栈溢出和堆溢出：在开发过程中，可能遇到过栈溢出（如递归过深）和堆溢出（如大量对象创建未释放）。

• JVM调优：在工作中可能进行过简单的JVM调优，如调整堆大小、垃圾回收器参数等，以提高应用性能。

1. Spring框架类

2. Spring框架类

3. 问题：Spring和SpringBoot的区别在哪里？除了优点之外，SpringBoot有不好的地方吗？

答案：

• Spring和SpringBoot的区别：Spring是一个轻量级的企业级应用开发框架，提供了全面的编程和配置模型。SpringBoot基于Spring框架，提供了一种快速开发单个微服务应用的简便方法。它简化了配置和部署过程，内置了许多默认配置，使得开发者可以快速启动和运行应用。

• SpringBoot的优点：简化了配置，减少了开发者的工作量，内置了多种应用服务器，支持自动配置。

• SpringBoot的缺点：由于做了很多优化和兼容，整体上可能不如Spring轻量化。在特定情况下，自动配置可能不满足需求，需要开发者手动调整，这可能增加了复杂性。

1. 问题：SpringBoot中事务管理的注解有用过吗？它是如何实现的呢？

答案：

• 使用过@Transactional注解来声明事务管理。

• 实现方式：SpringBoot通过AOP（面向切面编程）动态代理的方式实现事务管理。当标记了@Transactional的方法被调用时，Spring会创建一个代理对象来拦截方法调用，并在方法执行前后添加事务管理的逻辑。

1. 问题：Controller类是单例的，那它是如何做到同时处理多个线程的访问呢？

答案：

• Controller类确实是单例的，但SpringMVC通过DispatcherServlet来处理每个请求，并为每个请求创建一个新的请求处理线程。每个线程都有自己的请求和响应对象，因此即使Controller是单例的，它也能同时处理多个线程的访问，而不会相互干扰。

1. MySQL类

2. 问题：如何知道索引有没有命中？

答案：

• 可以通过执行计划（EXPLAIN）来查看SQL语句是否命中索引。在执行计划的结果中，type列如果显示为index，则表示使用了索引；如果显示为ALL，则表示进行了全表扫描，没有使用索引。

1. 问题：Limit查询深度分页问题的解决？

答案：

• 使用游标分页或延迟关联查询（延迟加载）来解决深度分页问题。游标分页通过记录上一次查询的最后一个ID，下次查询从该ID开始，避免全表扫描。

1. 中间件类

2. 问题：如果一个线程从Redis获取数据时由于某种原因发生了阻塞，这时另一个线程去获取同一个数据，是否会被阻塞？

答案：

• 在Redis中，虽然它使用了单线程模型来处理命令，但阻塞通常是由于特定的命令（如BLPOP、BRPOP）导致的，而不是因为其他线程的阻塞操作。因此，另一个线程去获取同一个数据通常不会被阻塞，除非它也执行了可能导致阻塞的命令。

1. 问题：Redis单线程为什么能这么快？什么是IO多路复用？

答案：

• Redis单线程之所以能这么快，是因为它使用了单线程模型来避免上下文切换开销，同时采用了非阻塞IO和事件驱动的模型来处理请求。这使得Redis在处理请求时非常高效。

• IO多路复用是一种允许单个线程同时监视多个文件描述符，等待它们变得“就绪”的机制。这意味着单个线程可以处理多个并发IO流，常见的实现有BIO（阻塞IO）、NIO（非阻塞IO）和IO多路复用（如epoll）。

1. 问题：某个接口中过多调用了其他服务的方法，导致业务耦合度高、响应时间慢，如何解决？

答案：

• 可以通过以下方式解决：

  • 使用多线程或线程池异步处理，减少同步等待时间。

  • 引入消息队列进行解耦，将同步调用改为异步消息传递。

1. 问题：消息队列如何确保消息不丢失？

答案：

• 确保消息不丢失可以从以下三个方面考虑：

  • 生产者到消息队列：使用事务消息或确认机制（如RabbitMQ的publisher confirms）确保消息被正确投递。

  • 消息队列自身：持久化消息到磁盘，并采用副本机制确保消息不丢失。

  • 消息队列到消费者：消费者在处理完消息后发送确认消息给队列，队列只有在收到确认后才删除消息。

1. RPC类

2. 问题：对RPC有了解过吗？

答案：

• 对RPC有一定的了解。RPC（远程过程调用协议）是一种允许程序调用另一个地址空间（通常是另一台机器上）的过程或函数的协议。

1. 问题：调用方和被调用方如何确定对方身份？

答案：

• 调用方和被调用方通常通过服务注册与发现机制来确定对方身份。在服务启动时，被调用方会在服务注册中心（如Zookeeper、Consul等）注册自己的服务地址和端口信息。调用方在需要调用服务时，会先到服务注册中心查询被调用方的地址信息，然后进行远程调用。

24.美团到店二面.八股部分

1. SpringBoot如何指定Bean加载顺序

答案：

在SpringBoot中，没有直接的方式来指定Bean的加载顺序，因为Spring容器默认是根据类型和依赖关系来管理Bean的创建顺序的。但是，可以通过以下方法来间接控制Bean的加载顺序：

• 使用@DependsOn注解：可以在Bean定义时使用@DependsOn注解来指定该Bean依赖于其他Bean，确保在创建当前Bean之前先创建依赖的Bean。

• 实现Spring的org.springframework.core.Ordered接口或使用@Order注解：这些方式可以影响Bean的加载顺序，但主要用于控制Bean的初始化顺序，而不是加载顺序。

• 使用BeanFactoryPostProcessor和BeanPostProcessor：通过自定义这些后处理器，可以在Bean创建之前或之后插入自定义逻辑，间接控制加载顺序。

1. MySQL什么时候分库、什么时候分表

答案：

分库和分表是数据库水平扩展的两种方式，它们的使用场景如下：

• 分库：

  • 当单台数据库服务器的性能无法满足需求时，可以考虑分库。

  • 当数据量非常大，单台服务器存储不下时，可以通过分库来分散存储。

  • 当需要跨多个地理位置部署应用，以实现数据的地理分布时，可以使用分库。

• 分表：

  • 当单表数据量过大，导致查询、更新操作性能下降时，可以考虑分表。

  • 当表中存在大量历史数据，而这些数据不经常访问时，可以通过分表将热点数据与非热点数据分开。

  • 当需要减少单表锁的粒度，提高并发性能时，可以采用分表。

1. 线程池各个参数设置时的考量

答案：

线程池的参数设置需要根据具体的应用场景和需求来考量，以下是一些关键的参数及其考量因素：

• corePoolSize：核心线程数，用于设置线程池的基本大小。考量因素包括：

  • 应用程序的CPU密集型或IO密集型特性。

  • 系统资源（如CPU核心数）的可用性。

• maximumPoolSize：最大线程数，线程池允许创建的最大线程数。考量因素包括：

  • 系统资源限制，如内存大小。

  • 预期的并发任务数量。

• keepAliveTime：非核心线程空闲时的存活时间。考量因素包括：

  • 线程池的使用频率，如果任务频繁，可以设置较短的存活时间。

• workQueue：工作队列，用于存放待执行的任务。考量因素包括：

  • 任务的特点，是否允许任务丢失或需要保证任务顺序。

  • 队列的类型和大小，如LinkedBlockingQueue、SynchronousQueue等。

• threadFactory：线程工厂，用于创建线程。考量因素包括：

  • 是否需要自定义线程的属性，如线程名称、优先级、守护状态等。

• rejectedExecutionHandler：拒绝策略，当线程池和队列都满时，对新任务的处理策略。考量因素包括：

  • 是否允许任务丢失或需要记录日志。

  • 是否需要调用者处理失败的任务。

1. 除了建索引，还有什么办法提高查询速度

答案：

除了建立索引外，以下是一些提高查询速度的方法：

• 优化SQL语句：重写查询，避免使用子查询，减少JOIN操作，使用EXPLAIN分析查询计划并优化。

• 使用缓存：对于频繁查询且不经常变更的数据，可以使用缓存来减少数据库访问。

• 数据库表结构优化：合理设计表结构，减少数据冗余，适当使用范式。

• 使用分区表：将大表分割成多个更小、更易于管理的部分。

• 优化硬件：提高服务器的CPU、内存、存储性能。

• 使用更快的存储引擎：如InnoDB通常比MyISAM更快，因为它支持事务处理和行级锁定。

• 减少数据传输：只查询需要的列，而不是使用SELECT *。

• 数据库配置优化：调整数据库的配置参数，如缓冲池大小、查询缓存等。

25.猫眼娱乐一面

1. 问题：介绍一下你实习的项目

答案：在我的实习项目中，我主要负责使用Redis分布式锁来保证审批订单的潜在修改和撤回行为的一致性。具体来说，就是在下单修改的操作中，确保这些操作的原子性，防止并发操作导致的数据不一致问题。

1. 问题：什么场所需要分布式来保证行为的并发性

答案：在分布式系统中，尤其是在高并发、多节点的情况下，需要使用分布式锁来保证行为的并发性。例如，电商平台的订单处理、库存管理、支付系统等场景。

1. 问题：审批和修改不是只需要行锁来保证原子性就可以了吗？

答案：行锁主要用于数据库层面，确保同一时间只有一个事务能操作某一行数据。但在分布式系统中，多个节点可能操作同一个资源，此时行锁无法满足需求，需要分布式锁来保证原子性。

1. 问题：Redis的分布式锁你是怎么实现的？

答案：我通过Redis的SETNX命令实现分布式锁，具体步骤如下：

a. 使用SETNX命令尝试设置一个键值对，如果设置成功，表示获取锁成功。

b. 为锁设置一个过期时间，防止锁永远无法释放。

c. 执行业务逻辑。

d. 释放锁，使用DEL命令删除键值对。

1. 问题：Redis中如果有把锁因为集群节点宕机而永远无法被释放该如何解决

答案：可以为锁设置过期时间，即使节点宕机，锁也会在过期后自动释放。此外，可以使用Redis的Redlock算法，通过多个独立的Redis节点来提高锁的可靠性。

1. 问题：Redis的原子性如何保证

答案：Redis的操作本身就是原子性的，如SETNX、GETSET等命令。在实现分布式锁时，通过这些原子性命令来保证操作的原子性。

1. 问题：你给锁设置操作时间，如果时间到了还没执行完任务，锁要是释放了怎么办

答案：可以采用以下策略：

a. 在锁释放前，检查任务是否执行完毕，如果未执行完毕，可以续期。

b. 使用守护线程，定时检查任务执行状态，如果任务未完成，则续期。

1. 问题：介绍一下CountDownLatch 答案：CountDownLatch是一个同步辅助类，允许一个或多个线程等待其他线程完成操作。它通过一个计数器来实现，计数器的初始值表示需要等待的线程数量。每当一个线程完成操作后，计数器的值会减一，当计数器值为0时，等待的线程会被唤醒继续执行。

2. 问题：CountDownLatch底层基于什么，简单说说AQS 答案：CountDownLatch底层基于AbstractQueuedSynchronizer（AQS）实现。AQS是一个用于构建锁和同步器的框架，它使用一个int类型的state变量来表示同步状态，并通过内置的FIFO队列来管理等待的线程。

3. 问题：其中一个线程长时间阻塞以至于严重拖慢了后续任务的时间该怎么办 答案：可以采取以下措施： a. 对阻塞操作设置超时时间，避免无限期等待。 b. 使用线程池，合理分配线程资源，避免单个线程长时间占用。 c. 优化阻塞操作，减少阻塞时间。 d. 使用异步方式处理，避免阻塞。

4. 问题：为什么选择MQ来进行削峰解耦 答案：选择MQ（消息队列）进行削峰解耦的原因包括： a. 削峰：MQ可以缓冲高流量请求，避免系统瞬间过载。 b. 解耦：通过MQ，不同服务之间可以异步通信，降低系统间的耦合度。 c. 可靠性：MQ通常提供持久化机制，确保消息不会丢失。

5. 问题：进行MQ解耦的合适QPS的标准是多少 答案：合适的QPS标准取决于具体业务场景和系统性能。一般而言，QPS应该在不影响系统稳定性的前提下，尽可能满足业务需求。通常需要通过压力测试来确定合适的QPS。

6. 问题：MQ发送消息如何知道下游的服务成功消费了 答案：可以通过以下方式： a. 消息确认机制：消费者在消费完消息后，向MQ发送确认消息。 b. 回调：消费者在处理完消息后，调用生产者提供的回调接口通知处理结果。

7. 问题：如何保证消息不被重复消费 答案：可以采取以下措施： a. 使用幂等性操作：确保即使多次执行同一操作，结果仍然一致。 b. 消息去重：在消息体中添加唯一标识，消费者处理前检查是否已处理过。 c. 利用数据库等外部存储的原子性操作来保证消息的幂等性。

8. 问题：如何发现并且定位慢SQL语句 答案：可以通过以下方法： a. 使用数据库自带的慢查询日志功能。 b. 使用第三方监控工具，如Prometheus、Grafana等。 c. 在应用层面记录SQL执行时间，超过阈值则记录日志。

9. 问题：如何优化慢SQL 答案：可以采取以下措施： a. 为查询字段添加索引。 b. 避免使用SELECT *，只查询需要的字段。 c. 优化SQL语句，减少子查询和JOIN操作。 d. 分析执行计划，优化查询逻辑。

10. 问题：怎么解决深度分页问题 答案：解决深度分页问题可以采用以下方法： a. 使用游标分页，避免跳过大量数据。 b. 使用延迟加载，只加载当前页面数据。 c. 在业务允许的情况下，限制分页深度。

11. 问题：Mybatis的分页插件你有用过吗 答案：是的，我使用过Mybatis的分页插件，如PageHelper。它通过拦截器实现分页功能，只需在查询前调用startPage方法，即可实现物理分页。

12. 问题：简单介绍一下索引 答案：索引是数据库表中一种特殊的数据结构，它可以提高查询效率，类似于书籍的目录。索引存储了表中列的值以及指向对应行数据的指针，从而加快了数据检索速度。

13. 问题：什么是非聚簇索引跟聚簇索引有什么区别 答案：非聚簇索引（Non-clustered Index）和聚簇索引（Clustered Index）的区别如下：

• 非聚簇索引：索引的顺序与实际数据行的物理存储顺序不同，每个索引项包含索引列的值和指向数据行的指针。

• 聚簇索引：索引的顺序与数据行的物理存储顺序相同，叶子节点直接包含数据行。

• 聚簇索引通常只有一个，因为数据的物理顺序只能有一种，而非聚簇索引可以有多个。

1. 问题：如果要你从表中查询两个字段，如何更快地查询，对这两个索引加唯一索引 答案：为了更快地查询两个字段，可以创建一个复合索引（也称为联合索引）涵盖这两个字段。如果这两个字段的组合值是唯一的，可以加唯一索引来提高查询效率并保证数据的唯一性。

2. 问题：你是如何理解分布式定时任务的 答案：分布式定时任务是指在分布式系统中，按照预定的时间计划执行的任务。这些任务可以被分布到不同的服务器上执行，以实现负载均衡和容错性。分布式定时任务通常由任务调度中心统一管理和调度。

3. 问题：RPC和HTTP的区别 答案：RPC（远程过程调用）和HTTP（超文本传输协议）的区别主要包括：

• RPC是一种编程模型，允许一台计算机上的程序调用另一台计算机上的程序，而HTTP是一种协议，用于在Web服务器和客户端之间传输数据。

• RPC通常更注重效率和性能，HTTP则更注重通用性和易用性。

• RPC可以基于不同的传输协议，如TCP或UDP，而HTTP通常基于TCP。

1. 问题：RPC和RocketMQ的区别 答案：RPC和RocketMQ的区别主要在于它们的功能和应用场景：

• RPC主要用于服务间的远程方法调用，侧重于同步通信。

• RocketMQ是一个消息中间件，用于消息的异步传递，支持发布/订阅模式，侧重于解耦和削峰。

1. 问题：简单介绍一下MySQL的事务 答案：MySQL的事务是指一组操作，要么全部成功执行，要么全部失败回滚，保证数据库的一致性和完整性。事务具有ACID属性：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability）。

2. 问题：使用可重复读如何保证事务安全 答案：在MySQL中，可重复读（Repeatable Read）是事务隔离级别之一，它通过以下机制保证事务安全：

• 事务开始时，创建一个视图（快照），在事务期间，所有读取操作都从这个快照读取数据。

• 通过MVCC（多版本并发控制）机制，保证事务在执行期间看到的数据是一致的。

1. 问题：幻读是什么，可重复读使用什么机制保证了不幻读 答案：幻读是指在同一个事务中，连续执行两次同样的查询，第二次查询可能会返回第一次查询未返回的行。可重复读通过MVCC机制和间隙锁（Gap Locks）来保证不会发生幻读。

2. 问题：索引失效的情况？ 答案：索引失效的情况包括：

• 使用不等号（<>、!=）查询。

• 使用函数或计算在索引列上。

• 使用模糊匹配（LIKE）且前导字符为通配符。

• 在复合索引中，不按照索引的创建顺序使用列。

1. 问题：假如有 idx(a_b_c_d)，where a=x and b =y and c=z and d=o 会走索引嘛，where a=x and b =y会走索引嘛 where a=x and b =y and c、d范围查询会走索引嘛（索引下推） 答案：如果查询条件是a=x and b=y and c=z and d=o，那么会走索引idx(a_b_c_d)。如果查询条件是a=x and b=y，也会走索引，但只使用了索引的前两个字段。如果查询条件是a=x and b=y and c and d进行范围查询，那么可能会走索引，但具体情况取决于MySQL的查询优化器，它可能会使用索引下推（Index Condition Pushdown）来优化查询。

2. 问题：简单介绍一下Redis的数据结构 答案：Redis支持多种数据结构，包括：

• 字符串（Strings）：用于存储字符串和二进制数据。

• 列表（Lists）：按照插入顺序排序的字符串列表。

• 集合（Sets）：无序且元素唯一的字符串集合。

• 有序集合（Sorted Sets）：集合中的每个元素都关联一个分数，

以便对元素进行排序。

• 哈希（Hashes）：由字段和值组成的映射，字段和值都是字符串。

• 位图（Bitmaps）：以位为单位进行存储，适用于布尔值的高效存储。

• HyperLogLog：用于估计集合的基数，占用空间非常小。

• 流（Streams）：用于记录时间序列数据，类似于日志。

1. 问题：介绍一下Zset的数据结构，一般用于什么场景 答案：Zset（有序集合）的数据结构是由跳跃表（Skip List）和哈希表组成的。跳跃表用于按分数排序元素，哈希表用于快速访问元素。Zset一般用于以下场景：

• 排行榜：根据用户得分进行排序。

• 时间序列数据：记录事件的时间戳，并进行排序。

• 优先队列：根据优先级处理任务。

1. 问题：介绍一下大Key和热Key分别是什么情况 答案：大Key和热Key的情况如下：

• 大Key：指的是存储在Redis中的单个键值对占用内存非常大的情况，通常是由于存储了大量的数据或复杂的数据结构。

• 热Key：指的是在短时间内访问频率非常高的键，通常是由于某些键值对在业务中被频繁访问。

1. 问题：如何解决大Key问题，以及如何解决热Key问题 答案：解决大Key和热Key问题的方法如下：

• 大Key问题： a. 分片：将大Key拆分成多个小Key。 b. 数据结构优化：使用更适合的数据结构来存储数据。 c. 定期监控和清理：及时发现并处理大Key。

• 热Key问题： a. 使用缓存：在应用层缓存热Key，减少对Redis的访问。 b. 读写分离：将热Key的读操作分发到多个从节点。 c. 使用Redis的持久化策略：将热Key持久化到磁盘，避免Redis重启后重新计算。

1. 问题：Redis的内存淘汰策略是什么 答案：Redis的内存淘汰策略定义了当内存达到最大限制时，如何选择并淘汰键以释放内存。常见的淘汰策略包括：

• noeviction：不淘汰任何键，对写操作返回错误。

• allkeys-lru：淘汰最久未使用的键。

• allkeys-random：随机淘汰键。

• volatile-lru：淘汰设置了过期时间的最久未使用的键。

• volatile-random：随机淘汰设置了过期时间的键。

• volatile-ttl：淘汰即将过期的键。

1. 问题：Redis的默认key过期策略是什么 答案：Redis的默认key过期策略是被动过期，即当客户端访问一个键时，Redis会检查该键是否过期，如果过期则删除。此外，Redis还会定期主动扫描过期键，但这是基于概率的，不是严格的定时任务。

2. 问题：怎么理解Java的三大特性（面向对象三大特性） 答案：Java的三大特性是封装、继承和多态，它们是面向对象编程的基础：

• 封装：将对象的实现细节隐藏起来，仅对外暴露公共的接口。

• 继承：允许子类继承父类的属性和方法，实现代码的复用。

• 多态：允许不同类的对象对同一消息做出响应，即同一操作作用于不同的对象时可以有不同的解释和行为。

1. 问题：Java的“一次编译，处处运行”是如何理解的 答案：Java的“一次编译，处处运行”指的是Java程序在编译时不是直接编译成机器码，而是编译成平台无关的字节码。这些字节码可以在任何安装了Java虚拟机（JVM）的平台上运行，JVM负责将字节码解释或编译成本地机器码。

2. 问题：他是为什么可以平台间通用的 答案：Java可以平台间通用是因为它采用了字节码和JVM机制。字节码是一种中间表示，不依赖于特定的硬件和操作系统。JVM则是一个抽象的计算机，它可以在不同的平台上实现，负责运行字节码，因此Java程序可以在不同的平台上无缝运行。

3. 问题：JavaSE对象的初始化的过程 答案：JavaSE对象的初始化过程如下：

• 分配内存空间：为对象分配内存。

• 初始化成员变量：将成员变量初始化为默认值或显式指定的值。

• 执行构造器代码：执行类构造器的代码，对对象进行进一步初始化。

1. 问题：年轻和老年代详细讲讲，垃圾回收的过程是什么 答案：Java虚拟机的堆内存分为年轻代和老年代：

• 年轻代：用于存放新创建的对象，分为三个区域：Eden、Survivor0和Survivor1。大部分对象在Eden区创建，当Eden区满时，进行Minor GC，存活的对象会被复制到一个Survivor区，非存活对象被清除。

• 老年代：用于存放长时间存活的对象。当Survivor区中的对象经过多次GC后仍然存活，它们会被晋升到老年代。老年代的空间比年轻代大，GC发生的频率也较低，通常采用Major GC（或Full GC）来清理。

垃圾回收的过程主要包括以下几个步骤：

1. 标记阶段：垃圾回收器会标记出所有活动的对象。

2. 清除阶段：垃圾回收器会清除未被标记的对象，释放内存空间。

3. 整理阶段（可选）：在某些垃圾回收算法中，如标记-整理（Mark-Sweep-Compact）算法，会在这个阶段将所有存活的对象移动到内存的一端，以减少内存碎片。

4. 问题：年轻代分为什么区域 答案：年轻代分为以下三个区域：

• Eden区：大多数新创建的对象首先在这里分配。

• Survivor0区（S0）和Survivor1区（S1）：用于存放经过Minor GC后存活的对象。在任一时刻，只有一个Survivor区会被用来存放存活对象，另一个保持空闲状态。

1. 问题：介绍一下几种GC算法 答案：常见的GC算法包括：

• 标记-清除（Mark-Sweep）：标记出所有活动的对象，然后清除未被标记的对象。

• 标记-整理（Mark-Compact）：标记出所有活动的对象，然后将所有存活的对象移动到内存的一端，清理掉边界以外的内存。

• 复制（Copying）：将内存划分为大小相等的两块，每次只使用其中一块。在垃圾回收时，将存活的对象复制到另一块内存区域，然后清理掉旧的内存区域。

• 分代收集（Generational Collection）：根据对象存活周期的不同，将堆内存划分为不同的代，通常有年轻代和老年代，针对不同代采用不同的GC算法。

1. 问题：什么情况下对象会从年轻代晋升到老年代 答案：对象晋升到老年代的情况包括：

• 对象在Survivor区中经历了一定次数的Minor GC后仍然存活（默认是15次，可以通过参数调整）。

• Survivor区中对象的年龄超过了阈值。

• 大对象直接分配到老年代，因为它们在年轻代中的复制成本较高。

1. 问题：默认是多少次没有被回收就可以晋升？ 答案：在HotSpot虚拟机中，默认情况下，一个对象在Survivor区中存活15次Minor GC后，如果没有被回收，就会被晋升到老年代。这个次数可以通过JVM参数-XX:MaxTenuringThreshold来调整。

2. 问题：ArrayList和LinkedList的区别，ArrayList是线程安全吗 答案：ArrayList和LinkedList的区别主要在于它们的底层数据结构和性能特点：

• ArrayList：基于动态数组实现，支持随机访问，查找和更新操作快，但插入和删除操作较慢，因为可能需要移动数组中的元素。

• LinkedList：基于双向链表实现，插入和删除操作快，但查找和更新操作较慢，因为需要遍历链表。

• ArrayList不是线程安全的，如果多个线程同时修改ArrayList，可能会导致数据不一致。如果需要线程安全，可以使用Vector或者Collections.synchronizedList方法包装ArrayList。

1. 问题：HashMap的底层原理是什么，他为什么会导致线程不安全 答案：HashMap的底层原理是基于数组和链表实现的哈希表。主要包含以下几个部分：

• 数组：存储链表的头节点。

• 链表：解决哈希冲突，当多个键映射到同一个数组索引时，它们会形成一个链表。

• 哈希函数：用于计算键的哈希值，以确定其在数组中的位置。

HashMap会导致线程不安全的原因包括：

• 多线程环境下，如果两个或多个线程同时执行put操作并触发扩容，可能会导致链表形成环，从而引发死循环。

• 如果一个线程正在迭代HashMap，另一个线程修改了HashMap的结构（如添加或删除元素），会抛出ConcurrentModificationException。

1. 问题：它会导致什么线程不安全的情景 答案：HashMap在多线程环境中可能会导致以下线程不安全的情景：

• 扩容时的链表环：多个线程同时执行put操作并触发扩容，可能会导致链表形成环。

• 迭代过程中的数据不一致：一个线程在迭代HashMap时，另一个线程修改了HashMap，导致迭代器抛出ConcurrentModificationException。

• 数据覆盖：两个线程同时执行put操作，可能会覆盖彼此的值。

1. 问题：HashMap在不同jdk版本有什么区别，Jdk1.7的HashMap插入是什么情况，会导致什么问题 答案：在JDK 1.7和JDK 1.8中，HashMap的实现有以下主要区别：

• JDK 1.7：使用数组和链表实现，当链表长度超过一定阈值时，链表会转换成红黑树以优化

查询性能。

• JDK 1.7的HashMap在插入时，如果发生哈希冲突，新元素会被添加到链表的头部。如果同时有多个线程执行插入操作，并且触发了扩容，可能会导致链表形成环，从而在后续的get操作中形成死循环。

• JDK 1.8：对HashMap进行了优化，包括链表转红黑树的改进，以及扩容时的转移策略。在扩容时，JDK 1.8的HashMap会保持原有链表的顺序，避免了JDK 1.7中的链表环问题。

1. 问题：如果要用线程安全的Hash表可以用什么数据结构 答案：如果需要线程安全的哈希表，可以使用以下数据结构：

• Hashtable：是Java早期提供的一个线程安全的哈希表实现，但它通过 synchronized 关键字实现同步，可能会导致性能问题。

• ConcurrentHashMap：是Java 5引入的，提供了更好的并发性能，它通过分段锁（Segmentation）来减少锁的竞争。

• Collections.synchronizedMap：可以包装任何Map实现，使其成为线程安全的。

1. 问题：讲讲ConcurrentHashMap的底层原理 答案：ConcurrentHashMap的底层原理如下：

• 分段锁：ConcurrentHashMap将内部数据分为多个段（Segment），每个段其实就是一个小的哈希表。对每个段进行加锁，不同的段可以并发访问，从而减少锁的竞争。

• 红黑树：类似于HashMap，当链表长度超过一定阈值时，链表会转换成红黑树，以优化查询性能。

• CAS操作：ConcurrentHashMap在更新操作时大量使用了CAS（Compare And Swap）操作，以实现无锁的线程安全。

1. 问题：jdk1.7和jdk8下ConcurrentHashMap的底层数据结构区别有哪些 答案：JDK 1.7和JDK 1.8下ConcurrentHashMap的底层数据结构区别如下：

• JDK 1.7：使用分段锁（Segment）来减少锁的竞争，每个Segment包含一个哈希表。

• JDK 1.8：去除了分段锁的设计，改为使用CAS操作和synchronized关键字来实现更细粒度的锁。同时，引入了红黑树来优化链表的查询性能。

1. 问题：尽可能发散地讲讲CAS，CAS是基于指令集的嘛， 答案：CAS（Compare And Swap）是一种硬件级别的原子操作，它通过比较内存中的值和预期的值，如果相同，则将内存中的值替换为新值。CAS是基于CPU指令集的，不同的CPU架构可能提供了不同的实现。

CAS的主要特点和应用场景包括：

• 原子性：CAS操作保证了比较和交换的原子性，是构建无锁编程和并发数据结构的基础。

• 无锁编程：CAS可以用于实现无锁的数据结构，如无锁队列、无锁堆等。

• 并发控制：在并发编程中，CAS可以用来实现线程安全的计数器、原子引用等。

• 基于指令集：CAS操作通常是由CPU指令直接支持的，如x86架构的CMPXCHG指令。

1. 问题：Java中有哪些场景用到CAS或者能够直接封装使用原生CAS的API 答案：在Java中，以下场景和API使用了CAS操作：

• AtomicInteger、AtomicLong等原子类：这些类提供了基于CAS操作的原子性更新方法。

• java.util.concurrent（JUC）包中的并发数据结构：如ConcurrentHashMap、CopyOnWriteArrayList等，它们内部使用了CAS操作来保证线程安全。

• LockSupport类：提供了基于CAS操作的park和unpark方法，用于线程同步。

• sun.misc.Unsafe类：提供了低级别的CAS操作方法，可以直接操作内存。

1. 问题：MySQL的行锁是悲观锁还是乐观锁 答案：MySQL的行锁通常是悲观锁。悲观锁假设在数据操作过程中可能会发生冲突，因此在进行数据操作之前会先加锁，防止其他事务对数据进行修改，直到事务完成释放锁。

2. 问题：数据库中有用到CAS吗，用的是什么机制实现CAS 答案：数据库中确实有用到类似CAS的机制，通常称为乐观锁。乐观锁假设在数据操作过程中不会发生冲突，在更新数据时会检查数据是否被其他事务修改过。如果数据未被修改，则进行更新；如果数据已被修改，则更新失败。实现乐观锁的机制通常包括以下几种：

• 版本号：在数据表中添加一个版本号字段，每次更新数据时检查版本号是否一致。

• 时间戳：在数据表中添加一个时间戳字段，每次更新数据时检查时间戳是否一致。

1. 问题：Java中有哪些数据结构用到CAS或者能够直接封装使用原生CAS的API 答案：Java中以下数据结构和API

使用了CAS或者能够直接封装使用原生CAS的API：

• 原子类（Atomic Classes）：如AtomicInteger、AtomicLong、AtomicReference等，这些类提供了基于CAS操作的原子性更新方法。它们内部使用了sun.misc.Unsafe类的CAS操作来实现。

• 并发集合（Concurrent Collections）：例如ConcurrentHashMap、ConcurrentLinkedQueue、CopyOnWriteArrayList等，这些并发集合在内部实现中使用了CAS来处理并发更新，从而避免使用传统的锁机制。

• 锁（Locks）：如ReentrantLock的内部实现Sync，在某些情况下会使用CAS来尝试获取锁。

• 线程同步工具（Synchronization Tools）：如LockSupport的park和unpark方法，它们使用CAS操作来管理线程的挂起和恢复。

• sun.misc.Unsafe类：这个类提供了低级别的、不安全的操作，包括直接内存访问、对象字段访问、数组操作等。它提供了compareAndSwapInt、compareAndSwapLong和compareAndSwapObject等方法，这些方法直接封装了原生CAS的API，可以在Java代码中直接使用。

1. 问题：简单谈谈OSI七层模型 答案：OSI（Open Systems Interconnection）七层模型是一个概念性框架，用于理解和设计网络体系结构。它将网络通信的过程分为七个不同的层次，每层负责不同的功能。从下到上，这些层次依次为：

2. 物理层（Physical Layer）：负责传输原始比特流，通过物理媒介（如电缆、光纤）进行数据传输。

3. 数据链路层（Data Link Layer）：负责在相邻节点之间可靠地传输数据，处理帧的传输错误、流量控制和访问媒介。

4. 网络层（Network Layer）：负责数据包从源到目的地的传输和路由选择，实现不同网络之间的通信。

5. 传输层（Transport Layer）：提供端到端的数据传输服务，确保数据的完整性和可靠性，如TCP和UDP协议。

6. 会话层（Session Layer）：负责建立、管理和终止会话，即不同应用程序之间的对话。

7. 表示层（Presentation Layer）：负责数据的表示、加密和压缩，确保数据在网络中传输时的正确解释。

8. 应用层（Application Layer）：为应用程序提供网络服务，如HTTP、FTP、SMTP等。

9. 问题：TCP和HTTP的区别 答案：TCP（Transmission Control Protocol）和HTTP（Hypertext Transfer Protocol）是网络通信中不同层次的协议，它们的主要区别如下：

• 协议层级：TCP是传输层协议，它提供面向连接的、可靠的数据传输服务。HTTP是应用层协议，它构建在TCP之上，用于在Web服务器和客户端之间传输超文本数据。

• 目的：TCP旨在提供可靠的数据传输，确保数据正确无误地从源传输到目的地。HTTP则用于规定客户端和服务器之间如何交换数据，即超文本文档的传输格式。

• 连接性：TCP建立的是端到端的连接，保证数据包的顺序和完整性。HTTP基于请求-响应模型，客户端发起请求，服务器返回响应，但HTTP本身不维护持续连接（尽管有HTTP持久连接的机制）。

• 数据传输：TCP传输的是原始数据流，不关心数据内容。HTTP则传输的是结构化的数据，如HTML页面、图片、视频等。

1. 问题：TCP如何保证可靠性的，简单来讲讲 答案：TCP保证可靠性的机制包括：

• 序列号和确认应答：TCP为每个数据包分配一个序列号，接收方收到数据后发送确认应答（ACK），未收到确认的数据包会被重传。

• 重传机制：如果发送方在指定时间内未收到确认应答，它会重传丢失的数据包。

• 流量控制：TCP使用滑动窗口机制来控制发送方的发送速率，避免接收方处理不过来。

• 拥塞控制：TCP通过拥塞窗口来控制网络中的数据流量，避免网络拥塞。

• 数据校验：TCP头部包含一个校验和字段，用于检测数据在传输过程中的任何错误。

1. 问题：简单谈谈Zookeeper 答案：ZooKeeper是一个开源的分布式协调服务，它为分布式应用提供一致性服务。它通常用于维护配置信息、命名服务、分布式同步、组服务等。ZooKeeper的主要特点如下：

• 分布式一致性：ZooKeeper通过其集群中的多个服务器确保数据的一致性，即使部分服务器发生故障，也能保持服务的可用性。

• 数据模型：ZooKeeper的数据模型类似于文件系统，以树形结构存储数据，每个

节点称为ZNode，并且ZNode可以有子节点。

• 顺序一致性：当多个客户端同时对ZooKeeper进行写操作时，ZooKeeper会保证顺序一致性，即先提交的写操作会先完成。

• 高可用性：ZooKeeper通过集群部署，实现高可用性和负载均衡。

• 简单性：ZooKeeper提供了简单的API，客户端可以轻松地使用它来创建、读取、更新和删除ZNode。

• 安全性：ZooKeeper支持客户端认证和权限控制，确保只有授权的客户端才能对ZooKeeper进行操作。

• 动态配置：ZooKeeper允许在运行时动态地添加或移除服务器，系统可以自动适应这些变化。

1. 问题：同步和异步的区别是什么 答案：同步和异步的区别主要在于处理任务的方式：

• 同步（Synchronous）：同步处理是指任务在执行过程中会阻塞调用线程，直到任务完成。例如，传统的阻塞式I/O操作。

• 异步（Asynchronous）：异步处理是指任务在执行过程中不会阻塞调用线程，调用线程可以继续执行其他任务。当任务完成时，会通过回调函数或事件通知调用线程。例如，非阻塞式I/O操作、回调机制等。

1. 问题：同步阻塞和异步阻塞的区别是什么 答案：同步阻塞和异步阻塞的区别在于阻塞的方式和线程的状态：

• 同步阻塞：在同步阻塞中，当线程执行到某个同步方法或同步块时，如果该同步资源已经被其他线程占用，那么当前线程会被阻塞，直到同步资源被释放。线程会进入阻塞状态，等待其他线程释放同步资源。

• 异步阻塞：在异步阻塞中，线程可能不会被阻塞，而是进入等待状态。例如，当一个线程等待一个消息队列中的消息时，它不会被阻塞，而是进入等待状态，直到消息到达。

1. 问题：谈谈NIO，谈谈NIO的三大组件 答案：NIO（New I/O）是Java 1.4引入的一个新的I/O API，用于处理更大数据量的操作。它提供了比传统的I/O API（如java.io包）更高效的I/O操作。NIO的三大组件包括：

• 通道（Channels）：通道是双向的，可以读取和写入数据。它取代了流（Stream），提供了更灵活的I/O操作。

• 缓冲区（Buffers）：缓冲区是NIO中用于存储数据的容器，它可以被通道读取或写入。缓冲区提供了对数据的直接操作，例如可以对其进行扩容或复用。

• 选择器（Selectors）：选择器用于监控多个通道，并决定哪个通道已经准备好进行读取或写入操作。它允许一个线程同时处理多个通道。

1. 问题：谈谈Buffer的几大属性 答案：Buffer是一个用于存储数据的容器，它具有以下属性：

• 容量（Capacity）：Buffer可以存储的最大数据量。

• 限制（Limit）：Buffer可以读取或写入的最大数据量，限制总是大于或等于位置（Position）。

• 位置（Position）：下一次读取或写入数据的位置。

• 标记（Mark）：用于记录Buffer中的一个位置，之后可以通过调用reset()方法返回到这个位置。

1. 问题：说说你对IOC和AOP的理解 答案：IOC（Inversion of Control）和AOP（Aspect-Oriented Programming）是两种不同的编程范式：

• IOC（控制反转）：IOC是一种设计模式，它将对象的创建和绑定职责从应用程序代码中转移到外部容器。在IOC容器中，容器负责创建对象、管理对象的生命周期以及将对象相互绑定。这种设计模式使得应用程序的代码更加模块化，便于管理和维护。

• AOP（面向切面编程）：AOP是一种编程范式，它允许开发者将横切关注点（如日志、安全、事务管理等）与业务逻辑分离，并将它们封装在所谓的“方面（Aspect）”中。AOP提供了在不修改现有代码的情况下，将横切关注点添加到应用程序中的能力。

1. 问题：Java的动态代理可以聊聊吗 答案：Java

的动态代理是一种运行时代理机制，它允许你创建一个代理对象，这个代理对象可以拦截并处理对真实对象的方法调用。动态代理通常用于实现切面编程（AOP）中的横切关注点。

动态代理的主要特点和用法包括：

• 代理对象创建：动态代理在运行时创建，而不是在编译时。

• 拦截方法调用：代理对象可以拦截对真实对象的方法调用，并在调用前后添加额外的逻辑。

• 代理实现：Java提供了一个代理类java.lang.reflect.Proxy，通过它创建动态代理对象。

• 接口代理：动态代理要求真实对象实现一个或多个接口，代理对象也实现相同的接口。

• 增强功能：通过代理对象，可以在不修改真实对象代码的情况下，为其添加额外的功能，如日志记录、性能监控等。

• 使用场景：动态代理常用于实现日志记录、事务管理、权限校验等横切关注点。

1. 问题：CGLIB和JDK动态代理的区别和应用场景 答案：CGLIB（Code Generation Library）和JDK动态代理是两种不同的Java动态代理实现，它们的主要区别和应用场景如下：

• 实现方式：

  • JDK动态代理：基于Java的代理机制，通过反射调用真实对象的方法。

  • CGLIB代理：通过字节码生成技术，创建一个真实对象的子类，并重写父类的方法。

• 适用场景：

  • JDK动态代理：适用于真实对象实现接口的情况。

  • CGLIB代理：适用于真实对象没有实现接口的情况。

• 性能：CGLIB代理由于需要生成字节码，因此性能可能略低于JDK动态代理。

• 使用场景：

  • JDK动态代理：适用于需要代理接口的情况，如AOP框架中的拦截器。

  • CGLIB代理：适用于需要代理非接口的情况，如Spring框架中的AOP。

26.汇川技术一面

1. 问题：你老家在哪，你对于工作地点有要求吗，家里有弟弟妹妹吗，你的平时爱好是什么？

2. 问题：你平时有哪些学习计划，最近有什么提升的学习计划吗？

1. 答案：我通常会制定一个长期的学习计划，包括技术提升、知识拓展和软技能培养。最近，我计划深入学习大数据处理技术，以提升自己在处理大规模数据集方面的能力。

1. 问题：你平时在学习过程中遇到问题是怎么解决的？

1. 答案：在学习过程中，我会尝试通过查阅资料、阅读相关书籍和文章来解决遇到的问题。如果自己无法解决，我会向同事、导师或在线社区寻求帮助。此外，我也会通过实践来加深对知识点的理解。

1. 问题：谈谈MySQL的问题，MySQL在运行一条SQL期间发生了什么？

1. 答案：MySQL在运行一条SQL期间，首先会对SQL语句进行解析，确定查询条件和执行计划。然后，根据执行计划，MySQL会从数据表中检索数据，并按照查询条件进行排序、分组等操作。最后，MySQL将处理后的结果返回给客户端。

1. 问题：MySQL中调用语句的时候，where，having，group，sum，max这些执行顺序如何？

1. 答案：在MySQL中，这些子句的执行顺序为：from -> where -> group by -> having -> select -> order by。具体来说，先执行from子句，然后根据where子句过滤数据，接着根据group by子句对数据进行分组，然后根据having子句对分组后的数据进行筛选，再执行select子句选择需要显示的字段，最后根据order by子句对结果进行排序。

1. 问题：其中聚合函数的顺序是怎么排的？

1. 答案：聚合函数的顺序与select子句中的字段顺序一致。也就是说，在select子句中，聚合函数会按照它们出现的顺序进行计算。

1. 问题：对于海量数据的深度分页是怎么提高效率的？

1. 答案：对于海量数据的深度分页，可以采用以下方法提高效率：

   • 利用索引：为经常用于分页查询的列创建索引，提高查询速度。

   • 减少返回结果：只返回当前页和上一页的数据，减少数据库查询负担。

   • 分页查询优化：使用MySQL的LIMIT和OFFSET关键字进行分页查询，避免使用SELECT *。

1. 问题：一道SQL：有id，身份证id，人名，其中有非常多的冗余数据（身份证人名相同，id不同），要求删除其中重复名字的数据。

1. 答案：可以使用以下SQL语句来删除重复名字的数据：

   DELETE a FROM table_name a, table_name b WHERE a.name = b.name AND a.id > b.id;

     这段SQL语句通过比较两个表中的name字段，删除id较大的重复记录。

1. 问题：Java的集合有哪些，你对他的了解有哪些，可以尽可能发散地聊聊这些集合之间的关联和应用场景？

1. 答案：Java中的集合主要包括List、Set、Map三种类型。

   • List：有序集合，元素可以重复。常见的实现有ArrayList、LinkedList等。

   • Set：无序集合，元素不能重复。常见的实现有HashSet、TreeSet等。

   • Map：键值对集合，键不能重复。常见的实现有HashMap、TreeMap等。

     这些集合之间的关联和应用场景如下：

   • List和Set：List可以看作是可重复的Set，Set可以看作是元素唯一的List。List适用于需要顺序和重复元素的场景，Set适用于需要去重和无序的场景。

   • Map：Map中的键和值可以是任何类型的对象，适用于需要键值对存储的场景。

1. 问题：红黑树结构是什么，为什么HashMap使用红黑树，而不是B+树？

1. 答案：红黑树是一种自平衡的二叉搜索树，每个节点都有颜色属性，满足红黑树的特性。HashMap使用红黑树是为了提高查询效率，尤其是在链表长度较长时，红黑树可以避免链表过长导致的查询性能下降。

1. 问题：请你详细讲讲HashMap的原理？

1. 答案：HashMap是基于哈希表实现的，它存储键值对（key-value）。当插入键值对时，首先计算键的哈希值，然后

根据哈希值找到对应的数组索引，如果该索引位置已经有元素，则通过链表或红黑树结构来处理哈希冲突。HashMap的原理主要包括以下几个步骤：

1. 哈希函数：将键（key）通过哈希函数计算出哈希值，哈希值用于确定键值对在哈希表中的位置。

2. 数组索引：哈希值通过某种方式（如取模运算）转换为数组索引，该索引对应哈希表中的一个数组元素。

3. 链表或红黑树：如果多个键通过哈希函数计算得到的数组索引相同，即发生了哈希冲突，这些键值对会以链表或红黑树的形式存储在同一个数组索引位置。

4. 插入和查找：插入操作时，先计算哈希值，然后根据哈希值找到数组索引，如果索引位置为空，则直接插入；如果已有元素，则通过链表或红黑树结构来处理哈希冲突。查找操作时，先计算哈希值，然后根据哈希值找到数组索引，再通过键在链表或红黑树中查找对应的键值对。

5. 扩容：当哈希表中的元素数量超过阈值时，HashMap会进行扩容，即创建一个新的哈希表，将原有元素重新计算哈希值并插入到新哈希表中。

6. 键值对存储：每个键值对在哈希表中以Node对象的形式存储，Node对象包含键、值、哈希值和指向下一个节点的指针（链表结构）或红黑树节点（红黑树结构）。

7. 迭代：可以通过迭代器或for-each循环来遍历HashMap中的所有键值对。

HashMap的性能取决于哈希函数的质量和哈希表的负载因子（load factor），当负载因子过高时，会增加哈希冲突的概率，导致性能下降。因此，合理选择哈希函数和负载因子对于优化HashMap的性能至关重要。

1. 问题：红黑树和平衡二叉树之间有什么区别和关系？ 答案：红黑树和平衡二叉树都是自平衡的二叉搜索树，它们的主要区别在于实现细节和查找效率。

• 平衡二叉树：平衡二叉树是红黑树的一个特例，它要求每个节点的左右子树的高度差不超过1。平衡二叉树包括AVL树、红黑树等。

• 红黑树：红黑树是平衡二叉树的一种实现，它要求每个节点要么是红色，要么是黑色，并且满足以下性质：

  • 每个节点要么是红色，要么是黑色。

  • 根节点是黑色。

  • 每个叶子节点（NIL节点，空节点）是黑色。

  • 如果一个节点是红色，则它的两个子节点都是黑色。

  • 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

红黑树通过以上性质保证了树的高度平衡，从而提高了查找、插入和删除操作的效率。

1. 问题：Redis中如何解决缓存穿透问题，（缓存空对象和布隆过滤器） 答案：Redis中解决缓存穿透问题通常使用布隆过滤器（Bloom Filter）。布隆过滤器是一种空间效率较高的概率型数据结构，可以用来判断一个元素是否属于某个集合。

在Redis中，可以使用布隆过滤器来判断一个请求是否合法。如果布隆过滤器认为该请求是非法的，则可以不从缓存中查找数据，而是直接返回错误信息，从而避免缓存穿透问题。此外，也可以在缓存中存储空对象，当缓存穿透发生时，直接返回空对象，而不是返回null，以避免null值在客户端引发空指针异常。

1. 问题：如果有多个重复id的用户进来发送不同的非法请求来成功打击到你的redis该怎么办？ 答案：如果有多个重复id的用户发送不同的非法请求来攻击Redis，可以采取以下措施：

• 增加访问限制：限制每个用户的访问频率，避免用户频繁发送请求。

• 黑白名单：使用黑白名单机制，对非法用户进行限制或禁止访问。

• 缓存预热：在系统启动时或定期预热缓存，避免缓存为空。

• 分布式缓存：使用分布式缓存系统，如Redis集群，提高系统的可用性和扩展性。

1. 问题：从Nginx和Redis层面讲讲（Redis–布隆过滤器） 答案：在Nginx和Redis层面，可以使用布隆过滤器来减少对Redis的访问次数，从而提高系统性能。具体来说，可以采用以下策略：

• Nginx层：在Nginx中使用模块（如lua-resty-bloom）来实现布隆过滤器，用于过滤掉恶意请求。

• Redis层：在Redis中存储布隆过滤器的配置和状态，如哈希函数、布隆过滤器的位数和误差率等。

• 请求处理：当Nginx接收到一个请求时，首先使用布隆过滤器进行快速过滤，如果请求被过滤器认为是合法的，则直接处理；如果被过滤器认为是非法的，则不访问Redis，而是返回错误信息或直接拒绝请求。

1. 问题：布隆过滤器的底层原理是什么，有哪些配置参数，能控制什么效果？ 答案：布隆过滤器的底层原理是通过多个哈希函数对输入的元素进行映射，并将映射结果存储在一个固定大小的位数组中。如果位数组中至少有k个位置被映射到的哈希值所标记，那么这个元素被认为属于集合。

布隆过滤器的配置参数包括：

• 位数组大小：决定了布隆过滤器的存储空间和误报率。位数组越大，误报率越低，但存储空间和计算成本越高。

• 哈希函数数量：决定了布隆过滤器的准确性和计算成本。哈希函数数量越多，准确率越高，但计算成本也越高。

• 误报率：布隆过滤器的误报率可以通过调整位数组大小和哈希函数数量来控制。误报率越低，准确率越高，但布隆过滤器的性能也越差。

布隆过滤器的配置参数可以控制其在不同场景下的性能和准确率。在实际应用中，需要根据具体需求和资源情况来调整这些参数。

布隆过滤器（Bloom Filter）是一种空间效率极高的概率型数据结构，它用于测试一个元素是否属于集合。它是由 Burton Howard Bloom 在 1970 年提出的。布隆过滤器的特点是高效地插入和查询，同时它也有一定的误判率（即错误地判断一个元素属于集合），但是它绝不会漏判（即如果判断一个元素不属于集合，那么这个元素一定不在集合中）。

布隆过滤器的机制如下：

基本组成

1. 位数组：布隆过滤器使用一个位数组（bit array）来存储信息，初始时，所有的位都置为0。

2. 哈希函数：布隆过滤器需要依赖多个哈希函数，这些哈希函数可以将一个元素映射到位数组中的不同位置。

添加元素

当向布隆过滤器中添加一个元素时，步骤如下：

1. 使用多个哈希函数分别对元素进行哈希，得到位数组中的几个位置索引。

2. 将这几个位置上的位设置为1。

检查元素是否存在

当检查一个元素是否存在于布隆过滤器中时，步骤如下：

1. 使用同样的多个哈希函数对元素进行哈希，得到位数组中的几个位置索引。

2. 检查这些位置上的位是否全部为1。

   1. 如果全部为1，则元素**可能**在集合中。

   2. 如果有任何一位是0，则元素**一定不在**集合中。

误判的原理

布隆过滤器可能出现误判的原因是哈希碰撞。由于布隆过滤器使用有限的位数组，随着元素的不断添加，位数组中的某些位可能由于不同的元素映射到相同的位置而被多次设置为1。这样，当查询一个实际上并不在集合中的元素时，由于这些位置上的位已经是1，布隆过滤器可能会错误地判断该元素存在于集合中。

优化和变种

• 可扩展性布隆过滤器：当位数组填满时，可以通过增加位数组的大小来减少误判率。

• 计数布隆过滤器：使用计数数组代替位数组，每个位置存储一个计数而不是0或1，这样可以支持元素的删除操作。

• 层叠哈希：使用多个哈希函数的层叠组合，进一步提高哈希的均匀性。

使用场景

布隆过滤器适用于那些允许一定误判率，但需要极高查询效率和存储空间的应用场景，如：

• 网络缓存系统的缓存查找

• 防止推荐系统推荐重复内容

• 查询一个元素是否在一个大数据集中

• 防止数据库查询不存在的主键

布隆过滤器的实现和维护相对简单，但它为我们提供了一种在空间和时间效率上非常优秀的处理大规模数据集合的方法。

27.moka成都二面

1. 问题：说一下对CAS的理解

1. 答案：CAS（Compare And Swap）是一种硬件级别的原子操作，它允许一个处理器对内存中的值进行原子操作，以避免多线程环境下由于竞争条件导致的并发问题。CAS操作通常包含三个操作数：内存位置（V）、预期原值（A）和新值（B）。当执行CAS操作时，处理器会首先读取内存位置的值，将其与预期原值进行比较。如果相等，处理器会将内存位置的值更新为新值；如果不等，处理器将不执行任何操作。

1. 问题：sync和cas实现方式上有什么差异

1. 答案：sync通常指的是同步锁，它依赖于CPU提供的原子操作指令来保证线程安全。而CAS是一种无锁（lock-free）的同步机制，它通过硬件层面的原子操作来实现线程间的同步，避免了传统同步锁可能带来的性能开销。

1. 问题：sync底层依赖cpu的操作吗

1. 答案：是的，sync底层依赖CPU提供的原子操作指令来保证线程安全。这些指令通常包括test-and-set、test-and-set-and-test、test-and-set-and-test-and-set等，它们可以保证在多线程环境下，对共享资源的访问是原子性的。

1. 问题：不依赖cpu指令能实现锁吗

1. 答案：是的，不依赖CPU指令也能实现锁。例如，可以通过软件层面实现的锁（如互斥锁、读写锁）来实现线程同步。这些锁通常依赖于操作系统提供的线程同步机制，如POSIX的pthread_mutex_lock和pthread_mutex_unlock等函数。

1. 问题：为什么要满足最左匹配

1. 答案：在数据库索引中，最左匹配原则是指在进行索引查找时，应首先使用索引的最左边列进行匹配。这是因为索引通常是按照列的顺序创建的，最左边的列具有最高的区分度，能够帮助数据库快速定位到目标数据。如果最左边的列已经能够区分出不同的数据，那么数据库就不需要继续使用后面的列进行索引查找，这样可以减少索引查找的时间，提高查询效率。

1. 问题：abc的联合索引，没有a，会不会有些情况下也能得到不错的复杂度

1. 答案：是的，即使在联合索引中没有包含列a，在某些情况下仍然可以得到不错的复杂度。例如，如果列b和列c的组合具有很高的区分度，那么即使没有列a，数据库优化器仍然可能会选择使用列b和列c的组合作为索引查找的起点。但是，最左匹配原则仍然适用，如果列a具有更高的区分度，数据库优化器仍然会首先使用列a进行索引查找。

1. 问题：比如a的值只有两个值

1. 答案：如果列a的值只有两个值，那么在这种情况下，即使没有列b和列c，数据库优化器也可能选择使用列a作为索引查找的起点。但是，由于列a的值只有两个，这意味着区分度很低，查询可能会退化到全表扫描。因此，最左匹配原则仍然非常重要，如果可能的话，应该确保列a、b和c的组合具有足够的区分度，以避免全表扫描。

1. 问题：怎么扫描比全表扫描快

1. 答案：扫描比全表扫描快的原因在于索引能够快速定位到目标数据，而全表扫描则需要逐行遍历整个表，时间复杂度为O(n)，其中n是表中的行数。相比之下，索引扫描的时间复杂度通常为O(log n)或O(1)，取决于索引的类型和查询条件。

1. 问题：怎么优化这个过程让它不去全表扫描，提高它的效率，尽快找到数据

1. 答案：为了优化查询过程，避免全表扫描，可以采取以下措施：

   • 创建合适的索引：确保表中有针对查询条件的索引，以提高查询效率。

   • 优化查询语句：确保查询语句中包含了所有必要的索引列，以满足最左匹配原则。

   • 调整查询条件：如果可能的话，调整查询条件，使其能够使用已存在的索引。

1. 问题：有a和b的两个单独索引，条件是a=?or b=?这种情况优化器会怎么办

1. 答案：在这种情况下，优化器可能会选择使用a索引或b索引，具体取决于哪个索引能够更快地定位到目标数据。如果a索引中的数据更少，优化器可能会选择使用a索引；如果b索引中的数据更少，优化器可能会选择使用b索引。如果两个索引的数据量相近，优化器可能会随机选择一个索引

1. 问题：优化器怎么判断什么时候走全表扫描还是走索引?全表扫描有没有可能比索引扫描快

1. 答案：优化器判断是否走全表扫描还是走索引，会考虑多个因素，包括：

• 索引的选择性：如果索引的选择性很高，即能够有效区分不同的行，优化器更可能选择索引扫描。

• 数据的分布：如果数据在索引列上分布均匀，索引扫描效率较高。如果数据分布不均匀，全表扫描可能更快。

• 索引的统计信息：优化器会根据索引的统计信息来判断数据分布，以决定是否使用索引。

• 查询的具体条件：如果查询条件中包含的列不在索引中，或者查询条件与索引列不匹配，可能需要全表扫描。

全表扫描通常比索引扫描慢，因为全表扫描需要遍历整个表的数据，而索引扫描只需要遍历索引中的数据。但在某些情况下，全表扫描可能比索引扫描快，例如当表非常小，或者当查询条件导致索引无法有效利用时。

1. 问题：NIO比阻塞IO效率高，为什么

1. 答案：NIO（Non-blocking I/O）比阻塞IO效率高的原因在于它能够同时处理多个I/O操作，而不需要等待每个操作完成。在阻塞IO中，当一个线程正在进行I/O操作时，它会被阻塞，直到操作完成，这期间该线程无法处理其他任务。而在NIO中，线程可以注册多个I/O操作，并在等待I/O操作完成时执行其他任务，从而提高了整体的系统吞吐量和效率。

1. 问题：NIO会占用CPU的时间吗

1. 答案：是的，NIO会占用CPU的时间。在NIO中，线程负责注册和处理I/O操作，当I/O操作完成时，线程会处理这些操作。因此，NIO操作需要线程进行参与，这会占用CPU的时间。不过，NIO的目的是通过并行处理I/O操作来提高系统性能，而不是减少CPU的使用。

1. 问题：优化了哪个过程

1. 答案：NIO优化了I/O操作的过程。通过非阻塞I/O，NIO允许一个线程同时处理多个I/O操作，从而提高了系统的吞吐量和效率。

1. 问题：报表导出优化30s以上，这个是优化的CPU时间，还是时延

1. 答案：报表导出优化30s以上，通常指的是优化了整个操作的时延。时延是指从发起操作到操作完成所需的时间，它包括了CPU处理时间、I/O操作时间、网络传输时间等多个方面。因此，优化30s以上的时延意味着整个报表导出操作的完成时间被显著缩短。

1. 问题：为什么可以优化到30s这个幅度

1. 答案：可以优化到30s以上的幅度，是因为优化了报表导出过程中的多个瓶颈。这可能包括：

• 优化了数据库查询：通过创建更合适的索引、优化查询语句等方式，提高了查询效率。

• 优化了数据处理：通过并行处理、减少不必要的计算等方式，提高了数据处理速度。

• 优化了I/O操作：通过使用NIO、优化数据存储方式等方式，提高了I/O操作效率。

• 优化了网络传输：通过压缩数据、使用更快的网络等方式，减少了网络传输时间。

通过这些优化措施，可以显著缩短报表导出操作的完成时间，从而实现30s以上的优化幅度。

28.腾讯一面

1. 问题：二叉查找树、二叉平衡树、红黑树的区别和联系。

答案：二叉查找树（BST）是一种数据结构，它具有以下性质：每个节点的左子树上所有节点的值均小于它的根节点的值，右子树所有节点的值均大于它的根节点的值。二叉平衡树是二叉查找树的一种，它要求任何节点的两个子树的高度最大差别为1，以保持树的平衡，从而确保查找、插入和删除操作的最坏情况时间复杂度为O(log n)。红黑树是平衡二叉查找树的一种，它通过约束节点的颜色和规则来保证树的平衡，这些规则包括：每个节点非红即黑、根节点是黑色、所有叶子节点（NIL节点）是黑色、红色节点的子节点必须是黑色、从任一节点到其每个叶子节点的所有路径都包含相同数目的黑色节点。红黑树相比AVL树（一种常见的二叉平衡树）在插入和删除时需要旋转的次数更少。

1. 问题：如果要维护一个集合中TOP10最大的数，用什么数据结构。

答案：可以使用最小堆（Min Heap）来维护集合中TOP10最大的数。最小堆是一种特殊的完全二叉树，其中每个父节点的值小于或等于其所有子节点的值。通过维护一个大小为10的最小堆，当堆的大小超过10时，弹出堆顶元素（最小的元素），这样可以保证堆中始终保存着集合中最大的10个数。

1. 问题：熟悉大数据组件吗，比如Spark、Flink。

答案：是的，Spark和Flink都是目前流行的大数据处理框架。Apache Spark是一个快速、通用的大数据处理引擎，它提供了丰富的API用于数据处理、机器学习、流处理等，其核心是弹性分布式数据集（RDD）以及对RDD的操作。Apache Flink是一个流处理框架，它同时支持流处理和批处理，具有高吞吐量、低延迟的特点，并且提供了事件驱动的计算模型。

1. 问题：覆盖索引是什么。 答案：覆盖索引（Covering Index）是一种数据库索引，它包含了查询中所需要的所有字段。当执行一个查询时，如果所有需要的数据都可以从索引中获取，而不需要回表查询，那么这个索引就被称作覆盖索引。使用覆盖索引可以显著提高查询性能，因为它减少了磁盘I/O操作。

2. 问题：聚集索引和非聚集索引区别。 答案：聚集索引（Clustered Index）和非聚集索引（Non-Clustered Index）的主要区别在于数据行的物理存储方式。聚集索引决定了表中数据的物理顺序，每个表只能有一个聚集索引，因为数据行只能有一种物理顺序。非聚集索引与数据的物理存储顺序无关，它包含索引键值和指向数据行的指针，一个表可以有多个非聚集索引。

3. 问题：给几个SQL，看会不会走索引（注意order by id）。 答案：

• SELECT * FROM users WHERE id = 10; // 会走索引，因为使用了主键查询

• SELECT name FROM users WHERE id = 10; // 会走索引，因为使用了主键查询，并且是覆盖索引

• SELECT * FROM users ORDER BY id; // 可能会走索引，如果id是聚集索引

• SELECT * FROM users ORDER BY name; // 不会走索引，除非对name字段创建了索引

1. 问题：如果要优化SQL，用什么方法。 答案：优化SQL的方法包括但不限于：

• 确保使用了合适的索引。

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

• 使用JOIN代替子查询。

• 使用EXPLAIN分析查询计划。

• 避免在WHERE子句中使用函数或计算。

• 优化数据模型，减少数据冗余。

• 使用批处理和缓存策略。

1. 问题：EXPLAIN需要关注那些字段。 答案：在使用EXPLAIN分析查询计划时，需要关注以下字段：

• id：查询中SELECT的序列号。

• select_type：查询的类型。

• table：显示这一行的数据是关于哪张表的。

• type：连接类型，如ALL、index、range等。

• possible_keys：指出MySQL能使用哪些索引来优化查询。

• key：实际使用的索引。

• key_len：使用的索引的长度。

• ref：显示索引的哪一列被使用了。

• rows：MySQL认为必须检查的用来返回请求数据的行数。

• Extra：包含MySQL解决查询的详细信息。

1. 问题：EXPLAIN的Extra列中出现的内容，Using Index和Using Where的区别。 答案：EXPLAIN的Extra列提供了MySQL优化器如何执行查询的额外信息。Using Index表示MySQL使用了覆盖索引，不需要回表查询；而Using Where表示MySQL服务器将在存储引擎检索行后再进行过滤，即没有使用索引进行过滤。

2. 问题：数据库用来做分布式锁怎么做。 答案：数据库实现分布式锁通常有以下几种方式：

• 使用表锁或行锁：通过在数据库中创建特定的锁表，并在需要加锁时插入或更新记录来实现。

• 使用唯一索引：通过插入带有唯一索引的记录来实现锁，如果插入成功则获取锁，删除记录则释放锁。

• 使用乐观锁或悲观锁：通过在记录中添加版本号字段，进行版本检查来实现。

1. 问题：什么SQL会加排他锁。 答案：以下SQL操作会加排他锁（X锁）：

• INSERT、UPDATE、DELETE操作，因为这些操作需要修改数据。

• SELECT … FOR UPDATE，在事务中锁定选择的行，防止其他事务修改。

1. 问题：JVM的线程状态。 答案：JVM中的线程状态包括：

• 新建（New）：创建后尚未启动的线程状态。

• 可运行（Runnable）：包括运行和就绪状态的线程，等待被CPU调度。

• 阻塞（Blocked）：等待获取监视器锁而阻塞的线程状态。

• 等待（Waiting）：无限期等待另一个线程执行特定操作（如通知）的线程状态。

• 计时等待（Timed Waiting）：在一定时间内等待另一个线程执行特定操作的线程状态。

• 终止（Terminated）：线程执行完成后的状态。

1. 问题：什么是Happens-before。 答案：Happens-before是Java内存模型（JMM）中定义的一个概念，用来指定两个操作之间的执行顺序。如果操作A happens-before 操作B，那么操作A的结果对操作B可见，且操作A的执行顺序在操作B之前。

2. 问题：原子性和可见性是什么。 答案：原子性指的是一个操作（或一系列操作）要么全部执行，要么全部不执行，不会出现部分执行的情况。可见性指的是当一个线程修改了共享变量的值后，其他线程能够立即得知这个修改。

3. 问题：为什么需要保证可见性，是什么问题导致的。 答案：需要保证可见性是因为在多线程环境中，由于CPU缓存的存在

，每个线程可能会将共享变量读取到自己的CPU缓存中，如果没有适当的同步机制，一个线程对变量的修改可能不会立即对其他线程可见，从而导致不一致的问题。这种情况是由以下问题导致的：

• CPU缓存：现代CPU通常都有自己的缓存，线程对变量的修改可能只发生在CPU缓存中，而没有立即写入主内存。

• 编译器优化：编译器在生成机器代码时可能会进行指令重排，这可能导致程序的执行顺序与代码顺序不一致。

• 处理器优化：处理器也可能会对输入的指令进行重排，以优化执行效率。

1. 问题：CPU的缓存一致性是什么。 答案：CPU的缓存一致性是指在一个多核处理器系统中，所有的CPU核心都能够保持对共享数据的一致性视图。当某个核心修改了共享数据时，这个修改需要以一种可预测的方式传播到其他核心的缓存中，以保持数据的一致性。缓存一致性协议，如MESI（Modified, Exclusive, Shared, Invalid），用于确保这种一致性。

2. 问题：进程通信的几种方式。 答案：进程通信（Inter-Process Communication, IPC）的方式包括：

• 管道（Pipes）：允许在父子进程间或兄弟进程间进行单向数据传输。

• 命名管道（FIFOs）：类似于管道，但可以在无关进程间进行通信。

• 消息队列（Message Queues）：允许进程以消息为单位进行数据交换。

• 信号量（Semaphores）：主要用于同步，也可以用于进程间通信。

• 共享内存（Shared Memory）：允许多个进程共享一段内存空间进行数据交换。

• 套接字（Sockets）：提供了在不同主机上的进程间进行双向通信的能力。

1. 问题：进程是怎么生成的（调用什么函数，C++）。 答案：在C++中，进程通常是通过调用fork()函数生成的。fork()函数在父进程中调用，会创建一个与父进程几乎完全相同的新进程（子进程）。在子进程中，fork()返回0，而在父进程中，fork()返回子进程的进程ID。

2. 问题：线程是怎么生成的（调用什么函数，C++）。 答案：在C++中，线程可以通过调用std::thread对象来创建。以下是一个简单的例子：

#include <thread> #include <iostream> void threadFunction() { std::cout << "Hello from the thread!" << std::endl; } int main() { std::thread myThread(threadFunction); myThread.join(); // 等待线程结束 return 0; }

1. 问题：TCP有几种拥塞控制的方式。 答案：TCP拥塞控制的主要方式包括以下几种：

• 慢启动（Slow Start）

• 拥塞避免（Congestion Avoidance）

• 快速重传（Fast Retransmit）

• 快速恢复（Fast Recovery） 这些算法可以组合使用，如TCP Reno和TCP NewReno。

1. 问题：同步和异步、阻塞和非阻塞在概念上区别。 答案：

• 同步（Synchronous）和异步（Asynchronous）：同步操作是指在执行一个操作时，调用者需要等待操作完成才能继续执行；异步操作是指调用者发出操作请求后，可以立即继续执行，而不需要等待操作完成。

• 阻塞（Blocking）和非阻塞（Non-blocking）：阻塞操作是指调用者在执行操作时，如果操作没有立即完成，调用者会一直等待；非阻塞操作是指调用者在执行操作时，即使操作没有立即完成，调用者也会立即返回，不会一直等待。

1. 问题：JDK里面用到什么设计模式，并且举例子。 答案：JDK中使用了多种设计模式，以下是一些例子：

• 单例模式（Singleton）：如java.lang.Runtime类，确保一个类只有一个实例。

• 工厂模式（Factory Method）：如java.util.Calendar类中的getInstance()方法。

• 抽象工厂模式（Abstract Factory）：如java.util.Arrays类中的asList()方法。

• 建造者模式（Builder）：如java.lang.StringBuilder类。

• 适配器模式（Adapter）：如java.util.Arrays.asList()方法返回的列表实际上是适配器，它适配了一个数组。

1. 问题：消息队列的事务了解吗。 答案：消息队列的事务是指一组消息操作要么全部成功，要么全部失败，保证消息处理的原子性和一致性。在消息队列中，事务通常通过以下方式实现：

• 生产者事务：确保消息被可靠地发送到队列，如果发送失败，则进行回滚。

• 消费者事务：确保消息从队列中取出后，可以进行一系列的处理，如果处理失败或出现异常，则进行回滚，保证消息不会丢失也不会被重复处理。在实现消息队列事务时，通常会涉及到以下概念：

• 事务性消息：消息队列支持将一组消息作为一个事务来发送和接收，确保这组消息要么全部成功，要么全部失败。

• 两阶段提交（2PC）：一种分布式事务协议，用于在分布式系统中保持事务的一致性。消息队列可能会使用两阶段提交来确保跨多个服务或节点的操作要么全部成功，要么全部回滚。

• 确认（Acknowledgment）：消费者在处理完消息后，需要向消息队列发送确认，表示消息已经被成功处理。在事务中，确认通常是事务完成的一部分。

例如，在使用RabbitMQ时，可以通过以下方式实现事务：

Channel channel = connection.createChannel(); try { // 开启事务 channel.txSelect(); // 发送消息 channel.basicPublish(exchange, routingKey, null, message.getBytes()); // 提交事务 channel.txCommit(); } catch (Exception e) { // 回滚事务 channel.txRollback(); } finally { // 关闭通道和连接 channel.close(); connection.close(); }

需要注意的是，使用事务会降低消息队列的性能，因为它需要等待事务的确认。因此，在某些场景下，可能会使用其他机制，如发送方确认（publisher confirms）或消费端的手动确认（manual acknowledgments），来保证消息的可靠性，同时避免事务的开销。

29.虾皮二面

1. 问题：表述一下他们部门使用什么技术，然后介绍一下我自己用的什么编程语言。

答案：我们部门主要使用Java作为后端开发语言，同时结合Spring Framework和Spring Boot来构建微服务架构。数据库方面，我们使用MySQL和Redis，其中Redis用于缓存和消息队列。前端技术栈主要包括React和Vue.js。对于大数据处理，我们使用Apache Kafka进行实时数据流处理，以及Apache Spark进行批处理和分析。而我个人的编程语言经验主要集中在Java和Python上，Java用于后端开发，Python则用于数据分析、机器学习以及自动化脚本编写。

1. 问题：如果要自己实现一个hashmap怎么设计（我就把Java的hashmap怎么设计的大概说了一下，然后又要求如果冲突大的情况下怎么简单改进）。

答案：实现一个HashMap的基本设计包括以下几个关键点：

• 使用数组来存储数据，数组的每个槽位称为桶（bucket）。

• 使用哈希函数来计算键的哈希值，并将结果映射到数组的索引上。

• 每个桶可以存储一个或多个键值对，当发生哈希冲突时，可以使用链表或红黑树来处理。

• 当数组容量达到一定阈值时，进行扩容操作，通常是创建一个更大的数组，并将旧数组中的元素重新哈希到新数组中。

如果冲突很大，可以采取以下改进措施：

• 使用更好的哈希函数，以减少冲突的概率。

• 增加数组的大小，即桶的数量，以减少每个桶中的元素数量。

• 使用红黑树代替链表来处理冲突，这样在冲突较多时，仍然能保持较好的查询性能（O(log n)）。

1. 问题：四次挥手的过程。

答案：四次挥手是TCP连接终止的过程，具体步骤如下：

• 第一次挥手：客户端发送一个FIN包给服务器，用来关闭客户端到服务器的数据传送。

• 第二次挥手：服务器收到这个FIN包后，发送一个ACK包作为应答。

• 第三次挥手：服务器发送一个FIN包给客户端，用来关闭服务器到客户端的数据传送。

• 第四次挥手：客户端收到这个FIN包后，发送一个ACK包作为应答。

1. 问题：time_wait的作用。

答案：TIME_WAIT状态存在于主动关闭连接的一方，它有两个主要作用：

• 确保被动关闭方能够收到最后的ACK包，如果被动关闭方没有收到ACK包，会重新发送FIN包。

• 允许网络中延迟的、携带旧序列号的包被自然消亡，防止这些延迟的包被错误地认为是属于新连接的数据。

1. 问题：poll select epoll 稍微详细的说一下（具体问问Linux里面怎么设计的）。

答案：

• poll：poll系统调用提供了和select类似的功能，但它没有最大文件描述符数量的限制。它通过一个数组来传递需要监听的文件描述符集合，并且可以指定每个文件描述符感兴趣的事件。当poll返回时，它告诉调用者哪些文件描述符已经准备好进行I/O操作。

• select：select系统调用允许程序监视一组文件描述符，等待其中一个或多个文件描述符变得“就绪”，即可以无阻塞地进行I/O操作。select的缺点是它支持的文件描述符数量有限，并且每次调用都需要重新传递整个文件描述符集合，效率较低。

• epoll：epoll是Linux特有的I/O事件通知机制，它解决了select和poll的一些问题。epoll使用一个事件表来记录每个文件描述符的状态，这样就不需要每次调用时都传递整个文件描述符集合。epoll支持边缘触发（ET）和水平触发（LT）两种模式，并且能够处理大量的文件描述符，这使得它在高并发情况下比select和poll更加高效。

30.掌上先机实习一面

1. 问题：在你的学习过程中，或者说你做这些项目过程中，你的一般是用的 JDK 在哪一个版本？

答案：在我的学习和项目过程中，主要使用的JDK版本是JDK 1.8。这个版本因为其稳定性、性能改进以及新特性（如Lambda表达式、Stream API等）而被广泛采用。同时，我也关注JDK的新版本，如JDK 11和JDK 17，以了解和利用最新的语言特性和改进。

1. 问题：1.8 的 Hashmap 有用过吗？简单聊一聊 HashMap。

答案：是的，在JDK 1.8中，我经常使用HashMap。HashMap是基于哈希表的Map接口的实现，它存储键值对，允许使用任意对象作为键和值。HashMap的特点包括：

• 键不能为null，但值可以为null。

• 不保证元素的顺序，特别是它不保证顺序随时间不变。

• HashMap不是线程安全的。

• 在JDK 1.8中，当链表的长度大于一定阈值时，链表会转换成红黑树，以提高搜索效率。

1. 问题：有了解过哈希 map 一个扩容的一个机制吗？数据是怎么移动的，有了解过吗？大概有多少数据会参与移动呢？是全部的数据还是说只有部分？如果我想保证线程安全，有什么办法吗？Hashmap 跟 ConCurrentHashmap 的区别在哪？知道吗？

答案：HashMap的扩容机制是在容量达到一定阈值时，创建一个新的更大的数组，并将所有元素重新哈希到新数组中。这个过程涉及到所有数据的移动。为了保证线程安全，可以使用Collections.synchronizedMap方法包装HashMap，或者使用ConcurrentHashMap。ConcurrentHashMap与HashMap的区别在于：

• ConcurrentHashMap是线程安全的，而HashMap不是。

• ConcurrentHashMap采用了分段锁（Segmentation）技术，允许多个线程并发访问不同段的数据，从而提高了并发访问的性能。

• ConcurrentHashMap在JDK 1.8中不再使用分段锁，而是使用了CAS操作和synchronized来保证线程安全，并进一步优化了性能。

1. 问题：除了Hashmap，你们在项目过程中一般还用到什么其他的？还用到其他的一个集合类吗？Array list 底层的一个数据结构有了解过吗？如果要往中间或者头部插入数据的时候，一般是会有什么？会有什么问题吗？或者底部是大概是不，底层大概是会经历什么操作吗？有了解过吗？linked list 有用过吗？

答案：除了HashMap，项目中还常用到ArrayList、LinkedList、HashSet和TreeSet等集合类。ArrayList底层使用数组实现，插入数据到中间或头部时，需要移动插入点之后的所有元素，这可能会导致性能问题，特别是对于大数据量的列表。LinkedList底层使用双向链表实现，插入操作只需要改变指针，不需要移动大量数据。LinkedList在插入和删除操作上比ArrayList更高效，但在随机访问上则不如ArrayList。

1. 问题：volatile自己有用过吗？它有什么作用？为什么在并发环境下会有可见性问题。加了关键字之后为什么就能保证可见性？在 double check 那个代例的那个例子当中，就是它除了可见性之外，还有另外还有其他的作用吗？

答案：是的，我在多线程编程中使用过volatile关键字。volatile的作用是确保变量的更改对其他线程立即可见，并禁止指令重排序。在并发环境下，没有volatile修饰的变量可能会由于CPU缓存不一致而出现可见性问题。volatile通过在变量读写时插入内存屏障来保证可见性。在双重检查锁定（double-checked locking）的例子中，volatile除了保证可见性外，还确保了初始化的原子性，防止指令重排序导致的问题。

1. 问题：JVM这一块有了解过吗？JVM 的内存区域划分，有了解过吗？简单聊一下。每块的区域大概有什么作用你知道吗？垃圾回收器有了解过吗？常用的垃圾回收算法有哪些知道吗？

答案：JVM的内存区域划分主要包括以下几块：

• 方法区（Method Area）：存储已被加载的类信息、常量、静态变量等。

• 堆（Heap）：JVM管理的内存中最大的一块，用于存储对象实例。

• 程序计数器（Program Counter Register）：每个线程都有一个程序计数器，是线程私有的，用于存储指向下一条指令的地址。

• 虚拟机栈（VM Stack）：每个线程运行时都有一个栈，用于存储局部变量表、操作数栈、动态链接、方法出口等信息。

• 本地方法栈（Native Method Stack）：为虚拟机使用到的Native方法服务。

垃圾回收器（GC）主要有以下几种：

• Serial GC：单线程垃圾回收器，适用于小型应用。

• Parallel GC：多线程垃圾回收器，适用于吞吐量优先的应用。

• CMS（Concurrent Mark Sweep）

31.拼多多正式批一面

1. 问题：为什么树化的阈值是 8，反树化的阈值是 6？

答案：在JDK 1.8的HashMap中，当链表长度达到或超过8时，链表会转换为红黑树以提高查找效率。这是因为当链表长度超过8时，链表的查找时间复杂度会从O(1)退化到O(n)，而红黑树的时间复杂度为O(log n)。当链表长度小于6时，红黑树会转换回链表，这是因为当链表长度较短时，红黑树的额外开销（如树节点和红黑树操作）可能会超过其带来的性能提升。

1. 问题：HashMap 是线程安全的吗？多线程情况下会有什么问题？

答案：HashMap不是线程安全的。在多线程环境下，HashMap可能会出现以下问题：

• 数据竞争：多个线程同时修改HashMap可能导致数据不一致。

• 死循环：当多个线程同时修改HashMap时，可能会导致链表形成死循环。

• 不可预知的并发修改：HashMap的遍历和修改操作可能不会按预期执行，因为JVM的优化可能导致操作的顺序发生变化。

1. 问题：Java 线程安全的 Map 有哪些？

答案：Java中线程安全的Map实现有：

• ConcurrentHashMap：基于分段锁实现，允许多个线程并发访问。

• Collections.synchronizedMap：通过包装一个HashMap来实现线程安全。

• Hashtable：基于同步锁实现，是线程安全的，但性能较差。

Hashtable性能较差的原因主要在于它的线程安全实现方式。以下是几个具体的点：

1. 全局锁：Hashtable为了保证线程安全，对整个哈希表结构使用了一个单独的锁（monitor）。这意味着任何时刻只允许一个线程访问Hashtable的任何方法，包括读操作和写操作。这种独占锁的方式严重限制了并发性能，因为在多线程环境中，其他想要访问Hashtable的线程即使只是进行读操作，也必须等待持有锁的线程释放锁。

2. 锁的粒度大：由于Hashtable使用的是全局锁，锁的粒度很大。在理想情况下，对于读多写少的场景，应该允许多个读线程同时访问，而不需要加锁。但由于Hashtable的实现，即使是多个读操作也不能并发执行，这进一步降低了性能。

3. 频繁的上下文切换：由于所有线程都需要等待锁，这可能导致频繁的线程上下文切换，增加了系统的开销。

4. 锁竞争激烈：在多线程环境中，当多个线程频繁地尝试访问Hashtable时，锁竞争会变得非常激烈，这会导致线程阻塞和等待时间增加，从而降低应用程序的整体性能。

相比之下，现代的并发数据结构如ConcurrentHashMap采用了分段锁（Segment Locking）或者其他更细粒度的锁机制，允许多个读操作并发进行，并且写操作也尽可能少的阻塞其他操作，大大提高了并发环境下的性能。

总结来说，Hashtable的线程安全实现牺牲了性能，以换取在多线程环境下的数据一致性。对于需要高并发处理的应用，通常会选用其他的数据结构来代替Hashtable。

ConcurrentHashMap的分段锁是一种基于多个锁的并发控制机制，它允许对哈希表的多个不同部分进行并行操作。以下是分段锁的工作原理和它锁定的部分：

分段锁（Segment Locking）的原理：

1. 分段：ConcurrentHashMap内部将数据分为多个段（Segment），每个段其实就是一个小的哈希表。这些段可以并发地进行读写操作，只要操作的不是同一个段。

2. 独立锁：每个段都有一个独立的锁（通常是一个ReentrantLock对象）。这意味着不同的段之间可以同时进行读写操作，而不会相互阻塞。

3. 并发操作：由于每个段都有自己的锁，所以多个线程可以同时访问哈希表的不同段，从而提高了并发性能。

分段锁具体锁定的部分：

• Segment锁：每个Segment对象都有一个锁，这个锁控制对Segment内所有桶（bucket）的访问。当需要对某个桶进行操作时（比如插入、删除、更新操作），需要首先获取该桶所在Segment的锁。

• 桶（Bucket）：虽然不是直接锁定单个桶，但是当对某个桶进行操作时，会锁定整个包含该桶的Segment。因此，在操作某个桶时，实际上是通过锁定它所在的Segment来间接锁定该桶。

• 链表/红黑树：当哈希表中的桶发生哈希冲突时，会形成链表或红黑树。在锁定Segment后，对链表或红黑树的操作（如查找、插入、删除节点）都是在持有锁的情况下进行的。

分段锁的优势：

• 减少锁竞争：由于锁是分散在多个Segment上的，锁的粒度更细，因此锁竞争比单个全局锁要少得多。

• 提高并发性：在理想情况下，ConcurrentHashMap可以支持多达16个（默认的Segment数量）线程并发读写，而不会相互阻塞。

分段锁的注意事项：

• 读取操作：读取操作通常不需要锁定，因为ConcurrentHashMap通过volatile变量和不可变对象等机制确保了读取操作的可见性和原子性。

• 分段的数量：分段的数量是一个重要的参数，它决定了并发级别。默认情况下，分段的数量是16，但这个值可以根据应用程序的需求进行调整。

ConcurrentHashMap的分段锁机制使得它在多线程环境中表现出很高的并发性能，同时保证了线程安全。不过，值得注意的是，从Java 8开始，ConcurrentHashMap的实现已经不再使用分段锁，而是采用了一种更细粒度的锁机制，即使用synchronized块来锁定哈希桶或链表的头节点，进一步提高了并发性能。

Java 8中的改进：

1. 移除分段锁：Java 8中，ConcurrentHashMap移除了分段锁机制，转而使用一种更细粒度的锁机制。这种机制使用synchronized关键字来锁定哈希桶（bucket）或链表的头节点。

2. 使用CAS操作：为了进一步提高并发性能，ConcurrentHashMap大量使用了CAS（Compare-And-Swap）操作，这些操作是无锁的，可以在不使用锁的情况下更新数据。

3. 红黑树：当链表的长度超过一定阈值（默认为8）时，链表会被转换成红黑树，以减少查找时间。

1. 问题：ConcurrentHashMap 的底层实现？

答案：ConcurrentHashMap的底层实现主要包括以下几个部分：

• 分段锁（Segment）：ConcurrentHashMap使用分段锁来允许多个线程并发访问不同的数据段。

• 桶（Bucket）：每个Segment包含多个桶，每个桶是一个链表或红黑树。

• 数组（Segment[]）：ConcurrentHashMap使用一个数组来存储Segment对象，每个Segment对象包含一个桶数组。

• 并发修改：ConcurrentHashMap通过CAS操作和synchronized来保证线程安全。

1. 问题：MySQL 有哪几种锁？

答案：MySQL中常用的锁类型包括：

• 表锁：用于锁定整个表。

• 行锁：用于锁定表中的行数据。

• 意向锁：用于锁定表或行数据的意向。

• 共享锁和排他锁：用于锁定表或行数据的读写权限。

1. 问题：MySQL 事务有哪些特性？

答案：MySQL事务具有以下特性：

• 原子性：事务中的操作要么全部成功，要么全部失败。

• 一致性：事务的执行结果保证数据库状态的一致性。

• 隔离性：事务的执行与其他事务相互隔离，不会相互干扰。

• 持久性：事务一旦提交，其结果将永久保存。

1. 问题：一条 update 语句的执行过程？

答案：一条update语句的执行过程主要包括以下几个步骤：

• 解析：MySQL解析器将update语句解析为可以执行的SQL语句。

• 优化：查询优化器对SQL语句进行优化，以提高执行效率。

• 执行：MySQL执行器根据优化后的SQL语句执行操作。

• 提交：事务提交后，修改的数据将永久保存。

1. 问题：MySQL 数据怎么刷到磁盘的？

答案：MySQL数据刷到磁盘的过程包括以下几个步骤：

• 缓冲区写入：MySQL将数据写入缓冲区。

• 事务提交：事务提交后，缓冲区中的数据将写入磁盘。

• 缓冲区清理：缓冲区中的数据写入磁盘后，缓冲区将进行清理。

1. 问题：Redis 常用的数据结构？

答案：Redis常用的数据结构包括：

• 字符串（String）：用于存储字符串值。

• 列表（List）：用于存储有序的字符串列表。

• 集合（Set）：用于存储无序的、不重复的字符串集合。

• 有序集合（Sorted Set）：用于存储有序的字符串集合。

• 哈希（Hash）：用于存储键值对。

1. 问题：布隆过滤器的底层结构，

使用场景？ 答案：布隆过滤器（Bloom Filter）是一种概率型数据结构，用于检测一个元素是否存在于一个集合中。它的底层结构通常由以下几个部分组成：

• 哈希函数：布隆过滤器使用多个哈希函数将输入元素映射到数组的位上。

• 位数组：一个固定大小的位数组，用于存储哈希函数的输出结果。

• 错误率：布隆过滤器的错误率可以通过调整哈希函数的数量和位数组的大小来控制。

使用场景：

• 缓存：布隆过滤器可以用来缓存经常访问的数据，减少数据库查询次数。

• 去重：在处理大数据集时，布隆过滤器可s以用来快速判断数据是否重复。

• 内容审核：在社交媒体或电子邮件服务中，布隆过滤器可以用来过滤掉恶意或违规内容。

1. 问题：Redis 过期删除？ 答案：Redis的过期删除机制是指当键的生存时间（TTL）到期时，Redis会自动删除该键。Redis会定期检查键的生存时间，并删除那些已经过期的键。这种机制可以防止内存泄漏，因为即使应用程序没有及时清理过期的键，Redis也会自动处理。

32.阿里高德Java后端（二面）

1. 问题：自我介绍，并介绍项目经验。

答案：您好，我是一名具有多年开发经验的软件工程师。我曾在多家知名互联网公司工作，参与过多个大型项目的开发和维护。我熟悉多种编程语言和框架，包括Java、Python、Go等，以及Spring、Dubbo、Kafka等主流技术栈。我擅长解决复杂的技术问题，具有良好的团队协作和沟通能力。

1. 问题：算法题：给定一组整数数组，每个元素代表一天与前一天相比的带宽变化（负数表示减少，正数表示增加）。编写程序找到一段连续的时间，使得在这段时间内的带宽变化量总和最大，返回日期区间和最大值。

答案：这是一个典型的动态规划问题。我们可以使用一个数组dp来记录从第i天开始，连续n天带宽变化量总和的最大值。对于每一天，我们遍历其前面的所有天，计算从当前天开始，连续n天的带宽变化量总和，并与dp[i]比较，取最大值。这样，我们就可以找到最大带宽变化量及其对应的日期区间。

1. 问题：服务器推流的实现方式。

答案：服务器推流通常使用流媒体技术来实现，常见的实现方式包括：

• RTMP（Real-Time Messaging Protocol）：一种实时流媒体传输协议，适用于直播和视频会议。

• HTTP-FLV（HTTP-FLV Streaming）：基于HTTP协议的FLV流媒体传输，适用于在线视频播放。

• HLS（HTTP Live Streaming）：基于HTTP协议的直播流媒体传输，适用于移动设备和浏览器播放。

• DASH（Dynamic Adaptive Streaming over HTTP）：基于HTTP协议的自适应流媒体传输，可以根据网络条件动态调整视频质量。

1. 问题：Redis为什么快，IO多路复用，缓存击穿和缓存穿透的区别。

答案：Redis之所以快，主要得益于以下几点：

• 内存存储：Redis将数据存储在内存中，避免了磁盘I/O的瓶颈。

• 单线程模型：Redis采用单线程模型，避免了多线程竞争导致的上下文切换和锁的开销。

• 非阻塞IO：Redis使用IO多路复用技术，如epoll、select等，可以同时处理多个客户端的请求。

• 数据结构优化：Redis提供了丰富的数据结构，如字符串、列表、集合、有序集合等，以适应不同的应用场景。

缓存击穿和缓存穿透的区别在于：

• 缓存击穿：当缓存中的数据过期时，大量请求直接打到后端数据库，导致数据库压力过大。

• 缓存穿透：当缓存中的数据过期时，请求的键不存在于数据库中，导致大量请求直接打到后端数据库，同样导致数据库压力过大。

1. 问题：实现RPC需要注意什么。

答案：实现RPC（Remote Procedure Call）需要注意以下几点：

• 接口定义：明确定义服务接口，包括输入参数、输出参数和异常情况。

• 序列化与反序列化：选择合适的序列化方式，如JSON、Protocol Buffers等，以减少传输的数据量。

• 网络通信：使用高效的网络通信协议，如HTTP/2、WebSocket等，以提高传输效率。

• 负载均衡：实现负载均衡机制，以提高系统的可扩展性和可用性。

• 服务发现：提供服务发现机制，以动态管理服务实例，适应服务器的增减和故障。

• 容错与重试：实现容错和重试机制，以提高系统的鲁棒性。

1. 问题：Zookeeper的实现原理。

答案：Zookeeper是一个分布式协调服务，主要用于解决分布式系统中的数据一致性问题。其实现原理主要包括以下几个方面：

• 文件系统：Zookeeper采用树形目录结构，类似于Unix文件系统，用于存储数据。

• 数据节点：Zookeeper中的数据存储在称为“节点”的文件中，每个节点可以包含子节点。

• 版本控制：Zookeeper使用版本号来管理数据变更，以实现数据一致性。

• 原子广播：Zookeeper使用ZAB（Zookeeper Atomic Broadcast）协议来实现原子广播，保证数据的一致性。

• 数据同步：Zookeeper通过数据同步机制，确保各个服务器上的数据一致。

1. 问题：工作中如何处理死锁。

答案：在分布式系统中，死锁通常是由于多个服务或线程在等待

其他服务或线程持有的资源，而这些资源又被其他服务或线程持有，导致资源无法释放，从而形成死锁。处理死锁的方法包括：

• 死锁检测：定期检测系统状态，发现死锁后，通过打破循环依赖关系来解除死锁。

• 死锁预防：通过资源分配策略，如银行家算法，来避免死锁的发生。

• 死锁避免：在资源分配时，使用各种算法，如等待图算法，来预测资源分配是否会引发死锁，从而避免分配。

• 死锁恢复：在死锁发生后，撤销某些进程的操作，使其资源释放，从而恢复系统的正常运行。

1. 问题：日常开发中遇到类冲突怎么办。 答案：在日常开发中，遇到类冲突时，可以采取以下措施：

   1. 分析冲突原因：确定冲突的类名、版本等信息，找出冲突的根本原因。

   2. 修改依赖关系：调整项目依赖关系，避免引入冲突的类。

   3. 使用版本控制：使用版本控制工具，如Maven、Gradle等，来管理项目依赖版本，避免冲突。

   4. 修改代码：修改代码，避免直接引用冲突的类，或者使用冲突类的方法和属性。

   5. 升级依赖版本：升级冲突的类库版本，以解决冲突问题。

2. 问题：拼音转汉字，再搜索包含汉字的词的实现方法。 答案：实现拼音转汉字的方法可以采用以下步骤：

   1. 拼音转汉字：使用拼音转汉字库，如Pinyin4j，将拼音转换为对应的汉字。

   2. 构建汉字索引：构建一个汉字索引，将每个汉字映射到其拼音。

   3. 搜索包含汉字的词：使用构建的汉字索引，对输入的拼音进行搜索，找到包含该拼音的汉字词。

3. 问题：给定一个POI，如何召回附近的人。 答案：召回附近的人可以通过以下步骤实现：

• 获取POI的位置信息：使用地图服务或GPS定位技术获取POI的位置。

• 计算距离：根据POI的位置信息，计算用户与POI之间的距离。

• 过滤用户：根据距离范围，筛选出附近一定范围内的用户。

• 发送消息：向筛选出的用户发送召回通知，告知他们POI的位置和相关信息。

33.得物二面

1. 问题：线程有哪些状态并解释其含义？

答案：线程有以下几种状态：

• 初始状态（New）：创建后尚未启动的线程处于这个状态。

• 运行状态（Runnable）：线程调用了start()方法后，线程进入运行状态，它可能正在运行，也可能正在等待CPU时间片。

• 阻塞状态（Blocked）：线程因为等待某些资源（如监视器锁）而暂时停止运行。

• 等待状态（Waiting）：线程无限期地等待另一个线程执行特定操作（如通知）。

• 超时等待状态（Timed Waiting）：线程在一定时间内等待另一个线程的通知或者时间到达。

• 终止状态（Terminated）：线程执行完成或者因异常退出的状态。

1. 问题：超时等待的线程如何唤醒？

答案：超时等待的线程可以通过以下几种方式唤醒：

• 其他线程调用notify()或notifyAll()方法，如果线程在等待对象监视器锁。

• 超时时间到达，线程自动唤醒。

• 线程.interrupt()方法被调用，如果线程在等待中响应中断，则会抛出InterruptedException异常，从而结束等待状态。

1. 问题：一个类有两个字段，一个short，一个boolean，那么这个类建立一个对象，需要占多大的内存空间？

答案：在Java中，一个对象除了其字段值外，还包括对象头（Object Header）和对齐填充（Padding）。short类型占用2个字节，boolean类型理论上占用1个比特，但在实际内存分配中通常会占用1个字节。对象头的大小依赖于JVM的实现，通常为8字节（32位系统）或16字节（64位系统）。对齐填充是为了满足JVM的对齐要求。因此，一个对象的总大小可能是对象头大小加上字段大小加上对齐填充的大小。假设是64位系统，那么这个对象可能占用24字节（16字节对象头 + 2字节short + 1字节boolean + 5字节对齐填充）。

1. 问题：503与504状态码表示什么含义？

答案：

• 503 Service Unavailable：服务器目前无法处理请求，因为临时过载或维护。

• 504 Gateway Timeout：服务器作为网关或代理，没有及时从上游服务器收到响应。

1. 问题：HTTPS与HTTP有什么区别？

答案：HTTPS（HTTP Secure）与HTTP的主要区别在于安全性：

• HTTPS在传输数据时会进行加密，而HTTP不会。

• HTTPS需要证书（SSL/TLS证书）来验证服务器的身份。

• HTTPS默认使用443端口，而HTTP使用80端口。

• HTTPS比HTTP更安全，能够防止数据在传输过程中被窃听和篡改。

1. 问题：Netty里面NIO的非阻塞是怎么实现的？

答案：Netty中的NIO（Non-blocking I/O）非阻塞是通过以下方式实现的：

• 使用选择器（Selector）来处理多个通道（Channel）上的事件。

• 一个线程可以管理多个Channel，只有在Channel准备好进行读写操作时，线程才会进行相应的操作，不会一直等待某个Channel的数据。

• Channel注册到Selector上，可以监听不同的事件（如连接就绪、可读、可写等）。

• 当Selector检测到某个Channel准备好进行I/O操作时，线程才会执行对应的操作，从而实现非阻塞。

1. 问题：Netty的那个NioEventLoop是怎么运行的啊？

答案：NioEventLoop在Netty中的运行机制如下：

• NioEventLoop本质上是实现了Executor接口的线程，负责处理注册在其上的Channel的所有I/O事件。

• 它内部维护了一个Selector，用于监听注册在其上的Channel的各种事件。

• 当事件发生时，Selector会通知NioEventLoop，然后NioEventLoop会调用相应的事件处理器来处理这些事件。

• NioEventLoopGroup是NioEventLoop的集合，通常充当线程池的角色，管理多个NioEventLoop。

• NioEventLoop不仅可以处理I/O事件，也可以执行普通任务和定时任务。

34.4399一面

1. 问题：浮点数底层怎么表示？

答案：浮点数在底层通常遵循IEEE 754标准表示。该标准定义了浮点数的存储格式，包括符号位、指数位和尾数位（或称为有效数字位）。

• 符号位（sign bit）：决定数值的正负，0表示正数，1表示负数。

• 指数位（exponent）：表示2的幂次，用于确定浮点数的量级。

• 尾数位（fraction/mantissa）：表示实际的数字信息，通常是二进制小数点后的数字。

以32位浮点数（单精度）为例，符号位占1位，指数位占8位，尾数位占23位。64位浮点数（双精度）则符号位占1位，指数位占11位，尾数位占52位。

1. 问题：TCP和UDP的区别，在哪一层？

答案：TCP（传输控制协议）和UDP（用户数据报协议）都是传输层协议，它们的主要区别在于：

• TCP提供可靠的、面向连接的服务，确保数据正确无误地到达目的地。UDP提供不可靠的、无连接的服务，数据传输可能丢失或出错。

• TCP进行拥塞控制，会根据网络状况调整数据传输速率。UDP不进行拥塞控制，传输速率固定。

• TCP头部较大，包含序号、确认号、窗口大小等信息。UDP头部较小，只有源端口、目标端口、长度和校验和信息。

• TCP适用于要求高可靠性的应用，如Web浏览、文件传输等。UDP适用于对实时性要求高的应用，如视频会议、在线游戏等。

1. 问题：Java面向对象怎么体现？

答案：Java面向对象的体现主要在以下几个方面：

• 类和对象：Java使用类作为创建对象的模板，对象是类的实例。

• 封装：通过访问修饰符（如private、protected、public）来控制对类成员的访问，隐藏内部实现细节。

• 继承：通过extends关键字允许子类继承父类的属性和方法，实现代码复用。

• 多态：允许不同类的对象对同一消息做出响应，即同一操作作用于不同的对象时可以有不同的解释和行为。

1. 问题：多态从虚拟内存角度怎么实现的？

答案：多态在虚拟内存角度是通过以下方式实现的：

• 虚拟机为每个对象维护一个指向方法区的指针，方法区存储了类的信息，包括方法表。

• 当调用一个方法时，虚拟机通过对象的类型信息查找对应的方法表，确定要执行的方法。

• 如果子类覆写了父类的方法，子类的方法表中的该方法条目会指向子类的方法实现。

• 这种动态绑定过程使得即使引用类型相同，实际执行的方法也可能不同，从而实现多态。

1. 问题：一个项目问题，为什么要保证原子性？

答案：在项目中保证原子性是为了确保操作在并发环境下的正确性和一致性。原子性指的是一个操作（或一系列操作）要么全部执行，要么全部不执行，不会出现部分执行的情况。这可以防止多个线程同时对同一数据进行操作时导致的数据不一致问题。

1. 问题：原子性是什么？

答案：原子性是指一个操作在执行过程中不会被任何其他操作中断，该操作在执行完毕之前，其他操作无法观察到中间状态。在数据库事务中，原子性是ACID属性之一，确保事务中的所有操作要么全部成功，要么全部失败。

1. 问题：高并发指的是什么？

答案：高并发指的是系统在短时间内遇到大量操作请求的情况。它通常用来描述服务器、网络或应用程序在面临大量用户同时访问时，如何有效地处理这些请求，确保系统稳定运行，提供良好的用户体验。

1. 问题：WebSocket的结构，和HTTP区别？

答案：WebSocket是一种网络通信协议，提供全双工通信渠道，其结构与HTTP的区别如下：

• WebSocket在初始握手时使用HTTP协议，之后数据传输不遵循HTTP的请求-响应模型，而是建立持久的连接，允许服务器和客户端双向实时通信。

• WebSocket连接一旦建立，服务器和客户端可以随时发送消息，不需要发送HTTP头部信息。

• HTTP是无状态的，每次请求都需要重新建立连接，而WebSocket在建立连接后可以保持状态，直到其中一方关闭连接。

1. 问题：Volatile关键字 讲讲内存屏障？

答案：Volatile关键字用于声明变量，以确保对变量的读写操作直接在主内存中进行。内存屏障是Volatile实现可见性的关键机制，它包括以下几种：

• LoadLoad屏障：确保后续的读操作在之前的读操作之后执行。

• StoreStore屏障：确保后续的写操作在之前的写操作之后执行。

• LoadStore屏障：确保后续的写操作在之前的读操作之后执行。

• StoreLoad屏障：确保后续的读操作在之前的写操作之后执行。

这些屏障可以防止指令重排序和编译器的优化，确保volatile变量的特殊语义得到正确实现。

1. 问题：操作系统的内存管理？ 答案：操作系统的内存管理主要负责物理内存和虚拟内存的管理，主要包括以下功能：

• 内存分配：操作系统负责将物理内存分配给需要内存的进程。

• 内存保护：确保每个进程只能访问它被分配的内存区域，防止进程间相互干扰。

• 地址映射：将虚拟地址转换为物理地址，使得进程可以使用比实际物理内存更大的地址空间。

• 内存置换（Swapping/Paging）：当物理内存不足时，操作系统将部分内存页置换到磁盘上，以释放空间供其他进程使用。

• 内存碎片整理：通过内存的紧凑操作，减少内存碎片，提高内存利用率。

35.科大讯飞一面

1. 问题：请介绍一下你的项目或实习经历。

答案：在我的上一段实习经历中，我在一家互联网公司担任软件开发实习生。主要参与了一个基于微服务架构的在线教育平台项目。在这个项目中，我负责学生模块的开发，包括用户注册、登录、课程选课、学习进度跟踪等功能。通过这次实习，我深入了解了Spring Boot、MyBatis、Redis等技术的应用，并学会了如何使用Git进行版本控制和协同开发。

1. 问题：双亲委派模型是什么？如何打破双亲委派模型？什么时候打破双亲委派？

答案：双亲委派模型是Java类加载器的一种机制，当一个类需要被加载时，首先会请求父类加载器进行加载，如果父类加载器无法加载，再由自己进行加载。这样可以避免类的重复加载，保证类的唯一性。

打破双亲委派模型的方法有：

• 自定义类加载器，重写loadClass方法。

• 使用线程上下文类加载器。

打破双亲委派模型的情况有：

• JNDI、JDBC等需要加载用户自定义的类。

• Tomcat等Web容器为了实现不同应用的类隔离。

1. 问题：volatile作用是什么？内存屏障什么原理？

答案：volatile关键字的作用是保证变量的可见性和有序性。当一个变量被声明为volatile时，对该变量的读写操作都会直接与主内存交互，而不是使用线程私有的缓存。

内存屏障的原理是通过禁止特定类型的处理器重排序来实现的。内存屏障可以分为以下几种：

• LoadLoad屏障：禁止读读重排序。

• StoreStore屏障：禁止写写重排序。

• LoadStore屏障：禁止读写重排序。

• StoreLoad屏障：禁止写读重排序。

1. 问题：juc都有什么类？

答案：JUC（java.util.concurrent）包下包含了以下几类并发工具类：

• 线程执行器（Executor）：如ExecutorService、ThreadPoolExecutor等。

• 同步工具（Synchronizers）：如CountDownLatch、CyclicBarrier、Semaphore等。

• 锁（Locks）：如ReentrantLock、ReentrantReadWriteLock等。

• 原子变量（Atomic Variables）：如AtomicInteger、AtomicLong、AtomicReference等。

• 阻塞队列（Blocking Queues）：如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue等。

1. 问题：ThreadLocal原理是什么？ 答案：ThreadLocal提供了线程局部变量，即每个线程都可以拥有一个自己独立初始化的变量副本。ThreadLocal的原理是，它内部维护了一个ThreadLocalMap，这个Map的键是ThreadLocal对象，值是实际要存储的变量副本。当线程访问ThreadLocal变量时，它会首先获取当前线程的ThreadLocalMap，然后以ThreadLocal对象为键，获取对应的值。

2. 问题：引用类型有什么？ 答案：Java中的引用类型主要有以下四种：

• 强引用（Strong Reference）：最常见的引用类型，如Object obj = new Object();，只要强引用存在，垃圾回收器就不会回收被引用的对象。

• 软引用（Soft Reference）：用于实现内存敏感的高速缓存。在内存足够时，软引用对象不会被回收；在内存不足时，软引用对象可能会被回收。

• 弱引用（Weak Reference）：用来描述非必须的对象，它的强度比软引用更弱一些。当垃圾回收器扫描到弱引用对象时，无论内存是否充足，都会回收被弱引用的对象。

• 虚引用（Phantom Reference）：也称为幽灵引用，是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。

1. 问题：为什么ThreadLocal key和value用的都是什么引用类型？为什么value用强引用？ 答案：在ThreadLocal的实现中，ThreadLocalMap的key使用了弱引用，即ThreadLocal对象。这样做是为了允许ThreadLocal对象在没有其他强引用的情况下被垃圾回收器回收，从而避免内存泄漏。而value则使用了强引用，这是因为value是实际存储的数据，如果使用弱引用，那么在垃圾回收时，value可能会被回收，导致数据丢失。因此，value使用强引用来确保数据在需要时始终是可用的。

2. 问题：Mysql用了什么索引数据结构？对比B和B+树？ 答案：MySQL使用B+树作为索引的数据结构。

B树和B+树的对比：

• B树：每个节点既包含键值，也包含数据。在B树中，每个节点可以有多个子节点，节点中的键值会按照升序排列，并且每个节点的子节点数量有上限和下限。

• B+树：只有叶子节点才包含所有的键值和数据，非叶子节点只存储键值。所有的叶子节点之间通过指针连接，形成了一个链表。这使得B+树更适合于进行范围查询。

1. 问题：聚簇索引和非聚簇索引? 答案：聚簇索引（Clustered Index）和非聚簇索引（Non-Clustered Index）是数据库索引的两种类型。

• 聚簇索引：数据的物理顺序与索引顺序相同，即索引的叶节点直接指向数据行。每个表只能有一个聚簇索引，通常情况下，主键会被作为聚簇索引。

• 非聚簇索引：数据的物理顺序与索引顺序不同，索引的叶节点存储的是指向数据行的指针。一个表可以有多个非聚簇索引，它们不影响数据的物理存储顺序。

1. 问题：explain的原理？如何优化sql查询？ 答案：EXPLAIN是MySQL提供的一个用于分析SQL查询执行计划的一个命令。它的原理是，MySQL执行器在执行SQL语句之前，会先根据SQL语句生成一个执行计划，EXPLAIN命令可以展示这个执行计划的详细信息，包括表的读取顺序、数据检索方式、是否使用索引、扫描的行数等。

优化SQL查询的方法：

• 确保查询中使用的列上有索引。

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

• 使用JOIN代替子查询。

• 使用LIMIT限制返回的行数。

• 避免在WHERE子句中使用函数或计算。

• 定期分析表和优化表（ANALYZE TABLE）。

• 考虑使用分区表来提高查询性能。

36.高顿教育Java实习一面

1. 问题：多线程创建方式有哪些？

答案：在Java中，创建多线程主要有以下几种方式：

• 继承Thread类：创建一个类继承Thread类，并重写run()方法，然后创建该类的实例并调用start()方法。

• 实现Runnable接口：创建一个类实现Runnable接口，实现run()方法，然后将该类的实例传递给Thread对象并调用start()方法。

• 实现Callable接口：通过FutureTask包装Callable对象，然后将FutureTask对象传递给Thread对象并调用start()方法，这种方式可以获取线程的执行结果。

• 使用线程池：通过Executors类创建线程池，然后提交Runnable或Callable任务给线程池执行。

当然，以下是上述多线程创建方式的代码示例：

1. 继承Thread类创建线程的示例代码：

class MyThread extends Thread { @Override public void run() { System.out.println("线程运行中: " + Thread.currentThread().getName()); } } public class ThreadExample { public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.start(); } }

1. 实现Runnable接口创建线程的示例代码：

class MyRunnable implements Runnable { @Override public void run() { System.out.println("线程运行中: " + Thread.currentThread().getName()); } } public class RunnableExample { public static void main(String[] args) { Thread thread = new Thread(new MyRunnable()); thread.start(); } }

1. 实现Callable接口并通过FutureTask包装创建线程的示例代码：

import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; class MyCallable implements Callable<String> { @Override public String call() throws Exception { return "线程运行完成: " + Thread.currentThread().getName(); } } public class CallableExample { public static void main(String[] args) throws ExecutionException, InterruptedException { MyCallable callable = new MyCallable(); FutureTask<String> futureTask = new FutureTask<>(callable); Thread thread = new Thread(futureTask); thread.start(); // 获取线程执行的结果 String result = futureTask.get(); System.out.println(result); } }

1. 使用线程池创建线程的示例代码：

import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; class MyRunnableTask implements Runnable { @Override public void run() { System.out.println("线程池中的线程运行中: " + Thread.currentThread().getName()); } } public class ThreadPoolExample { public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(5); for (int i = 0; i < 10; i++) { executorService.execute(new MyRunnableTask()); } // 关闭线程池 executorService.shutdown(); } }

1. 问题：线程池参数有哪些？

答案：线程池的参数主要包括以下几个：

• corePoolSize：线程池的核心线程数，即使它们空闲，也不会被销毁。

• maximumPoolSize：线程池允许的最大线程数。

• keepAliveTime：当线程数大于核心线程数时，多余的空闲线程在终止前等待新任务的最长时间。

• unit：keepAliveTime参数的时间单位。

• workQueue：用于在执行任务之前保存任务的队列。它可以是ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。

• threadFactory：用于创建新线程的工厂。

• handler：当线程池和队列都满了时，用于处理被拒绝的任务的处理器。

1. 问题：MySQL事务有哪些特性？

答案：MySQL事务具有以下四个特性，通常被称为ACID属性：

• 原子性（Atomicity）：事务中的所有操作要么全部成功，要么全部失败回滚，不会处于中间状态。

• 一致性（Consistency）：事务必须使数据库从一个一致性状态转移到另一个一致性状态。

• 隔离性（Isolation）：一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，反之亦然。

• 持久性（Durability）：一个事务一旦提交，它对数据库中数据的改变就是永久性的。

1. 问题：如何防止MySQL中的幻读？

答案：防止幻读可以通过以下几种方式：

• 使用Serializable隔离级别：这是最高的隔离级别，可以完全防止幻读，但它会大大降低系统的并发能力。

• 使用Next-Key Locks：在Repeatable Read隔离级别下，MySQL InnoDB存储引擎默认使用Next-Key Locks，它结合了行锁和间隙锁，可以有效防止幻读。

1. 问题：手写懒汉式单例模式。

答案：

public class LazySingleton { private static LazySingleton instance; private LazySingleton() {} public static synchronized LazySingleton getInstance() { if (instance == null) { instance = new LazySingleton(); } return instance; } }

1. 问题：懒汉式和饿汉式单例模式效率哪个高？

答案：饿汉式单例模式在类加载时就完成了实例化，因此加载类的时间比较长，但获取对象的速度快；懒汉式单例模式在第一次使用时才进行初始化，因此加载类的时间比较短，但获取对象的速度相对较慢。在单线程环境下，饿汉式的效率通常高于懒汉式，因为它避免了线程同步的开销。但在多线程环境下，如果懒汉式采用了双重检查锁定（Double-Checked Locking）等优化措施，其效率可以与饿汉式相当。

1. 问题：IOC和AOP是什么？

答案：IOC（Inversion of Control）是控制反转，它是一种设计思想，将对象创建和对象之间的依赖关系交给容器来管理，从而实现对象之间的解耦。AOP（Aspect-Oriented Programming）是面向切面编程，它允许开发者定义跨多个点的行为（如日志、事务、安全等），并将这种行为横切应用到程序的业务逻辑中。

1. 问题：Spring事务传播特性有哪些？

答案：Spring事务传播特性定义了多个事务方法相互调用时事务如何传播，主要包括以下几种：

• PROPAGATION_REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。

• PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。

• PROPAGATION_MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常。

• PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。

• PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

• PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

• PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则与PROPAGATION_REQUIRED类似。

1. 问题：PROPAGATION_NESTED和PROPAGATION_REQUIRES_NEW有什么区别？ 答案：PROPAGATION_NESTED和PROPAGATION_REQUIRES_NEW都是用来处理事务的传播行为，但它们在处理方式上有所不同：

• PROPAGATION_REQUIRES_NEW：每次调用都会创建一个新的事务，并且与外部事务相互独立。如果外部事务回滚，内部事务不会受到影响，反之亦然。这意味着内部事务的提交或回滚不会影响外部事务的执行。

• PROPAGATION_NESTED：如果当前存在事务，则会嵌套在一个保存点（Savepoint）中执行。如果内部事务失败，它可以在不影响外部事务的情况下回滚到保存点。如果外部事务回滚，那么内部事务也会被回滚，因为它们是同一个事务的一部分。PROPAGATION_NESTED需要一个支持保存点的数据源。

1. 问题：如何选择合适的事务传播行为？ 答案：选择合适的事务传播行为需要根据具体业务逻辑和需求来决定，以下是一些指导原则：

• 如果服务方法需要在一个新事务中执行，并且与外部事务无关，应该使用PROPAGATION_REQUIRES_NEW。

• 如果服务方法需要在当前事务内部执行，并且希望能够在方法失败时回滚到特定的保存点，而不影响外部事务的其他操作，应该使用PROPAGATION_NESTED。

• 如果服务方法必须在一个事务中执行，但是不需要自己管理事务，可以使用PROPAGATION_REQUIRED。

• 如果服务方法不应该在一个事务中执行，可以使用PROPAGATION_NOT_SUPPORTED或PROPAGATION_NEVER。

选择事务传播行为时，还需要考虑数据一致性和系统性能的要求，以及可能的事务隔离级别的影响。

1. 实践事务传播

  import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service public class OrderService { @Autowired private OrderRepository orderRepository; @Autowired private InventoryService inventoryService; // REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。 @Transactional public void createOrder(Order order) { // 保存订单信息 orderRepository.save(order); // 减少库存数量 inventoryService.decreaseInventory(order.getProductId(), order.getQuantity()); } } @Service public class InventoryService { @Autowired private InventoryRepository inventoryRepository; // SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务方式执行。 @Transactional(propagation = Propagation.SUPPORTS) public void decreaseInventory(Long productId, int quantity) { // 查询库存 Inventory inventory = inventoryRepository.findByProductId(productId); if (inventory.getQuantity() < quantity) { throw new InsufficientInventoryException("库存不足"); } // 更新库存数量 inventory.setQuantity(inventory.getQuantity() - quantity); inventoryRepository.save(inventory); } } // 异常类 class InsufficientInventoryException extends RuntimeException { public InsufficientInventoryException(String message) { super(message); } } // Order实体类 class Order { // ... 省略getter和setter方法 private Long id; private Long productId; private int quantity; } // Inventory实体类 class Inventory { // ... 省略getter和setter方法 private Long id; private Long productId; private int quantity; } // OrderRepository接口 interface OrderRepository { void save(Order order); } // InventoryRepository接口 interface InventoryRepository { Inventory findByProductId(Long productId); void save(Inventory inventory); }  

37.美团-到店日常实习

1. 问题：面试官介绍部门相关情况

答案：面试官通常会简要介绍部门的主要职责、团队规模、业务方向、技术栈、工作氛围以及近期的一些成就和挑战。这是为了让应聘者对即将加入的团队有一个初步的了解，并判断是否符合自己的职业规划和发展需求。

1. 问题：自我介绍（询问了学了哪些专业课）

答案：您好，我叫[您的名字]，毕业于[您的学校]，专业是[您的专业]。在校期间，我学习了数据结构、算法分析、操作系统、计算机网络、数据库原理等核心专业课程。我对编程有着浓厚的兴趣，并在课余时间通过参与项目和比赛来提升自己的技术能力。

1. 问题：自己介绍项目中的亮点

答案：在我的一个项目中，我负责设计和实现了基于微服务的架构，其中亮点包括：

• 使用Spring Cloud构建了高可用、可扩展的服务架构。

• 引入Redis作为缓存，优化了系统性能，减少了数据库的压力。

• 利用Docker容器化技术，实现了快速部署和自动化运维。

1. 问题：针对简历进行拷打

答案：面试官可能会针对简历中的项目经历、技术栈、工作成果等进行深入提问，以验证简历的真实性和应聘者的技术深度。例如，询问项目中的某个技术难题是如何解决的，或者要求解释某个技术选择的原因。

1. 问题：计网：tcp三次握手、握手失败怎么办

答案：TCP三次握手是建立TCP连接的过程，包括客户端发送SYN、服务端回应SYN-ACK、客户端再发送ACK。如果握手失败，比如因为网络问题或服务端无响应，客户端会根据超时机制重试发送SYN，如果多次重试后仍然失败，则会通知应用层连接建立失败。

1. 问题：出了几道很考验java基础知识的题目，让判断输出

答案：这类题目通常涉及Java的基本语法、面向对象、异常处理、多线程等知识点。例如，考察变量作用域、静态变量、继承、覆盖、异常捕获等。正确回答这些问题需要扎实的Java基础知识。

1. 问题：分布式锁

答案：分布式锁是一种在分布式系统中用于保证同一时间只有一个客户端能对共享资源进行操作的同步机制。常见的实现方式有基于Redis的SETNX命令、基于ZooKeeper的临时顺序节点等。

1. 问题：hashmap、copyonwritelist

答案：HashMap是一个基于散列的映射接口，提供了键值对存储和快速查找功能。而CopyOnWriteArrayList是一个线程安全的变体，它在修改操作时会创建并复制一个新的数组，以此来保证迭代器遍历时不会发生ConcurrentModificationException。

1. 问题：Spring相关的内容，bean的注入方式

答案：Spring中Bean的注入方式主要有三种：构造器注入、设值注入（Setter注入）和字段注入（Field注入）。构造器注入通过构造器参数完成依赖注入，设值注入通过属性的Setter方法完成，字段注入则是直接在字段上使用@Autowired等注解。

1. 问题：Spring事务、实现方式、底层原理、失效情况

答案：Spring事务通过AOP（面向切面编程）实现，底层原理是使用代理模式在方法执行前后加入事务管理逻辑。失效情况可能包括方法不是public的、抛出非运行时异常、事务方法内部直接调用同类的事务方法等。

1. 问题：Redis持久化操作、同步策略 答案：Redis提供了两种持久化操作：RDB（快照）和AOF（追加文件）。RDB通过定时保存数据集的快照来持久化，而AOF则记录每个写操作命令，重启时通过重新执行这些命令来恢复数据。同步策略方面，RDB可以通过配置save指令来定时保存，而AOF则可以通过appendfsync配置项来设置同步频率，例如设置为everysec表示每秒同步一次。

2. 问题：Redis集群（自己没用过、过了） 答案：Redis集群是一个提供在多个Redis节点间自动分片的高可用解决方案。它允许数据分散存储在多个节点上，同时提供复制和故障转移功能。集群中的节点通过Gossip协议相互通信，以维护集群的状态信息。

3. 问题：Redis数据结构、跳表、压缩列表 答案：Redis支持多种数据结构，如字符串、列表、集合、哈希表、有序集合等。跳表（Skip List）是一种用于有序集合的实现，它通过多层链表的结构来允许快速的范围查询。压缩列表（Zip List）是一种特殊的双向链表，用于存储小整数和短字符串，它可以有效地减少内存使用。

   跳表（Skip List）和压缩列表（Zip List）是Redis中用于存储数据的两种不同数据结构，它们各自适用于不同的场景，并且有各自的优缺点。

   跳表（Skip List）

   跳表是一种有序的数据结构，它通过在列表中添加多级索引来提高查询效率。跳表中的每个元素都有多个指向其他元素的指针，这些指针可以在多个层级上跳跃，从而大大减少查询时间。

   结构

   跳表由以下几个部分组成：

   • 表头（Header）：包含指向第一个元素的指针，以及指向下一级的指针。

   • 索引（Level）：每个元素都包含指向上一级的指针。

   • 数据（Data）：实际存储的数据。

   工作原理

   当插入一个新元素时，系统会随机选择一个层级（Level），新元素在这个层级上会有一个指向其他元素的指针。当查找一个元素时，从表头开始，根据元素值与当前元素值的比较，跳转到下一个层级，直到找到目标元素或者确定元素不存在。

   优缺点

   • 优点：

     • 查询效率高：由于存在多级索引，可以快速定位到目标元素。

     • 插入和删除操作相对简单：只需要修改指针即可。

     • 空间效率高：相对于树形结构，跳表不需要为每个元素存储额外的层级信息。

   • 缺点：

     • 内存占用较大：需要为每个元素存储多级索引。

     • 随机层级的选择可能导致不均匀的索引分布，影响性能。

   压缩列表（Zip List）

   压缩列表是一种特殊的双向链表，它用于存储一系列的短字符串或整数。它通过一系列的技巧来减少内存的使用和提高数据的访问效率。

   结构

   压缩列表由以下几个部分组成：

   • 表头（Header）：包含压缩列表的长度和数据结构信息。

   • 数据块（Doubly Linked List Block）：包含一系列的节点，每个节点包含数据和指向前后节点的指针。

   • 游标（Cursor）：用于在压缩列表中移动的指针。

   工作原理

   当插入一个新元素时，如果新元素小于或等于当前节点的数据，则直接插入到当前节点之前。如果新元素大于当前节点的数据，则插入到当前节点的下一个节点之前。删除操作类似，通过游标定位到要删除的节点，并修改指针来删除节点。

   优缺点

   • 优点：

     • 内存占用小：通过将多个短字符串或整数合并成一个节点，减少内存使用。

     • 访问效率高：由于是双向链表，可以快速访问任意位置的数据。

   • 缺点：

     • 插入和删除操作较慢：需要移动游标，并且可能需要合并节点。

     • 不支持快速查找：查找操作需要遍历整个压缩列表。

   总结

   跳表适用于需要快速查找和插入操作的场景，而压缩列表适用于存储一系列的短字符串或整数，并且对内存使用要求较高的场景。在实际应用中，可以根据具体需求选择合适的数据结构。

4. 问题：Mysql隔离级别、隔离级别之间如何切换 答案：MySQL支持四种隔离级别：READ UNCOMMITTED、READ COMMITTED、REPEATABLE READ和SERIALIZABLE。隔离级别之间的切换可以通过修改MySQL的配置文件（如my.cnf）中的transaction-isolation参数，或者在会话级别使用SET TRANSACTION ISOLATION LEVEL命令来设置。

5. 问题：MVCC 答案：MVCC（多版本并发控制）是一种用于数据库管理系统中的并发控制技术，它允许事务在读取数据时不需要锁定数据，从而提高并发性能。MVCC通过保存数据的历史版本来实现，这样不同的事务可以看到数据在各自事务开始时的状态。

6. 问题：Mysql锁、在什么情况下需要加什么锁、锁退化 答案：MySQL中的锁分为行锁和表锁。在需要操作特定行时使用行锁，如UPDATE、DELETE操作；在需要对整个表进行操作时使用表锁，如ALTER TABLE。锁退化是指原本的行锁因为某些操作（如索引失效）而升级为表锁，这通常会导致并发性能下降。

38.B站二面

1. AOP解释代码

     本题考查了Spring AOP（面向切面编程）的相关知识。在Spring AOP中，可以通过定义切面来拦截特定的方法调用，并在这些方法执行前后添加额外的处理逻辑。这里的关键点在于理解切面的配置以及如何与目标对象的方法交互。

     首先，我们来看一下代码中的关键部分：

     在这个切面中，使用了@Around注解来指定一个环绕通知，它会拦截所有A类的所有方法的执行。在around方法内部，通过ProceedingJoinPoint对象的process()方法来实际执行被拦截的方法。

     现在我们来回答问题：若调用A.f1()，标准输出中将打印什么内容？

     当调用A.f1()时，由于f1方法调用了f2方法，因此按照代码的逻辑，会先进入f1方法的执行上下文，然后立即跳转到f2方法的执行。但是根据切面的配置，任何对A类方法的调用都会被这个切面拦截。

     所以，实际的执行流程如下：

     综上所述，最终的标准输出将是f2，因为在调用链中，f2是第一个被切面拦截并执行的方法。

     在 @Around 环绕通知中，您可以通过代码的顺序来区分哪些代码是在目标方法执行之前执行的，哪些是在目标方法执行之后执行的。以下是基本的模式：

   @Around("execution(* com.example.TargetClass.targetMethod(..))") public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable { // 这里的代码会在目标方法执行之前执行 // 执行目标方法 Object result = pjp.proceed(); // 这里的代码会在目标方法执行之后执行 // 返回目标方法的执行结果 return result; }

     在这个模式中：

     下面是一个具体的例子：

   @Around("execution(* com.example.Service.*(..))") public Object logMethodExecution(ProceedingJoinPoint pjp) throws Throwable { // 目标方法执行之前的代码 long startTime = System.currentTimeMillis(); System.out.println("方法开始执行: " + pjp.getSignature().getName()); // 执行目标方法 Object result = pjp.proceed(); // 目标方法执行之后的代码 long endTime = System.currentTimeMillis(); System.out.println("方法执行完毕: " + pjp.getSignature().getName()); System.out.println("执行时间: " + (endTime - startTime) + "ms"); // 返回目标方法的执行结果 return result; }

     在这个例子中：

     通过这种方式，您可以清楚地定义在目标方法执行前后需要执行的代码。记住，环绕通知可以完全控制目标方法的执行，包括是否调用 pjp.proceed(); 以及调用多少次。如果环绕通知中没有调用 pjp.proceed();，那么目标方法将不会被执行。

   1. 类A的定义:

      public class A { public void f1() { f2(); } public void f2() { } }

   2. AspectJ 切面配置:

      @Around(execution(* A.*)) void around(ProceedingJoinPoint p) { // 1. 打印被拦截的方法名称 System.out.println(p.methodName()); // 2. 执行被拦截的方法 p.process(); }

   3. 进入f1方法的执行上下文。

   4. 由于f1方法的第一行就是调用f2方法，因此控制权立即转移到f2方法。

   5. 但是，因为f2也是A类的一个方法，它也会被相同的切面拦截。

   6. 因此，在执行到f2方法之前，切面会先打印出f2方法的名称。

   7. 然后，切面会继续执行f2方法本身。

   8. pjp.proceed(); 之前的代码是在目标方法执行之前执行的。

   9. pjp.proceed(); 之后的代码是在目标方法执行之后执行的。

   10. 我们在目标方法执行之前记录了开始时间，并打印了方法开始执行的信息。

   11. 然后调用 pjp.proceed(); 来执行目标方法。

   12. 在目标方法执行之后，我们记录了结束时间，并打印了方法执行完毕的信息以及执行所花费的时间。

2. 问题：Redis：cluster集群原理，客户端是怎样知道该访问哪个分片的？

答案：Redis Cluster是一种分布式数据库方案，它通过分片来提供数据扩展性和高可用性。Redis Cluster将数据分散在多个节点上，每个节点负责存储一部分数据。集群中有多个分片（shard），每个分片可以有多个副本（replica）用于故障转移。

客户端访问Redis Cluster的过程如下：

• 客户端首次连接到任意一个Redis节点时，会获取到整个集群的节点信息和插槽（slot）分布情况。

• Redis Cluster使用16384个插槽，数据根据键的CRC16哈希值映射到这些插槽中的一个。

• 客户端根据需要操作的键计算出哈希值，从而确定该键属于哪个插槽。

• 客户端查找负责该插槽的节点，并将请求发送到该节点。

• 如果客户端连接的节点不是目标节点，它会收到一个重定向错误（MOVED），并被告知正确的节点地址。客户端随后更新其内部缓存并重新发送请求到正确的节点。

1. 问题：MySQL：事务隔离级别，第三范式的作用与原理

答案：MySQL的事务隔离级别定义了一个事务可能受其他并发事务影响的程度。MySQL支持以下四种隔离级别：

• READ UNCOMMITTED：最低隔离级别，允许读取尚未提交的数据，可能导致脏读、不可重复读和幻读。

• READ COMMITTED：允许读取已经提交的数据，可以防止脏读，但不可重复读和幻读仍可能发生。

• REPEATABLE READ：确保同一事务中多次读取相同记录的结果一致，可以防止脏读和不可重复读，但幻读仍可能发生（MySQL默认级别）。

• SERIALIZABLE：最高隔离级别，强制事务串行执行，完全隔离，防止脏读、不可重复读和幻读，但性能最低。

第三范式（3NF）的作用与原理：

第三范式是数据库设计的一种规范，要求一个数据库表中的所有数据元素必须直接依赖于主关键字，而不是通过其他非主关键字数据来确定。其目的是消除数据冗余和更新异常。

• 作用：减少数据冗余，保证数据一致性，提高数据操作的效率。

• 原理：通过确保表中的每个非主属性既不部分依赖于主键也不传递依赖于主键，从而消除数据冗余和更新异常。

1. 问题：Java：谈谈多线程，缓存行是什么，伪共享是什么，Netty，BIO，NIO的原理与区别

答案：多线程是Java并发编程的基础，它允许程序同时执行多个操作，提高了程序的响应性和效率。

多线程：

• Java提供了Thread类和Runnable接口来创建和管理线程。

• 多线程可以通过共享内存和消息传递两种方式进行通信。

• Java内存模型（JMM）定义了多线程环境中共享变量的可见性、原子性、有序性等规则。

缓存行：

• 缓存行是CPU缓存中存储数据的基本单位，通常大小为64字节。

• 当CPU访问一个变量时，它会将包含该变量的缓存行加载到CPU缓存中，这样可以提高数据访问的速度。

伪共享：

• 伪共享发生在多个线程修改互相独立的变量时，这些变量恰好位于同一个缓存行中。

• 由于缓存行的更新需要刷新整个缓存行，即使这些变量之间没有数据依赖，也会导致性能下降。

Netty是一个基于NIO的客户、服务器端编程框架，用于快速开发高性能、高可靠性的网络应用程序。

BIO（Blocking I/O）：

• 原理：服务器端为每个客户端连接创建一个线程，阻塞等待客户端的请求。

• 区别：BIO模型在处理大量客户端连接时会导致资源浪费和性能瓶颈。

NIO（Non-blocking I/O）：

• 原理：NIO采用多路复用器（Selector）来同时监控多个通道，只有在通道真正有读写事件发生时，才会进行读写操作。

• 区别：NIO减少了线程数量，提高了性能，适用于高并发场景。

Netty的原理：

• 基于NIO，提供异步事件驱动的网络应用程序框架。

• 使用Reactor模式，通过少量的线程（EventLoop）处理大量的连接。

• 支持多种协议，具有高度可定制性和可扩展性。

39.快手后端一面

1. 问题：token存了哪些信息 为什么用JWT的token而不用redis的token？

答案：Token通常存储以下信息：

• 用户标识（User ID）

• 用户角色或权限

• 过期时间

• 签发时间

• 签发者

• 自定义的声明（如用户名、邮箱等）

使用JWT（JSON Web Tokens）的原因：

• JWT是自包含的，不需要在服务器端存储会话信息，减少了服务器存储的开销。

• JWT可以在不同的服务间传递，不需要考虑跨域资源共享（CORS）问题。

• JWT具有过期时间，可以控制令牌的有效期。

• JWT一旦生成，内容不可篡改，保证了安全性。

不使用Redis存储Token的原因：

• 需要维护Redis的会话状态，增加服务器复杂性。

• 在分布式系统中，Redis需要处理跨服务的数据同步问题。

• 如果Redis服务出现故障，会导致认证服务不可用。

1. 问题：如何用redis存储时序数据？

答案：可以使用以下方法在Redis中存储时序数据：

• 使用Sorted Sets（有序集合），其中时间戳作为分数，数据作为成员。

• 使用Redis Streams，它是一种可以持久化的消息队列，适合存储时间序列数据。

• 使用Hashes来存储每个时间点的数据，以时间戳作为键。

1. 问题：redis和mysql数据是否会不一致，如何解决？

答案：Redis和MySQL数据可能会不一致，通常发生在以下情况：

• 写操作先更新MySQL后更新Redis，但Redis更新失败。

• 读操作在MySQL更新后，Redis更新前发生。

解决方法：

• 使用事务或Lua脚本确保Redis操作的原子性。

• 使用发布/订阅模式，当MySQL数据更新时，发布消息给Redis进行更新。

• 使用延迟双删策略，先删除Redis缓存，再更新MySQL，最后再次删除Redis缓存。

1. 问题：为什么用NEO4J？面试官告诉我其实200w数据量的情况下往往mysql效率更高，NEO4J会遇到瓶颈。

答案：使用NEO4J的原因：

• NE04J是一个原生图数据库，适合存储和管理具有复杂关系的数据。

• 对于图算法和关系查询，NEO4J通常比关系型数据库更高效。

面试官的观点：

• 对于200万数据量，传统的关系型数据库如MySQL可能更高效，因为它们优化了SQL查询和索引。

• NEO4J在数据量达到一定规模时可能会遇到性能瓶颈，特别是对于写入操作和大规模图遍历。

1. 问题：Java的两种锁 底层实现是什么，ReentrantLock公平锁如何实现？

答案：Java中的两种锁：

• 内置锁（Intrinsic Lock）：通过synchronized关键字实现，依赖JVM的监视器锁（Monitor Lock）。

• 显式锁（Explicit Lock）：通过Lock接口实现，如ReentrantLock。

ReentrantLock的公平锁实现：

• 公平锁通过一个FIFO队列来维护等待获取锁的线程。

• 当锁被释放时，它优先分配给等待时间最长的线程。

• 内部使用一个变量state来表示锁的状态，并通过AQS（AbstractQueuedSynchronizer）来管理线程的排队和锁的获取与释放。

1. Spring容器特点及Bean生命周期管理：

   1. Spring容器提供了依赖注入和控制反转的功能，使得应用程序更加模块化和易于测试。

   2. Bean的生命周期包括实例化、属性赋值、初始化、使用和销毁五个阶段。这些阶段的执行可以通过配置文件或注解来实现。

2. 垃圾回收(CMS)的阶段：

   1. CMS(Concurrent Mark Sweep)收集器的垃圾回收过程主要包括初始标记、并发标记、重新标记、并发清除和重写标记五个阶段。

3. Mysql使用B+树索引的原因：

   1. B+树索引能够有效地减少磁盘I/O次数，加快数据的检索速度。此外，B+树的叶子节点包含了所有记录的地址，这使得范围查找变得更加高效。

4. Mysql解决幻读的方法：

   1. 幻读是指在同一事务中，两次读取同一范围内的数据，结果却出现了新的记录。为了解决这个问题，Mysql使用了间隙锁(Gap Locking)和下一键锁(Next-Key Locking)机制。

5. Redis集群可能出现的问题及解决方案：

   当然，以下是关于仲裁者(Arbiter)、Gossip协议和Sentinel监控的详细解释，以及它们在Redis集群中的作用和实现方式。

   仲裁者 (Arbiter)

   定义：

   仲裁者是一个在分布式系统中用于解决争议的独立组件。在Redis集群中，仲裁者可以用来在出现网络分区时决定哪个分区的节点继续提供服务。

   作用：

   • 在网络分区的情况下，集群可能会被分成多个分区，每个分区都有自己的主节点。

   • 仲裁者的作用是在这些分区中选择一个作为主分区，其他分区中的主节点将降级为从节点或关闭。

   实现方式：

   • 仲裁者通常是一个独立的Redis实例，它不存储任何数据，只负责在出现网络分区时进行投票。

   • 当网络分区发生时，各个分区的主节点会尝试与仲裁者通信，以获得投票。

   • 仲裁者会选择第一个与之通信的主节点作为主分区，其他分区的主节点将根据仲裁者的决定执行相应的操作。

   Gossip协议

   定义：

   Gossip协议是一种分布式通信协议，用于在集群中的节点之间传播信息。它通过随机的节点间通信，逐渐将信息传播到整个集群。

   作用：

   • Gossip协议用于Redis集群中节点的发现、状态更新和故障检测。

   • 它通过不断交换信息，使得集群中的每个节点都能获得整个集群的概览。

   实现方式：

   • 每个节点周期性地随机选择其他节点，并与它们交换信息。

   • 信息交换包括节点的状态、版本号、集群配置等。

   • 通过这种不断的随机通信，集群中的信息最终会收敛到一个一致的状态。

   Sentinel监控

   定义：

   Sentinel是Redis提供的一个系统，用于监控Redis实例的状态，并在主节点出现故障时进行自动故障转移。

   作用：

   • Sentinel监控主节点和从节点的健康状态。

   • 当主节点出现故障时，Sentinel能够自动将一个从节点升级为新的主节点，并通知其他从节点更新配置。

   实现方式：

   • Sentinel通过定期发送PING命令来监控主从节点的状态。

   • 当Sentinel检测到主节点不可达时，它会与其他Sentinel协商并进行故障转移。

   • 故障转移过程包括选择一个从节点作为新的主节点，并让其他从节点重新配置以复制新的主节点。

   • Sentinel还会对故障的主节点进行监控，一旦它重新上线，Sentinel会将其配置为从节点。

   总结来说，仲裁者、Gossip协议和Sentinel监控都是Redis集群中用于提高可靠性和自动故障转移的关键机制。仲裁者用于在网络分区时选择主分区，Gossip协议用于节点间信息的传播，而Sentinel则用于监控节点状态并在必要时进行故障转移。

   1. Redis集群可能会遇到脑裂和网络分区等问题。为了解决这些问题，可以采用仲裁者(Arbiter)、Gossip协议和Sentinel监控等方式。

6. Cluster架构下单节点数据量过大的应对措施：

   1. 当单节点的数据量过大时，可以考虑使用分片(Sharding)技术将数据分散到多个节点上。同时，也可以采用读写分离的方式减轻主节点的压力。

7. Java的两种锁及其底层实现：

   1. Java中的两种锁分别是内置锁(Synchronized)和显式锁(Lock)。内置锁是通过对象头的Mark Word来实现的，而显式锁则是通过AQS(AbstractQueuedSynchronizer)框架来实现的。

8. ReentrantLock公平锁的实现原理：

   1. ReentrantLock的公平锁是通过一个等待队列来保证线程按照请求锁的顺序获得锁。当一个线程尝试获取锁时，它会检查是否有其他线程已经在等待队列中，如果有，那么该线程就会进入等待队列并在队尾排队。

40.得物二面

1. 问题：线程有哪些状态并解释其含义？

1. 答案：

   • 初始（New）：创建后尚未启动的线程处于这种状态。

   • 运行（Runnable）：线程正在JVM中执行，但它可能正在等待操作系统分配处理器资源。

   • 阻塞（Blocked）：线程因为等待某些资源（如监视器锁）而被阻塞，暂时停止执行。

   • 等待（Waiting）：线程无限期地等待另一个线程执行特定操作（如notify）。

   • 超时等待（Timed Waiting）：线程在一定时间内等待另一个线程执行特定操作，或者等待某个特定的时间。

   • 终止（Terminated）：线程执行完成或者因为异常而终止。

1. 问题：超时等待的线程如何唤醒？

1. 答案：

   • 超时等待的线程可以通过以下方式唤醒：

     • 如果线程因为调用 Object.wait(long timeout) 进入超时等待状态，另一个线程可以调用 Object.notify() 或 Object.notifyAll() 来唤醒它。

     • 如果线程因为调用 Thread.sleep(long millis) 进入超时等待状态，时间到达后线程会自动唤醒。

     • 使用 java.util.concurrent.locks.LockSupport.parkNanos(long nanos) 或 LockSupport.parkUntil(long deadline) 方法可以让线程进入超时等待状态，通过调用 LockSupport.unpark(Thread thread) 可以唤醒该线程。

1. 问题：一个类有两个字段，一个short，一个boolean，那么这个类建立一个对象，需要占多大的内存空间？

1. 答案：

   • 在Java中，对象头（Object Header）通常占用16字节（32位系统）或24字节（64位系统），用于存储对象的元数据，如哈希码、GC信息、类信息等。

   • short 类型占用2字节。

   • boolean 类型在对象内部通常占用1字节，但由于Java对象的对齐规则，它可能会占用更多的空间。

   • 因此，这个对象的总大小至少是对象头大小加上字段大小。在64位系统上，可能是24（对象头）+ 2（short）+ 1（boolean，考虑对齐可能是4或8）= 27或31字节。

1. 问题：503与504状态码表示什么含义？

1. 答案：

   • 503 Service Unavailable：服务器目前无法处理请求，因为临时过载或维护。

   • 504 Gateway Timeout：服务器作为网关或代理，没有收到来自上游服务器的及时响应。

1. 问题：HTTPS与HTTP有什么区别？

1. 答案：

   • HTTPS（HTTP Secure）是HTTP的安全版本，主要区别在于HTTPS在传输层使用SSL/TLS协议加密数据，提供了数据传输的安全性。

   • HTTPS需要服务器配置SSL证书，客户端和服务器通过SSL握手建立加密连接。

   • HTTP传输数据是明文的，而HTTPS传输的数据是加密的，防止数据被中间人攻击。

1. 问题：Netty里面NIO的非阻塞是怎么实现的？

1. 答案：

   • Netty实现NIO非阻塞的关键在于使用Java NIO的Channel和Selector。

   • Channel提供了非阻塞的I/O操作，可以注册到Selector上。

   • Selector可以同时监控多个Channel的状态（如可读、可写），这样单个线程就可以管理多个网络连接，无需为每个连接创建一个线程。

1. 问题：Netty的那个NioEventLoop是怎么运行的啊？

1. 答案：

   • NioEventLoop本质上是Netty中的I/O线程，它负责处理网络事件。

   • 它运行在一个无限循环中，不断地轮询Selector，以检查是否有就绪的I/O事件。

   • 当Selector检测到就绪事件时，NioEventLoop会处理这些事件，如数据读取、写入等。

   • NioEventLoop也负责执行任务队列中的任务，这些任务可能是用户自定义的业务逻辑。

1. 问题：你这个商城项目什么架构？

1. 答案：

   • 商城项目可能采用了分层架构，如表现层、业务逻辑层、数据访问层。

   • 使用了微服务架构，将不同的业务功能划分为独立的微服务。

   • 可能采用了前后端分离的架构，前端使用React、Vue或Angular等框架，后端提供RESTful API。

1. 问题：你的这个订单啊，商品表怎么设计的啊？我现在这有个订单表，因为业务量太大了，他扛不住，怎么优化呢？

   1. 分库分表：

      1. 水平拆分：当单表数据量过大时，可以考虑按照某种规则（如订单ID范围、下单时间等）将数据水平拆分到多个数据库表中。

      2. 垂直拆分：将不同类型的数据存储到不同的数据库表中，例如，将订单的支付信息、用户信息、商品信息分别存储。

   2. 读写分离：

      1. 通过主从复制，将读操作和写操作分离，主库负责写操作，从库负责读操作，这样可以有效减轻数据库的压力。

   3. 缓存优化：

      1. 利用Redis等缓存技术，缓存热点数据，如频繁读取的商品信息、用户信息等，减少数据库访问次数。

   4. 索引优化：

      1. 合理创建索引，对于查询频繁且数据量大的字段，如订单ID、用户ID等，建立索引可以显著提高查询效率。

      2. 定期分析索引的使用情况，对于不合理的索引进行优化或删除。

   5. 数据归档：

      1. 对于历史订单数据，可以定期进行归档处理，将其迁移到低成本存储中，以减少在线数据库的负担。

   6. SQL优化：

      1. 优化SQL查询语句，避免全表扫描，减少不必要的复杂关联查询。

      2. 使用explain等工具分析查询计划，找出性能瓶颈。

   7. 硬件升级：

      1. 在软件优化无法满足需求时，可以考虑升级服务器硬件，增加CPU、内存、存储等资源。

   8. 服务拆分：

      1. 将订单服务与其他服务拆分，独立部署，根据业务特点进行资源分配。

   9. 异步处理：

      1. 对于非实时性要求的业务操作，如发送订单通知、生成订单报表等，可以采用消息队列进行异步处理。

   10. 限流与降级：

       1. 在高并发情况下，通过限流保护系统，防止雪崩效应。

       2. 在系统压力过大时，对非核心业务进行降级处理，保证核心业务的正常运行。

41.蚂蚁集团 Java研发 一面面经

1. 问题：线程池的基本工作逻辑、工作原理

答案：线程池的基本工作逻辑如下：

（1）线程池在初始化时，会根据用户设置的参数创建一定数量的线程。

（2）当有任务提交给线程池时，线程池会从空闲线程中选择一个来执行任务。

（3）如果所有线程都在执行任务，且任务队列未满，则将任务放入队列等待。

（4）如果任务队列已满，且线程数量未达到最大值，则创建新线程来执行任务。

（5）如果线程数量已达到最大值，则根据拒绝策略处理新任务。

线程池的工作原理主要基于以下三个组件：

（1）线程池管理器：用于创建、管理线程池，包括创建线程、销毁线程、分配任务等。

（2）工作线程：线程池中的线程，用于执行任务。

（3）任务队列：用于存放待执行的任务，实现任务排队和缓冲功能。

1. 问题：线程池的参数如何设置

答案：线程池的参数设置包括以下几方面：

（1）核心线程数（corePoolSize）：线程池中始终存在的线程数。

（2）最大线程数（maximumPoolSize）：线程池中允许的最大线程数。

（3）线程空闲时间（keepAliveTime）：当线程数量超过核心线程数时，多余的空闲线程在终止前等待新任务的最长时间。

（4）时间单位（unit）：线程空闲时间的单位。

（5）任务队列（workQueue）：用于存放待执行任务的队列。

（6）线程工厂（threadFactory）：用于创建新线程的工厂。

（7）拒绝策略（handler）：当任务无法被执行时，采用的拒绝策略。

参数设置应根据具体业务场景和系统负载进行优化，以下是一个参考值：

• 核心线程数：设置为 CPU 核心数的 1 倍或 2 倍。

• 最大线程数：设置为 CPU 核心数的 3 倍至 5 倍。

• 线程空闲时间：根据任务执行频率和系统负载进行调整。

• 任务队列：选择合适的队列类型，如 ArrayBlockingQueue、LinkedBlockingQueue 等。

1. 问题：为什么要用线程池

答案：使用线程池有以下优点：

（1）降低资源消耗：通过复用线程，减少创建和销毁线程的开销。

（2）提高响应速度：任务到达时，无需等待线程创建即可立即执行。

（3）提高线程的可管理性：线程池可以统一管理线程的创建、销毁、数量、优先级等。

（4）提供更多功能：如定时执行、线程中断、线程监控等。

1. 问题：java 的协程了解嘛

答案：Java 中的协程是通过 Project Loom 实现的，目前（截至 2024）Project Loom 仍处于实验阶段。协程是一种轻量级线程，可以在单个线程内实现多任务调度，具有以下特点：

（1）轻量级：协程的创建和切换开销远小于线程。

（2）非阻塞：协程可以通过挂起和恢复实现非阻塞等待。

（3）高效：协程可以减少线程上下文切换，提高 CPU 利用率。

1. 问题：zset 的底层数据结构

答案：Redis 中的 zset（有序集合）底层数据结构是跳跃表（Skip List）和字典（Hash Table）的结合。跳跃表用于实现有序集合的排序功能，字典用于实现元素与分数的映射关系。跳跃表中的每个节点都包含一个分值和指向其他节点的指针，可以实现快速的范围查询。

1. 问题：针对整个平台上所有主播热卖的商品，做一个热卖排行榜（实时按照销量排序）

答案：实现热卖排行榜的方案如下：

（1）使用 Redis 的 zset 存储商品销量数据，商品 ID 作为成员，销量作为分值。

（2）每当商品销量发生变化时，更新 zset 中的分值。

（3）使用 zrevrange 命令获取销量最高的 N 个商品，实现热卖排行榜。

1. 问题：数据库索引介绍

答案：数据库索引是一种数据结构，用于提高数据库表中数据的查询速度。索引的原理是通过创建一个额外的数据结构（如 B-树、哈希表等），将表中的数据按照一定规则进行排序和存储，从而加快查询速度。索引的类型包括：

（1）主键索引：唯一标识表中的每条记录。

（2）唯一索引：保证索引列中的值唯一。

（3）普通索引：用于加快查询速度。

（4）全文索引：用于全文检索。

1. 问题：G1 工作原理

答案：G1（Garbage-First）是一种面向服务器的垃圾回收器，旨在满足具有大内存需求的应用程序，并提供可预测的

垃圾回收暂停时间。G1的工作原理主要包括以下几个步骤：

（1）标记周期（Marking Cycle）：G1将堆内存划分为多个大小相等的独立区域（Region），并在标记周期中进行垃圾回收。标记周期分为以下几个阶段：

• 初始标记（Initial Mark）：暂停所有应用线程，标记从根集合直接可达的对象。

• 并发标记（Concurrent Mark）：与应用线程同时运行，标记所有存活对象。

• 最终标记（Final Mark）：暂停所有应用线程，处理在并发标记阶段发生的变更。

• 清除（Clean）：暂停所有应用线程，计算每个Region的存活对象数量，并回收完全空闲的Region。

（2）垃圾回收（Garbage Collection）：G1根据各个Region的垃圾回收价值（回收所获得的空间大小与回收所需时间的比值）来选择回收哪些Region。这个过程分为以下几个阶段：

• 选择回收Region（Selection）：根据Region的垃圾回收价值选择一组Region进行回收。

• 复制（Copying）：将选中的Region中的存活对象复制到新的Region，同时回收旧的Region。

（3）疏散暂停（Evacuation Pause）：在疏散暂停期间，G1会执行实际的内存复制和清理工作。这个过程可能会根据不同的策略进行优化，以减少暂停时间。

G1的目标是提供一个能够在不同应用负载下具有可预测的暂停时间的垃圾回收器，同时保持较高的吞吐量。

1. 问题：乐观锁，悲观锁，分别用来解决什么问题 答案：

• 乐观锁用来解决并发控制的问题，它假设在没有冲突的情况下进行数据操作，通常通过版本号或时间戳来实现。如果检测到冲突（即数据在读取和写入之间被其他事务修改），乐观锁会拒绝当前操作并通常需要重试。乐观锁适用于读多写少的场景，可以减少锁的开销，提高系统的并发能力。

• 悲观锁用来解决数据一致性问题，它假设在数据操作过程中一定会发生冲突，因此在操作数据前会先加锁，直到事务完成才释放锁。悲观锁适用于写多读少的场景，可以保证数据的一致性，但可能会降低系统的并发性能。

1. 问题：流量比较高，更新比较频繁的话，一般用哪种锁合适 答案：在流量较高且更新频繁的场景下，通常更合适的是使用悲观锁，因为悲观锁能够有效防止并发冲突，保证数据的一致性。然而，如果使用悲观锁导致性能瓶颈，可以考虑以下优化措施：

• 使用乐观锁结合冲突检测和重试机制，减少锁的开销。

• 使用细粒度锁或分段锁，减少锁的竞争。

• 使用读写锁（Read-Write Lock），允许多个读操作并发进行，只在写操作时加锁。

• 根据具体业务场景，考虑使用无锁编程技术，如原子操作、CAS（Compare And Swap）等。

选择哪种锁需要根据具体业务场景、系统负载和数据一致性要求来权衡。

42.网易互娱

1. 问题：集合和数组的区别？

答案：数组（Array）和集合（Collection）在Java中有以下区别：

• 定长与变长：数组是定长的，一旦创建，其大小不可变；集合是变长的，可以根据需要动态地添加或移除元素。

• 类型安全：数组是类型安全的，只能存储指定类型的元素；集合可以存储任意类型的对象，但通常需要指定泛型来保证类型安全。

• 接口和实现：数组是一个简单的线性数据结构，而集合是一个接口，有多种实现，如List、Set、Queue等，提供了更多功能和方法。

• 性能：数组在性能上通常优于集合，因为数组是直接在内存中分配连续的空间，而集合则需要额外的封装和处理。

1. 问题：传值和传引用的区别？

答案：在Java中，基本数据类型（如int、float等）传递是传值，而对象传递是传引用的副本。

• 传值（Pass by Value）：传递的是实际数据的副本，原始数据不受影响。

• 传引用（Pass by Reference）：传递的是对象引用的副本，指向同一个对象，因此对对象的修改会影响到原始对象。

1. 问题：如何判断String是否相等？

答案：在Java中，可以使用以下方式判断两个String对象是否相等：

• 使用equals()方法：比较两个字符串的内容是否相同。

• 使用==运算符：比较两个字符串对象的引用是否相同，即它们是否指向同一个对象。

1. 问题：G1垃圾回收的流程？

答案：G1垃圾回收的流程主要包括以下几个阶段：

• 初始标记（Initial Mark）：标记根集合直接可达的对象。

• 并发标记（Concurrent Mark）：与应用线程同时运行，标记所有存活对象。

• 最终标记（Final Mark）：处理在并发标记阶段发生的变更。

• 清除（Clean）：计算每个Region的存活对象数量，并回收完全空闲的Region。

• 复制（Copying）：将存活对象复制到新的Region，并回收旧的Region。

1. 问题：垃圾回收算法以及优缺点？

答案：常见的垃圾回收算法包括：

• 标记-清除（Mark-Sweep）：优点是简单，缺点是内存碎片和回收效率低。

• 标记-整理（Mark-Compact）：优点是解决了内存碎片问题，缺点是整理过程需要移动对象，可能影响性能。

• 复制（Copying）：优点是没有内存碎片，回收速度快，缺点是内存利用率低。

• 分代收集（Generational Collection）：优点是针对不同生命周期的对象使用不同的算法，提高回收效率，缺点是增加了算法的复杂度。

1. 问题：强软弱虚的区别？

答案：在Java中，四种引用类型的主要区别如下：

• 强引用（Strong Reference）：普通的对象引用，不会被垃圾回收器回收。

• 软引用（Soft Reference）：在内存不足时可以被垃圾回收器回收。

• 弱引用（Weak Reference）：在垃圾回收器工作时，无论内存是否充足都会被回收。

• 虚引用（Phantom Reference）：对对象的引用，任何时候都可能被回收，主要用于跟踪对象被回收的活动。

1. 问题：mysql事务机制，怎么解决脏读的发生？

答案：MySQL事务机制遵循ACID原则。脏读是指一个事务读取了另一个未提交事务修改的数据。解决脏读的方法是使用事务隔离级别，将隔离级别设置为READ COMMITTED或以上，这样事务只能读取已经提交的数据。

1. 问题：mysql的两级缓存是什么？

答案：MySQL的两级缓存指的是：

• MySQL服务器层的查询缓存：缓存查询结果，适用于经常执行相同查询的场景。

• InnoDB存储引擎的缓冲池（Buffer Pool）：缓存数据和索引，减少磁盘I/O操作。

1. 问题：索引底层实现？

答案：MySQL索引底层实现主要有以下几种：

• B-Tree索引：适用于全键值、键值范围和键值排序的查询。

• Hash索引：适用于等值查询，但不支持排序和部分匹配查找。

• R-Tree（空间索引）：用于空间数据类型，如GIS。

1. 问题：undolog、redolog、binlog的使用场景？

答案：使用场景如下：

• Undo Log：用于事务回滚，保证事务的原子性。

• Redo Log：用于系统崩溃后恢复数据，保证事务的持久性。

• Binlog（Binary Log）：用于数据复制和备份，可以实现主从复制和数据恢复。

由于回答长度限制，计网和操作系统的相关问题将在下一次输出中继续回答。

1. 问题：HTTP 和 HTTPS 有什么区别？

答案：HTTP（HyperText Transfer Protocol）和 HTTPS（HTTP Secure）的主要区别在于安全性：

• HTTP传输数据不加密，数据可能被中间人窃取或篡改。

• HTTPS在HTTP的基础上加入了SSL/TLS协议，对数据进行了加密，提高了数据传输的安全性。

• HTTPS需要服务器安装SSL证书，而HTTP不需要。

• HTTPS默认使用443端口，而HTTP使用80端口。

1. 问题：https每次都要分配密钥嘛？每次连接有多久，怎么确认失效了？

答案：

• HTTPS每次连接都会在SSL/TLS握手过程中生成会话密钥，用于该次连接的数据加密。

• HTTPS连接的持续时间取决于多种因素，包括服务器配置、客户端行为和空闲时间。通常，连接会在一段时间不活动后自动关闭。

• 连接的失效通常是通过以下方式确认的：

    -TLS心跳：某些实现使用TLS心跳来保持连接活跃，如果心跳失败，连接可能被认定为失效。

  • 超时：如果连接在指定的时间内没有数据传输，服务器或客户端可能会主动关闭连接。

  • 手动断开：客户端或服务器可以随时决定断开连接。

1. 问题：HTTP/1.1 和 HTTP/2.0 有什么区别？

答案：HTTP/1.1 和 HTTP/2.0 的主要区别包括：

• 多路复用（Multiplexing）：HTTP/2.0 允许在同一个连接中并行处理多个请求和响应，而HTTP/1.1需要为每个请求/响应打开新的连接。

• 二进制帧（Binary Frames）：HTTP/2.0 使用二进制帧进行数据传输，而HTTP/1.1 使用基于文本的格式。

• 头部压缩（Header Compression）：HTTP/2.0 使用HPACK算法压缩请求和响应头部，减少开销。

• 服务器推送（Server Push）：HTTP/2.0 支持服务器主动向客户端推送资源，而HTTP/1.1 不支持。

1. 问题：HTTP 是不保存状态的协议, 如何保存用户状态？

答案：HTTP协议本身是无状态的，但可以通过以下方式保存用户状态：

• Cookies：服务器发送到客户端的一小段数据，客户端在后续请求中会携带这些数据。

• Session：服务器端存储用户会话信息，通常通过一个唯一的会话ID来识别用户。

• URL参数：在URL中添加参数来传递状态信息。

• 隐藏表单字段：在HTML表单中添加隐藏字段来保存状态信息。

1. 问题：TCP 三次握手？

答案：TCP三次握手是建立TCP连接的过程，包括以下三个步骤：

• 第一次握手：客户端发送一个SYN报文到服务器，并进入SYN_SENT状态，等待服务器确认。

• 第二次握手：服务器收到SYN报文后，会发送一个SYN+ACK报文作为确认，并进入SYN_RCVD状态。

• 第三次握手：客户端收到服务器的SYN+ACK报文后，发送一个ACK报文作为确认，并进入ESTABLISHED状态，服务器在收到ACK报文后也进入ESTABLISHED状态。

1. 问题：为什么三次？

答案：三次握手是为了确保TCP连接的可靠性，具体原因如下：

• 确保双方都有发送和接收的能力。

• 防止已失效的连接请求突然又传送到了服务端，从而产生错误。

1. 问题：进程和线程的区别？

答案：进程和线程的主要区别包括：

• 定义：进程是系统进行资源分配和调度的基本单位，线程是进程的执行单元。

• 资源拥有：进程拥有独立的地址空间、资源（如打开的文件、I/O等），线程共享所属进程的资源。

• 调度和切换：线程的切换和调度通常比进程更高效，因为线程间共享更多的资源。

• 通信方式：进程间通信（IPC）需要特定的机制（如管道、消息队列等），线程间可以直接读写共享数据。

1. 问题：什么是用户态和内核态？

答案：用户态和内核态是操作系统中描述进程执行状态的两个概念：

• 用户态：进程执行用户程序时的状态，此时进程只能访问受限的资源。

• 内核态：进程执行内核程序时的状态，此时进程可以访问所有的系统资源，包括内存、I/O设备等。

1. 问题：进程间的通信方式有哪些？

答案：进程间的通信方式包括：

• 管道（Pipe）：半双工，只能在具有亲缘关系的进程间使用。

• 命名管道（FIFO）：半双工，可以在无关进程间进行通信。

• 消息队列（Message Queue）：消息的队列，可以实现消息的随机查询。

• 信号量（Semaphore）：主要作为同步工具，用于进程间的同步。

• 共享内存（Shared Memory）：

允许多个进程共享一段内存，是最快的IPC方式，但需要同步机制。

• 套接字（Socket）：可用于不同机器上的进程间通信，支持网络通信。

1. 问题：进程的调度算法有哪些？ 答案：进程的调度算法主要包括以下几种：

• 先来先服务（FCFS）：按照请求的顺序进行调度。

• 短作业优先（SJF）：优先调度运行时间最短的进程。

• 优先级调度：根据进程的优先级来调度，优先级高的进程先执行。

• 时间片轮转（Round Robin, RR）：按时间片轮流执行各个进程。

• 多级反馈队列（Multilevel Feedback Queue, MFQ）：将时间片轮转与优先级调度相结合，动态调整进程的优先级。

由于网络和操作系统的问题较为复杂，以下是针对这两个领域的一些基础问题的详细回答：

网络相关：

1. 问题：TCP 和 UDP 有什么区别？ 答案：TCP（传输控制协议）和 UDP（用户数据报协议）的主要区别在于：

• 连接性：TCP是面向连接的，需要建立连接后才能传输数据；UDP是无连接的，可以直接发送数据。

• 可靠性：TCP提供可靠的服务，确保数据正确、完整地传输；UDP提供不可靠的服务，可能会丢失、重复或顺序错乱。

• 流量控制：TCP有流量控制和拥塞控制机制；UDP没有。

• 用途：TCP适用于要求高可靠性的应用，如Web浏览、文件传输；UDP适用于实时应用，如视频会议、在线游戏。

1. 问题：OSI 七层模型和 TCP/IP 四层模型有什么区别？ 答案：OSI七层模型和TCP/IP四层模型的主要区别在于层次划分和功能：

• 层次：OSI模型分为七层，分别是物理层、数据链路层、网络层、传输层、会话层、表示层和应用层；TCP/IP模型分为四层，分别是网络接口层、网络层、传输层和应用层。物数网传会示应 接网输应

• 功能：OSI模型中，每一层都有明确的功能定义；而TCP/IP模型中，会话层、表示层和应用层通常合并为应用层。

操作系统相关：

1. 问题：什么是虚拟内存？ 答案：虚拟内存是计算机系统内存管理的一种技术，它将物理内存与虚拟内存分隔开来，使得每个进程都拥有一个连续的、大小足够的虚拟地址空间。虚拟内存可以有效地使用物理内存，提高系统的多任务处理能力，并通过分页或分段机制实现内存与磁盘之间的数据交换。

2. 问题：什么是死锁？如何避免死锁？ 答案：死锁是指两个或多个进程在执行过程中，因争夺资源而造成的一种互相等待的现象，如果没有外部干预，这些进程都将无法向前推进。 避免死锁的方法包括：

• 资源分配策略：避免循环等待，如银行家算法。

• 资源请求策略：一次性请求所有需要的资源，或者按顺序请求资源。

• 撤销进程：检测到死锁时，撤销一些进程，回收资源。

1. 问题：操作系统中的文件系统是如何工作的？ 答案：文件系统是操作系统用于组织和管理存储设备上文件和目录的数据结构。它的工作原理包括：

• 空间管理：负责分配和回收存储空间。

• 文件管理：负责文件的创建、删除、读写和权限设置等操作。

• 目录管理：负责维护文件系统的目录结构，支持文件的查找和访问。

• 索引管理：通过索引来提高文件访问的速度。

43.Wind

1. 问题：Spring的事务级别？

答案：Spring支持的事务级别与SQL标准的事务隔离级别相同，主要包括以下几种：

• 读未提交（READ UNCOMMITTED）：允许事务读取未被其他事务提交的数据，可能会导致脏读、不可重复读和幻读。

• 读已提交（READ COMMITTED）：只允许事务读取已经被其他事务提交的数据，可以避免脏读，但不可重复读和幻读仍可能发生。

• 可重复读（REPEATABLE READ）：确保事务可以多次读取同样的数据结果，而不会被其他事务的影响所改变，可以避免脏读和不可重复读，但幻读仍可能发生。

• 串行化（SERIALIZABLE）：确保事务完全隔离，即一个事务在执行过程中完全不受其他事务的影响，可以避免脏读、不可重复读和幻读，但会降低系统的并发性能。

1. 问题：Redis的zset用跳表实现的优缺点？为什么用跳表不用别的呢？

答案：

优点：

• 跳表在查找、插入和删除操作中都可以提供对数时间复杂度的性能。

• 跳表相比红黑树更容易实现和调试。

• 跳表在执行区间查询时效率较高，因为它们可以快速跳过大量节点。

缺点：

• 跳表的空间复杂度相对较高，因为它们需要额外的指针来维护多级索引。

为什么用跳表：

• Redis中的有序集合经常需要进行区间查询，跳表在这种操作中表现良好。

• 跳表的实现相对简单，易于维护和扩展。

• 跳表在内存数据库中表现良好，因为它们不需要像B+树那样进行节点分裂和合并的操作。

1. 问题：红黑树 vs 跳表

答案：

红黑树是一种自平衡的二叉查找树，它确保了最坏情况下的时间复杂度为O(logN)。红黑树的优点在于它是一种严格的平衡树，对于每个操作都有明确的性能保证。然而，红黑树在区间查询方面不如跳表高效，因为它们需要遍历更多的节点。

1. 问题：B+树 vs 跳表

答案：

B+树是一种用于数据库和文件系统的索引结构，它通过减少磁盘I/O来提高查询效率。B+树适合于存储大量数据的磁盘索引，但不适合作为内存数据库的索引结构，因为它们在内存中的性能不如跳表。

1. 问题：为什么用MQ中间件？有什么优点嘛？使用的是什么设计模式？

答案：

为什么用MQ：

• 解耦：允许不同的系统组件之间独立开发和部署。

• 异步通信：提高系统的响应速度和吞吐量。

• 削峰填谷：平衡系统负载，防止系统过载。

优点：

• 可靠性：MQ可以提供消息的持久化、事务性保证和错误处理机制。

• 扩展性：MQ可以轻松地扩展以处理更多的消息和更大的负载。

• 灵活性：支持多种消息传递模式，如点对点、发布/订阅等。

设计模式：

• 生产者-消费者模式：生产者发送消息到队列，消费者从队列中接收消息进行处理。

1. 问题：mysql如何解决幻读问题的发生呢？

答案：

MySQL通过以下方式解决幻读问题：

• 使用可重复读（REPEATABLE READ）隔离级别：在这个级别下，MySQL通过MVCC（多版本并发控制）来保证事务在执行过程中看到的数据是一致的，从而避免幻读。

• 加锁：在更新操作时，MySQL会使用间隙锁（Gap Locks）来锁定一个范围，防止其他事务在这个范围内插入新数据，从而避免幻读。

1. 问题：有了https实现加密通讯，哪里会发生安全隐患呢？

答案：

即使使用了HTTPS，以下安全隐患仍然可能发生：

• 中间人攻击：如果攻击者能够截获通信并伪造证书，仍然可以解密和篡改数据。

• 证书信任问题：如果信任的证书颁发机构被攻破，攻击者可以颁发伪造的证书。

• 旧版本协议和加密算法的漏洞：使用过时或不安全的协议和算法可能导致安全漏洞。

1. 问题：为什么还要有其他的基于https一些通讯协议呢？

答案：

基于HTTPS的通讯协议可能包括WebSocket、HTTP/2等，它们的目的如下：

• 提供更高效的数据传输：例如，HTTP/2通过头部压缩、多路复用等技术提高了性能。

• 支持新的应用场景：例如，WebSocket支持全双工通信，适用于实时应用。

1. 问题：Redis的zset用跳表实现的优缺点？为什么用跳表不用别的呢？ 答案： 优点：

• 跳表提供了对数级的查找、插入和删除操作时间复杂度，这对于Redis来说是非常重要的，因为Redis是内存数据库，性能至关重要。

• 跳表的实现相对简单，这使得Redis能够快速迭代和维护其数据结构。

• 跳表在区间查询时特别高效，这对于Redis的ZRANGE和ZREVRANGE命令非常有用，因为它们经常用于获取有序集合中特定范围内的元素。

缺点：

• 跳表需要更多的内存来存储索引，这可能会导致一些内存密集型操作的额外开销。

• 跳表在某些操作（如删除）时可能会有一些性能瓶颈，尤其是在删除操作需要移动大量节点时。

为什么用跳表：

• 跳表的性能和简单性使得它成为Redis实现有序集合（ZSET）的合适选择。

• 跳表不需要像红黑树那样维护严格的平衡，这简化了实现并降低了维护成本。

• 跳表的内存占用可以通过调整索引层数来优化，使得它在Redis这样的内存数据库中更加高效。

1. 问题：红黑树 vs 跳表 答案： 红黑树和跳表都是平衡二叉树，但它们在实现和性能上有所不同：

• 红黑树是一种自平衡的二叉查找树，它的每个节点都包含额外的红黑标记，用于确保树在插入和删除操作后保持平衡。

• 跳表是一种有序链表，其中包含多个索引层，每个索引层都包含指向链表的指针。这些指针允许跳表进行高效的跳跃查找。

在Redis中，跳表被选择来实现ZSET，主要是因为跳表在区间查找时更加高效，并且跳表的实现相对简单，不需要维护严格的平衡。

1. 问题：B+树 vs 跳表 答案： B+树和跳表都是用于存储和查询数据的结构，但它们在数据库和文件系统中更为常见：

• B+树是一种平衡树，其节点包含多个子节点，每个子节点都包含指向其他节点的指针。B+树特别适合用于数据库索引，因为它们可以高效地进行范围查询和顺序访问。

• 跳表是一种有序链表，包含多个索引层，这些索引层包含指向链表的指针。跳表特别适合用于Redis中的有序集合（ZSET），因为它们可以高效地进行区间查询和顺序访问。

在Redis中，跳表被选择来实现ZSET，主要是因为跳表在内存中更加高效，并且跳表的实现相对简单，不需要维护严格的平衡。

1. 问题：为什么用MQ中间件？有什么优点嘛？使用的是什么设计模式？ 答案： 为什么用MQ中间件：

• 解耦：允许不同的系统组件之间独立开发和部署，提高了系统的灵活性和可扩展性。

• 异步通信：允许系统组件在非阻塞状态下工作，提高了系统的响应速度和吞吐量。

• 削峰填谷：平衡系统负载，防止系统过载，尤其是在高峰时段。

优点：

• 可靠性：MQ可以提供消息的持久化、事务性保证和错误处理机制。

• 扩展性：MQ可以轻松地扩展以处理更多的消息和更大的负载。

• 灵活性：支持多种消息传递模式，如点对点、发布/订阅等。

设计模式：

• 生产者-消费者模式：生产者发送消息到队列，消费者从队列中接收消息进行处理。

1. 问题：mysql如何解决幻读问题的发生呢？ 答案： MySQL通过以下方式解决幻读问题：

• 使用可重复读（REPEATABLE READ）隔离级别：在这个级别下，MySQL通过MVCC（多版本并发控制）来保证事务在执行过程中看到的数据是一致的，从而避免幻读。

• 加锁：在更新操作时，MySQL会使用间隙锁（Gap Locks）来锁定一个范围，防止其他事务在这个范围内插入新数据，从而避免幻读。

1. 问题：有了https实现加密通讯，哪里会发生安全隐患呢？ 答案： 即使使用了HTTPS，以下安全隐患仍然可能发生：

• 中间人攻击：如果攻击者能够截获通信并伪造证书，仍然可以解密和篡改数据。

• 证书信任问题：如果信任的证书颁发机构被攻破，攻击者可以颁发伪造的证书。

• 旧版本协议和加密算法的漏洞：

使用过时或不安全的协议和算法可能导致安全漏洞。

• 客户端或服务器配置错误：如果客户端或服务器的HTTPS配置不正确，可能会导致安全漏洞。

• 密钥管理问题：如果密钥管理不当，可能会导致密钥泄露或被恶意使用。

• 用户行为：用户可能会点击恶意链接或下载恶意附件，从而导致安全隐患。

1. 问题：为什么还要有其他的基于https一些通讯协议呢？ 答案： 尽管HTTPS提供了一种强大的加密通信方式，但它并不是万能的。其他基于HTTPS的通讯协议可能旨在解决HTTPS的某些局限性或提供更高级的功能：

• WebSocket：它提供了一种全双工通信机制，允许客户端和服务器之间进行实时、双向的数据交换。

• HTTP/2：它是一个更高效的HTTP协议，通过多路复用、头部压缩和二进制帧等机制，提高了数据传输的效率。

• gRPC：它是一个高性能的远程过程调用（RPC）框架，使用HTTP/2作为底层通信协议，提供了一种简单、高效的方式来进行分布式系统之间的通信。

44.ZA Bank

1. 问题：反射的原理

答案：反射是Java语言提供的一种能力，允许程序在运行时取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。其原理是，Java虚拟机在运行时，会为每个类维护一个Class对象，该对象包含了类的结构信息，通过这个Class对象，可以动态地创建对象、访问属性、调用方法等。

1. 问题：反射有哪些主要的API

答案：Java反射的主要API包括：

• Class类：用于获取对象的类型信息。

• Constructor类：代表类的构造方法。

• Method类：代表类的方法。

• Field类：代表类的成员变量。

• Modifier类：提供关于访问修饰符的信息。

    下面是一个简单的业务项目示例，演示了反射的API。假设我们有一个简单的业务场景，其中有一个Person类，该类有几个属性和一个方法。我们将使用反射来创建Person对象、获取和设置属性值以及调用方法。

    首先，定义Person类：

  public class Person { private String name; private int age; public Person() {} public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public void introduce() { System.out.println("Hello, my name is " + name + " and I am " + age + " years old."); } }

    接下来，我们将使用反射API来操作Person类的实例：

  import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; public class ReflectionExample { public static void main(String[] args) { try { // 获取Person类的Class对象 Class<?> personClass = Class.forName("Person"); // 使用反射创建Person对象 Constructor<?> constructor = personClass.getConstructor(); Object personObject = constructor.newInstance(); // 获取name和age字段 Field nameField = personClass.getDeclaredField("name"); Field ageField = personClass.getDeclaredField("age"); // 设置私有字段的访问权限 nameField.setAccessible(true); ageField.setAccessible(true); // 设置字段值 nameField.set(personObject, "Alice"); ageField.set(personObject, 30); // 获取字段值 String name = (String) nameField.get(personObject); int age = ageField.getInt(personObject); System.out.println("Name: " + name + ", Age: " + age); // 调用introduce方法 Method introduceMethod = personClass.getMethod("introduce"); introduceMethod.invoke(personObject); } catch (Exception e) { e.printStackTrace(); } } }

    在这个例子中，我们做了以下几件事情：

    这个例子展示了反射API的基本用法，包括创建对象、访问和修改字段、调用方法等。在实际业务项目中，反射通常用于实现更高级的功能，如插件系统、动态代理、ORM框架等。

  • 使用Class.forName获取Person类的Class对象。

  • 通过Class对象获取无参构造器并创建一个Person实例。

  • 获取Person类的name和age私有字段，并设置它们的访问权限。

  • 设置Person对象的name和age属性值。

  • 获取Person对象的name和age属性值并打印。

  • 获取Person类的introduce方法并调用它。

1. 问题：反射会不会有安全问题，如果有的话如何避免

答案：反射确实可能带来安全问题，因为它可以访问和修改私有成员，破坏封装性。避免方法包括：

• 限制反射的使用，只在必要时使用。

• 使用安全管理器（Security Manager）来限制反射的权限。

• 对敏感操作进行权限检查。

1. 问题：Spring框架用到哪些设计模式

答案：Spring框架使用了多种设计模式，包括：

• 工厂模式：用于创建Bean实例。

• 单例模式：确保Bean的单一实例。

• 代理模式：用于实现AOP。

• 策略模式：用于选择不同的算法或行为。

• 观察者模式：事件发布与监听。

• 模板方法模式：定义算法骨架，让子类实现具体步骤。

1. 问题：适配器模式用在什么场景

答案：适配器模式用在以下场景：

• 当希望使用一个已经存在的类，但其接口不符合你的需求时。

• 当你想要创建一个可重用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。

• 当需要使用多个现有的子类，而这些子类又需要适配到同一个接口时。

1. 问题：Java BIO和NIO的区别 答案：Java BIO（Blocking I/O）和NIO（Non-blocking I/O）的主要区别在于：

• BIO是阻塞式的I/O操作，线程在执行I/O操作时会阻塞，直到操作完成。

• NIO是非阻塞式的I/O操作，线程在执行I/O操作时不会阻塞，可以通过Selector来管理多个通道（Channel）。

• BIO基于字节流和字符流进行操作，而NIO基于通道和缓冲区（Buffer）进行操作。

• NIO提供了更高级的数据操作方法，如scatter/gather等。

1. 问题：Java 8里面有哪些类使用了NIO 答案：Java 8中，以下类和接口使用了NIO：

• java.nio.channels包中的类，如SocketChannel、ServerSocketChannel、FileChannel等。

• java.nio.file包中的类，如Paths、Files等，用于文件操作。

• java.nio.charset包中的类，如Charset和CharsetEncoder/Decoder，用于字符集编码和解码。

1. 问题：Java NIO由哪些部分组成，详细展开讲一下 答案：Java NIO由以下几部分组成：

• Channels：通道，用于数据传输的通道，与传统的流不同，通道是双向的。

• Buffers：缓冲区，用于存储数据，是NIO中的核心概念。常用的缓冲区有ByteBuffer、CharBuffer等。

• Selectors：选择器，用于检查一个或多个通道是否准备好进行I/O操作。这使得单个线程可以管理多个通道。

• Scatter/Gather：分散/聚集，允许将数据分散到多个缓冲区，或者从多个缓冲区聚集数据。

1. 问题：Java如何读写超大文件 答案：Java读写超大文件时，应该使用缓冲区（Buffer）和通道（Channel），而不是直接使用流（Stream）。以下是一些步骤：

• 使用FileChannel来打开文件。

• 创建一个足够大的ByteBuffer作为缓冲区。

• 循环从FileChannel读取数据到ByteBuffer，处理完数据后，再从ByteBuffer写入到FileChannel。

• 使用transferTo()或transferFrom()方法来高效地传输数据。

1. 问题：如何写出有好的健壮性、可读性、可维护性的代码 答案：为了写出有好的健壮性、可读性、可维护性的代码，应该考虑以下方面：

• 遵循编码规范和命名约定。

• 使用面向对象的原则，如单一职责、开闭原则、里氏替换等。

• 编写充分的单元测试，确保代码质量。

• 使用异常处理来处理错误和异常情况。

• 避免硬编码，使用配置文件或常量来管理可变的数据。

• 添加适当的注释，说明代码的目的和工作原理。

1. 问题：HashMap中初始容量和负载因子的理解，设置这两个参数时要考虑哪些因素 答案：HashMap中的初始容量是指哈希表在创建时的容量大小，而负载因子是哈希表在其容量自动增加之前可以达到多满的一种度量。设置这两个参数时要考虑以下因素：

• 初始容量：应该根据预期存储的元素数量来设置，以减少哈希表的扩容操作，提高性能。

• 负载因子：较高的负载因子可以减少空间开销，但会增加查询成本（哈希冲突的概率增加）；较低的负载因子会提高查询效率，但会增加空间开销。通常，默认值为0.75是一个时间和空间成本上的折中。

1. 问题：如果一开始有100个数据，后面每10分钟增加50个数据，此时HashMap的初始容量和负载因子应该分别设置为多少，原因是什么 答案：如果一开始有100个数据，后面每10分钟增加50个数据，可以预估在HashMap达到需要扩容之前的时间。假设我们希望至少在1小时内不需要扩容，那么初始容量应该设置为100 + 6 * 50 = 400（因为1小时有6个10分钟）。负载因子可以保持默认值0.75，因为它是一个比较平衡的选择。所以，初始容量设置为400，负载因子设置为0.75。

2. 问题：如果一开始有100个数据，后面每一秒增加20个数据，此时HashMap的初始容量和负载因子应该分别设置为多少，原因是什么 答案：如果每秒增加20个数据，那么在一分钟内会增加1200个数据。为了确保在一段时间内不需要频繁扩容，可以设置一个更大的初始容量。假设我们希望在5分钟内不需要扩容，那么初始容量应该设置为100 + 300 * 20 = 6100。负载因子可以设置为略低于默认值，比如0.7，以减少哈希冲突的概率。因此，初始容量设置为6100，负载因子设置为0.7。

3. 问题：用8核CPU执行大量计算任务，此时线程池的核心线程数、最大线程数、任务队列和拒绝策略应该怎样设置 答案：线程池的设置应该根据任务的性质（CPU密集型或I/O密集型）和CPU的核心数来决定。对于CPU密集型任务：

• 核心线程数：可以设置为CPU核心数，即8。

• 最大线程数：可以设置为CPU核心数的1到2倍，即16到32，以处理短时间内的任务高峰。

• 任务队列：可以使用有界队列，如LinkedBlockingQueue，以避免内存溢出。

• 拒绝策略：可以采用CallerRunsPolicy，让调用者线程执行任务，或者AbortPolicy直接抛出异常。

1. 问题：如果线程池已经达到核心线程数，之后线程池会怎样处理后面的任务请求，描述一下过程 答案：如果线程池已经达到核心线程数，后续的任务请求将按照以下过程处理：

• 首先，任务会被放入任务队列中等待执行。

• 如果任务队列已满，线程池会创建新的线程，直到达到最大线程数。

• 如果线程数已经达到最大线程数，并且任务队列已满，线程池将根据设置的拒绝策略来处理新任务。

1. 问题：线程池如何处理异常 答案：线程池中的线程在执行任务时如果抛出异常，可以有以下几种处理方式：

• 在任务内部捕获并处理异常。

• 在提交任务时使用Future对象，调用get()方法时可以捕获异常。

• 通过实现Thread.UncaughtExceptionHandler接口，为线程设置一个未捕获异常处理器。

1. 问题：用explain命令分析一条SQL的执行计划，会输出哪些内容 答案：使用explain命令分析一条SQL的执行计划时，通常会输出以下内容：

• id：查询的序列号。

• select_type：查询类型，如SIMPLE（简单查询）、PRIMARY（外层查询）、UNION（union中的第二个或后面的查询语句）、SUBQUERY（子查询）等。

• table：显示这一行数据是关于哪张表的。

• partitions：匹配的分区。

• type：连接类型，如ALL（全表扫描）、index（索引全扫描）、range（范围查询）、ref（非唯一索引访问）、eq_ref（唯一索引访问）、const/system（单表中最多只有一个匹配行）等。

• possible_keys：指出MySQL能使用哪些索引来优化查询。

• key：实际使用的索引。

• key_len：使用的索引的长度。

• ref：显示索引的哪一列被使用了。

• rows：MySQL认为必须检查的用来返回请求数据的行数。

• filtered：表示返回结果的行数占需读取行数的百分比。

• Extra：包含MySQL解决查询的详细信息，如Using index（使用覆盖索引）、Using where（使用WHERE子句）、Using temporary（使用临时表）等。

1. 问题：如何利用explain命令的执行结果去优化SQL语句的执行效率 答案：利用explain命令的执行结果去优化SQL语句的执行效率，可以采取以下措施：

• 确认type列显示的是不是最优的连接类型，如果不是，考虑添加或优化索引。

• 检查key列，确认是否使用了正确的索引。

• 如果rows列的值非常大，考虑优化WHERE子句，或者检查是否需要返回所有这些行。

• 查看Extra列，如果有Using filesort或Using temporary，可能需要优化查询或重新设计表结构。

• 如果filtered值非常低，考虑优化WHERE子句或使用不同的索引。

1. 问题：对一张新的表创建索引要考虑哪些因素 答案：创建索引时需要考虑以下因素：

• 表的大小：小表可能不需要索引，因为全表扫描可能更快。

• 查询类型：频繁进行查询的列应该创建索引。

• 数据的唯一性：高唯一性的列适合创建唯一索引。

• 更新频率：频繁更新的列上创建索引可能会降低写入性能。

• 索引的维护成本：索引可以提高查询速度，但也会增加插入、删除和更新操作的开销。

1. 问题：解释一下数据库索引的最左匹配原则 答案：数据库索引的最左匹配原则指的是，对于复合索引（即多列索引），查询条件必须从索引的最左前列开始匹配，才能有效利用索引。如果查询条件不包含索引的最左前列，那么即使后面的列在索引中，也无法使用该索引。

2. 问题：B+树查询数据的过程 答案：B+树查询数据的过程如下：

• 从根节点开始，比较要查找的关键字与节点中的关键字，确定要查找的关键字在哪个区间。

• 根据区间指针，找到下一个节点（可能是中间节点或叶子节点）。

• 重复上一步，直到到达叶子节点。

• 在叶子节点中顺序查找，直到找到所需的数据项。

1. 问题：一张学生信息表，一张学生修读课程表，手撕SQL语句查询有三门以上的课程达到90分以上的学生信息和课程信息（写不出来），说一下你的SQL的实现思路以及如何给这两张表建索引 答案：实现思路如下：

• 首先，对学生修读课程表进行分组和过滤，找出每门课程分数大于90分的学生ID。

• 然后，对这些学生ID进行分组，统计每个学生达到90分以上的课程数量。

• 最后，将学生信息表与学生修读课程表进行连接，查询出满足条件的学生信息和课程信息。

索引建立思路：

• 在学生修读课程表上，对学生的ID和课程分数建立复合索引，以便快速筛选出分数大于90分的学生记录。

• 在学生信息表上，对学生的ID建立索引，以便快速连接查询。

具体的SQL语句和索引创建语句需要根据具体的表结构和字段来编写。

1. 问题：手撕场景编程题：在线程安全的条件下转账（我的代码用synchronized，通过了测试用例，面试官问如何提高并发度，不当 答案：为了提高并发度，可以考虑以下优化方案：

• 使用ReentrantReadWriteLock代替synchronized，允许多个读线程同时访问，只在写操作时才完全锁定。

• 使用原子类（如AtomicInteger或AtomicLong），这些类通过使用非阻塞算法提供了更高的并发性能。

• 使用java.util.concurrent包中的ConcurrentHashMap等并发集合，这些集合提供了线程安全的操作，通常比synchronized块有更好的并发性能。

• 如果转账操作可以容忍一定的 延迟，可以使用消息队列（如RabbitMQ、Kafka等）来异步处理转账请求，从而提高系统的吞吐量。

1. 问题：线程池如何处理异常 答案：线程池处理异常的方式通常有以下几种：

• 在任务内部捕获并处理异常，确保异常不会导致线程退出。

• 通过实现UncaughtExceptionHandler接口，为线程设置一个未捕获异常处理器，这样任何未捕获的异常都会被该处理器捕获。

• 使用Future对象来提交任务，并在调用get()方法时捕获异常。

45.刷面试直播遇到的知识点

1. execute和submit

在Java并发编程中，ExecutorService 接口提供了两种方法来执行任务：submit 和 execute。这两个方法在功能和使用场景上有所不同。

execute(Runnable command)

execute 方法是 Executor 接口的一部分，它接收一个 Runnable 对象作为参数。以下是 execute 方法的一些特点：

• 它没有返回值。这意味着你无法知道任务是否已经完成执行。

• 它不会抛出异常。如果 Runnable 在执行过程中抛出异常，那么异常将会被 JVM 捕获并处理（通常是打印堆栈跟踪信息），但是调用者不会得到任何通知。

• 它适用于不需要知道任务执行结果的情况。

示例代码：

ExecutorService executor = Executors.newCachedThreadPool(); executor.execute(new Runnable() { public void run() { // 执行任务 } }); executor.shutdown();

submit(Runnable task) 和 submit(Callable<T> task)

submit 方法是 ExecutorService 接口的一部分，它有多个重载版本，可以接收 Runnable 或 Callable 类型的参数。以下是 submit 方法的一些特点：

• 当使用 Runnable 参数时，submit 方法返回一个 Future 对象，但是这个 Future 对象仅仅用来判断任务是否执行完成，因为 Runnable 不返回结果，所以 Future.get() 将返回 null。

• 当使用 Callable 参数时，submit 方法返回一个 Future 对象，可以通过调用 Future.get() 方法来获取任务执行的结果。Callable 接口类似于 Runnable，但它可以返回一个结果，并且可以抛出异常。

• submit 方法允许你捕获执行过程中抛出的异常。你可以通过 Future.get() 方法来获取这些异常。

• 它适用于需要知道任务执行结果或者需要处理任务执行中可能抛出的异常的情况。

示例代码：

使用 Runnable：

ExecutorService executor = Executors.newCachedThreadPool(); Future<?> future = executor.submit(new Runnable() { public void run() { // 执行任务 } }); // 等待任务完成 future.get(); executor.shutdown();

使用 Callable：

ExecutorService executor = Executors.newCachedThreadPool(); Future<String> future = executor.submit(new Callable<String>() { public String call() throws Exception { // 执行任务并返回结果 return "Result"; } }); // 获取任务执行的结果 String result = future.get(); executor.shutdown();

总结：

• 如果你不需要知道任务何时结束，也不关心任务可能抛出的异常，那么使用 execute 方法。

• 如果你需要知道任务何时结束，或者需要任务执行的结果，或者需要处理任务执行中可能抛出的异常，那么使用 submit 方法。

1. 讲一讲这个future是什么回事

在Java中，Future 是一个接口，它提供了对异步操作结果的访问。当你提交一个任务给 ExecutorService 执行时，submit 方法会返回一个 Future 对象。这个对象可以用来检查任务是否完成、等待任务完成以及获取任务的结果。

以下是一个使用 Future 的简单例子，这个例子展示了如何提交一个 Callable 任务，并使用 Future 来获取执行结果：

import java.util.concurrent.*; public class FutureExample { public static void main(String[] args) throws InterruptedException, ExecutionException { // 创建一个 ExecutorService ExecutorService executor = Executors.newCachedThreadPool(); // 提交一个 Callable 任务，并返回一个 Future 对象 Future<String> future = executor.submit(new Callable<String>() { @Override public String call() throws Exception { // 模拟长时间的计算任务 Thread.sleep(2000); return "Hello from Callable"; } }); // 执行其他任务... // 获取 Callable 任务的执行结果 // 如果任务未完成，get() 方法会阻塞直到任务完成 String result = future.get(); System.out.println("Result: " + result); // 关闭 ExecutorService executor.shutdown(); } }

在这个例子中，我们执行了以下步骤：

1. 创建一个 ExecutorService 实例。

2. 通过 submit 方法提交一个 Callable 任务，并接收一个 Future 对象。

3. 执行其他任务。

4. 使用 Future.get() 方法获取 Callable 任务的执行结果。如果任务还未完成，get() 方法将阻塞直到任务完成。

以下是 Future 接口的一些常用方法：

• boolean cancel(boolean mayInterruptIfRunning)：尝试取消任务的执行。如果任务已完成、已被取消或由于其他原因无法取消，则此尝试将失败。如果参数 mayInterruptIfRunning 为 true 并且任务当前正在运行，那么它将被中断。

• boolean isCancelled()：如果此任务在正常完成之前被取消，则返回 true。

• boolean isDone()：如果任务已完成，无论是正常完成、异常结束还是被取消，都返回 true。

• V get()：等待任务完成，然后返回结果。如果任务被取消，将抛出 CancellationException。如果任务异常结束，将抛出 ExecutionException。如果当前线程在等待时被中断，将抛出 InterruptedException。

• V get(long timeout, TimeUnit unit)：与 get() 类似，但是如果在指定时间内任务未完成，将抛出 TimeoutException。

Future 提供了一种非阻塞的方式来检查任务是否完成，以及获取任务的结果，这是通过 isDone() 和 get() 方法实现的。然而，如果任务尚未完成，调用 get() 方法将会阻塞当前线程，直到任务完成。

1. 线程池代码机制分析：

     以下是一个复杂的示例，其中创建了一个自定义的ExecutorService线程池，使用了多个参数，并展示了如何使用这个线程池来执行具体的业务逻辑。

     在这个例子中，我们将创建一个线程池，该线程池具有以下参数：

     我们将使用这个线程池来执行一个假设的业务逻辑：计算一系列大整数的质因数分解。

   import java.util.concurrent.*; import java.util.stream.Collectors; import java.util.stream.IntStream; public class CustomThreadPoolExample { public static void main(String[] args) { // 创建自定义线程工厂 ThreadFactory customThreadFactory = new ThreadFactory() { private int count = 0; @Override public Thread newThread(Runnable r) { return new Thread(r, "custom-thread-" + count++); } }; // 创建有界队列 int queueCapacity = 10; BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>(queueCapacity); // 创建拒绝策略 RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.CallerRunsPolicy(); // 创建线程池 ThreadPoolExecutor executor = new ThreadPoolExecutor( 4, // 核心线程数 8, // 最大线程数 60, // 线程保持活跃的时间 TimeUnit.SECONDS, // 时间单位 workQueue, // 工作队列 customThreadFactory, // 线程工厂 rejectedExecutionHandler // 拒绝策略 ); // 提交任务到线程池 IntStream.range(1, 21) // 生成1到20的整数 .mapToObj(BigInteger::new) // 将整数转换为BigInteger对象 .map(number -> (Runnable) () -> factorize(number)) // 将每个BigInteger对象映射为一个Runnable任务 .forEach(executor::execute); // 将每个任务提交到线程池执行 // 关闭线程池 executor.shutdown(); try { // 等待线程池中的所有任务完成 if (!executor.awaitTermination(60, TimeUnit.SECONDS)) { executor.shutdownNow(); // 超时后尝试停止所有正在执行的任务 } } catch (InterruptedException ex) { executor.shutdownNow(); // 如果等待过程中线程被中断，尝试停止所有正在执行的任务 Thread.currentThread().interrupt(); // 保留中断状态 } } // 质因数分解方法 private static void factorize(BigInteger number) { System.out.println("Calculating prime factors of: " + number); // 这里只是一个示例，实际质因数分解应该有更复杂的逻辑 long start = System.nanoTime(); BigInteger one = BigInteger.ONE; BigInteger two = BigInteger.valueOf(2); BigInteger n = number; StringBuilder factors = new StringBuilder(); while (n.mod(two).equals(BigInteger.ZERO)) { factors.append(2).append(" "); n = n.divide(two); } for (BigInteger i = BigInteger.valueOf(3); i.multiply(i).compareTo(n) <= 0; i = i.add(two)) { while (n.mod(i).equals(BigInteger.ZERO)) { factors.append(i).append(" "); n = n.divide(i); } } if (n.compareTo(one) > 0) { factors.append(n); } long duration = System.nanoTime() - start; System.out.println("Prime factors of " + number + " are: " + factors + " (took " + duration + " ns)"); } }

     在这个例子中，我们创建了一个自定义的线程池，它使用了一个有界队列和一个自定义的线程工厂。我们还定义了一个拒绝策略，当队列满时，由提交任务的线程来执行该任务。

     业务逻辑是一个简单的质因数分解方法，它被包装在一个Runnable中，并提交到线程池执行。每个任务计算一个大整数的质因数，并将结果打印出来。

     请注意，这个例子中的质因数分解方法是简化的，并不适合实际的大数分解。实际应用中，你可能需要一个更高效的算法来处理大整数的质因数分解。

   1. 核心线程数（corePoolSize）

   2. 最大线程数（maximumPoolSize）

   3. 线程保持活跃的时间（keepAliveTime）

   4. 时间单位（unit）

   5. 工作队列（workQueue）

   6. 线程工厂（threadFactory）

   7. 拒绝策略（handler）

2. ReenteredLock分析

     在Java中，ReentrantLock提供了比传统的synchronized更多的功能，以下是一些主要优势，并通过代码示例来展示：

     以下是一个简单的代码示例，展示了ReentrantLock的这些优势：

   import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; public class ReentrantLockExample { private static Lock lock = new ReentrantLock(); public static void main(String[] args) { // 使用ReentrantLock的可中断锁获取功能：取消事件&&避免死锁 Thread t1 = new Thread(() -> { try { // 尝试获取锁，但可以被中断 lock.lockInterruptibly();//等价于加了Interruptibly功能的lock.允许你有中断的可能,当然你不中断也没事 try { System.out.println("Thread 1: Holding lock"); // 模拟长时间任务 Thread.sleep(500); } finally { System.out.println("Thread 1: Releasing lock"); lock.unlock(); } } catch (InterruptedException e) { System.out.println("Thread 1: Interrupted while waiting for the lock"); } }); // 使用ReentrantLock的tryLock功能 Thread t2 = new Thread(() -> { boolean hasLock = false; try { // 尝试非阻塞地获取锁 hasLock = lock.tryLock(); if (hasLock) { System.out.println("Thread 2: Holding lock"); } else { System.out.println("Thread 2: Did not get the lock"); } } finally { if (hasLock) { System.out.println("Thread 2: Releasing lock"); lock.unlock(); } } }); // 使用ReentrantLock的tryLock带超时功能 Thread t3 = new Thread(() -> { boolean hasLock = false; try { // 尝试在给定时间内获取锁 hasLock = lock.tryLock(1000, TimeUnit.MILLISECONDS); if (hasLock) { System.out.println("Thread 3: Holding lock"); } else { System.out.println("Thread 3: Did not get the lock within the timeout"); } } catch (InterruptedException e) { System.out.println("Thread 3: Interrupted while waiting for the lock"); } finally { if (hasLock) { System.out.println("Thread 3: Releasing lock"); lock.unlock(); } } }); // 启动线程 t1.start(); t2.start(); t3.start(); // 稍后中断线程1 try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } t1.interrupt(); } }

     在这个例子中：

     以上是ReentrantLock相较于synchronized的一些优势，需要注意的是，尽管ReentrantLock提供了更多灵活性，但它也更容易出错（例如忘记释放锁）。因此，在不需要额外功能的情况下，推荐使用synchronized，因为它更简洁，且由JVM管理，不容易出错。

   1. 可中断的锁获取：使用ReentrantLock可以在等待锁的时候响应中断。

   2. 尝试非阻塞地获取锁：可以使用tryLock()方法尝试非阻塞地获取锁。

   3. 尝试在给定时间内获取锁：tryLock(long timeout, TimeUnit unit)方法允许在给定时间内尝试获取锁。

   4. 公平性：ReentrantLock可以创建公平锁，而synchronized只能是非公平锁。

   5. 线程1尝试获取锁，并在锁内休眠一段时间。如果线程1在休眠期间被中断，它会捕获InterruptedException并释放锁。

   6. 线程2尝试非阻塞地获取锁，如果锁不可用，它会打印一条消息并继续执行。

   7. 线程3尝试在1秒内获取锁，如果在这段时间内没有获取到锁，它会打印一条消息并继续执行。

3. 中断锁的TEST

     要中断正在等待获取锁的线程，你需要调用该线程的interrupt()方法。下面是如何具体中断线程t1的示例：

   import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class InterruptibleLockExample { private static Lock lock = new ReentrantLock(); public static void main(String[] args) { // 使用ReentrantLock的可中断锁获取功能：取消事件&&避免死锁 Thread t1 = new Thread(() -> { try { // 尝试获取锁，但可以被中断 lock.lockInterruptibly(); try { System.out.println("Thread 1: Holding lock"); // 模拟长时间任务 Thread.sleep(500); } finally { System.out.println("Thread 1: Releasing lock"); lock.unlock(); } } catch (InterruptedException e) { System.out.println("Thread 1: Interrupted while waiting for the lock"); } }); // 启动线程 t1.start(); // 在主线程中稍后中断线程t1 try { Thread.sleep(200); // 等待一段时间，确保t1已经开始尝试获取锁 } catch (InterruptedException e) { e.printStackTrace(); } t1.interrupt(); // 中断线程t1 // 等待线程t1结束 try { t1.join(); } catch (InterruptedException e) { e.printStackTrace(); } } }

     在这个例子中，我们首先启动了线程t1，然后主线程休眠了200毫秒，以确保t1有足够的时间开始执行并尝试获取锁。之后，主线程调用t1.interrupt()来中断t1。如果t1正在等待获取锁，这个中断将导致InterruptedException被抛出，然后t1会捕获这个异常并打印出相应的消息。

     请注意，如果t1已经获取了锁，调用t1.interrupt()不会立即导致t1释放锁。只有在t1调用了会抛出InterruptedException的方法（例如Thread.sleep()）时，中断才会生效。如果t1没有调用这样的方法，那么即使t1被中断，它也会继续持有锁直到它完成工作并主动释放锁。

     如果一个线程没有使用 lock.lockInterruptibly() 方法来获取锁，而是使用了 lock() 方法，那么即使另一个线程调用 interrupt() 方法来中断它，这个线程也不会在等待锁的过程中抛出 InterruptedException。这是因为 lock() 方法会忽略中断请求，只有当线程获取到锁后，中断状态才会被设置，但不会抛出异常。

     以下是一些关键点：

   1. lock() 方法：这个方法会尝试获取锁，如果锁不可用，则线程会阻塞直到锁变为可用。在这个过程中，即使线程被中断，它也不会抛出 InterruptedException，而是继续等待锁。

   2. lockInterruptibly() 方法：这个方法也会尝试获取锁，但如果线程在等待锁的过程中被中断，它会立即抛出 InterruptedException。

   3. 中断状态：当一个线程被中断时，它的中断状态会被设置。即使 lock() 方法不响应中断，线程的中断状态仍然会被设置，线程可以在检查中断状态后自行决定如何响应。

46.满帮后端

1. 讲一下什么是CompletableFuture

     CompletableFuture 是 Java 8 引入的一个并发编程的实用工具类，它实现了 Future 接口并提供了一种更高级的异步编程模型。CompletableFuture 允许你对异步操作的结果进行组合、链式处理以及异常处理，而不需要显式地管理线程的生命周期。

     以下是 CompletableFuture 的一些关键特性：

     与接受 Executor 的 Callable 的 Future 相比，以下是它们之间的主要区别：

     总的来说，CompletableFuture 是 Future 的一个更强大、更灵活的实现，它简化了异步编程的复杂性，提供了更多的控制和灵活性。

   1. 非阻塞操作：CompletableFuture 提供了非阻塞的方法来处理异步操作的结果，比如 thenApply, thenAccept, thenRun 等。

   2. 组合多个 Future：你可以使用 thenCompose, thenCombine 等方法来组合多个 CompletableFuture。

   3. 异常处理：exceptionally 和 handle 方法可以用来处理异步操作中出现的异常。

   4. 响应式编程：CompletableFuture 支持响应式编程模型，允许你注册回调函数来响应异步操作的结果。

   5. 创建和完成：你可以手动创建一个 CompletableFuture 并在任何时候完成它，或者使用它的工厂方法来创建一个基于其他异步操作的 CompletableFuture。

   6. 创建方式：

      1. CompletableFuture 可以通过其静态方法如 supplyAsync, runAsync 等直接创建，无需显式地提供一个 Executor，尽管你可以传递一个 Executor 来控制异步任务的执行。

      2. Future 通常是通过 ExecutorService.submit(Callable task) 方法创建的，其中 Callable 是一个有返回值的任务，并且你需要提供一个 ExecutorService 来执行这个任务。

   7. 功能丰富性：

      1. CompletableFuture 提供了更丰富的API，允许你轻松地组合多个异步操作，处理异常，甚至可以等待多个 CompletableFuture 完成。

      2. Future 提供的功能相对有限，它只能检查任务是否完成、等待任务完成以及获取任务的结果。

   8. 非阻塞操作：

      1. CompletableFuture 提供了非阻塞的方法来处理异步结果，例如 thenApply, thenAccept 等。

      2. Future 中的 get 方法是阻塞的，它会一直等待直到任务完成或超时。

   9. 异常处理：

      1. CompletableFuture 提供了 exceptionally 和 handle 方法来优雅地处理异步操作中出现的异常。

      2. Future 的异常处理需要通过 get 方法抛出的异常来进行，这通常需要额外的 try-catch 块。

   10. 回调函数：

       1. CompletableFuture 允许你注册回调函数来在异步操作完成时执行，这是响应式编程的一个特点。

       2. Future 不支持直接注册回调函数，你需要定期检查任务是否已完成。

2. 问题：实习中怎么用的CompletableFuture进行异步编排？

答案：在实习中，我使用CompletableFuture进行异步编排主要是通过以下步骤实现的：

• 首先，创建CompletableFuture对象，通常使用其静态方法supplyAsync来异步执行一个供应者函数。

• 然后，通过thenApply、thenCompose或thenAccept方法来链式调用后续的处理步骤，这些方法允许我们在前一个阶段完成后，不阻塞主线程的情况下继续处理结果。

• 如果需要等待多个CompletableFuture全部完成，可以使用allOf方法，该方法会返回一个新的CompletableFuture，当所有给定的CompletableFuture完成后，新的CompletableFuture也会完成。

• 为了处理异常，可以使用exceptionally或handle方法来捕获并处理异步操作中出现的异常。

• 最后，如果需要同步等待所有异步操作完成，可以使用get方法。

import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; public class CompletableFutureExample { public static void main(String[] args) throws ExecutionException, InterruptedException { // 创建第一个异步任务，计算数字的平方 CompletableFuture<Integer> futureSquare = CompletableFuture.supplyAsync(() -> { int number = 5; return number * number; // 计算5的平方 }); // 创建第二个异步任务，计算数字的立方 CompletableFuture<Integer> futureCube = CompletableFuture.supplyAsync(() -> { int number = 5; return number * number * number; // 计算5的立方 }); // 当两个任务都完成时，合并它们的结果 CompletableFuture<Integer> combinedFuture = futureSquare .thenCombine(futureCube, (square, cube) -> square + cube); // 等待最终结果，并打印出来 Integer result = combinedFuture.get(); System.out.println("The combined result is: " + result); } }

import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; public class ECommercePlatform { public static void main(String[] args) throws ExecutionException, InterruptedException { // 模拟订单ID和商品ID String orderId = "123"; String productId = "456"; // 使用CompletableFuture异步获取订单详情 CompletableFuture<String> orderDetailsFuture = CompletableFuture.supplyAsync(() -> fetchOrderDetails(orderId)); // 使用CompletableFuture异步获取商品详情 CompletableFuture<String> productDetailsFuture = CompletableFuture.supplyAsync(() -> fetchProductDetails(productId)); // 等待两个异步操作都完成，并合并结果 CompletableFuture<String> combinedFuture = orderDetailsFuture .thenCombine(productDetailsFuture, (orderDetails, productDetails) -> { return "Order Details: " + orderDetails + "\nProduct Details: " + productDetails; }); // 打印合并后的结果 System.out.println(combinedFuture.get()); } // 模拟从数据库获取订单详情的方法 private static String fetchOrderDetails(String orderId) { // 模拟数据库查询延迟 try { Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } return "Order ID: " + orderId + " - Details from Database"; } // 模拟从外部API获取商品详情的方法 private static String fetchProductDetails(String productId) { // 模拟外部API调用延迟 try { Thread.sleep(1500); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } return "Product ID: " + productId + " - Details from External API"; } }

1. 问题：10万条数据有10条判断规则，怎么判断每个数据符合哪些规则？

答案：针对10万条数据和10条判断规则，可以采用以下策略进行判断：

• 使用并行流（Java 8及以上）：将数据集合转换为并行流，然后对每个元素应用规则判断，这样可以利用多核处理器加速处理过程。

• 使用线程池：创建一个固定大小的线程池，将数据分配给不同的线程进行处理，每个线程负责一部分数据的规则判断。

• 规则引擎：如果规则较为复杂，可以考虑使用规则引擎（如Drools），将规则预定义在规则引擎中，然后将数据输入进行匹配判断。

• 批处理：将数据分批处理，每批数据应用所有规则，这样可以减少内存消耗，并提高处理效率。

1. 问题：JVM的垃圾回收算法有哪些？

答案：JVM的垃圾回收算法主要包括以下几种：

• 标记-清除（Mark-Sweep）：此算法分为标记和清除两个阶段，首先标记出所有活动的对象，然后清除未被标记的对象。

• 标记-整理（Mark-Compact）：与标记-清除算法类似，但是在清除之后增加了整理过程，将所有存活的对象移动到内存的一端，以解决内存碎片问题。

• 复制（Copying）：将内存划分为大小相等的两块，每次只使用其中一块。在垃圾回收时，将存活的对象复制到另一块内存区域，然后清理掉旧的内存区域。

• 分代收集：将堆内存划分为不同的代（如新生代和老年代），根据不同代的对象特点采用不同的垃圾回收算法。

1. 问题：怎么排查OOM，怎么防止OOM发生？

答案：排查OOM的方法：

• 使用JVM提供的工具，如jstack、jmap、jconsole等，分析堆栈信息和堆内存快照。

• 分析日志文件，查找是否有OutOfMemoryError异常的堆栈跟踪。

• 使用VisualVM、MAT（Memory Analyzer Tool）等工具分析堆转储文件（heap dump）。

防止OOM的方法：

• 增加JVM堆内存大小，使用-Xmx和-Xms参数调整。

• 优化代码，避免内存泄漏，及时释放不再使用的对象。

• 使用缓存时，设置合适的缓存大小和过期策略。

• 使用轻量级对象，如使用基本类型数组代替包装类数组。

• 使用JVM参数-XX:+HeapDumpOnOutOfMemoryError生成OOM时的堆转储文件，便于事后分析。

1. 问题：线程池的参数有哪些，解释他们的作用？

答案：线程池的参数包括：

• corePoolSize：线程池中的核心线程数，即使它们是空闲的，也会保留在池中。

• maximumPoolSize：线程池中允许的最大线程数。

• keepAliveTime：当线程数大于核心线程数时，这是多余空闲线程在终止前等待新任务的最长时间。

• unit：keepAliveTime参数的时间单位。

• workQueue：用于在执行任务之前保存任务的队列。这个队列仅保存execute方法提交的Runnable任务。

• threadFactory：执行程序创建新线程时使用的工厂。

• handler：当线程池无法执行新任务时，调用handler处理被拒绝的任务。

1. 问题：Spring是单例还是多例的，怎么创建多个Spring实例？

答案：Spring框架管理的Bean默认是单例的。如果要创建多个Spring实例，可以在定义Bean时设置scope属性为prototype，这样每次请求Bean时，Spring容器都会创建一个新的实例。

1. 问题：TCP和UDP分别介绍一下，有什么区别？

答案：TCP（传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。它通过三次握手建立连接，保证数据包的顺序和数据的完整性。UDP（用户数据报协议）是一种无连接的、不可靠的、基于数据报的传输层协议。它发送数据之前不需要建立连接，并且不对数据包的顺序进行检查。

区别：

连接性：TCP是面向连接的，需要建立连接后才能发送数据；UDP是无连接的，发送数据前不需要建立连接。 可靠性：TCP提供可靠的服务，通过确认和重传机制确保数据的正确传输；UDP不保证数据传输的可靠性，可能会丢失或重复数据包。 有序性：TCP保证数据按顺序到达；UDP不保证数据包的顺序，可能会乱序到达。 速度：TCP由于其可靠性机制，速度相对较慢；UDP因为没有这些机制，传输速度较快。 用途：TCP适用于要求高可靠性的应用，如Web浏览器、电子邮件、文件传输等；UDP适用于实时应用，如视频会议、在线游戏等，它们可以容忍一定的数据丢失。

1. 问题：MySQL的索引介绍一下，建立索引的原则有哪些？ 答案：MySQL的索引是一种数据结构，可以快速地检索表中的数据。索引分为以下几种类型：

   1. B-Tree索引：最常见的索引类型，适用于全键值、键值范围和键值排序的搜索。

   2. Hash索引：基于哈希表实现，只有精确匹配索引所有列的查询才有效。

   3. Full-Text索引：用于全文检索，能够快速查找文本中的关键词。

建立索引的原则：

• 选择性：选择那些能够过滤掉大量数据的列作为索引，即高选择性的列。

• 尽量减少索引的长度：较短的索引可以更快地检索，减少I/O操作。

• 使用最频繁的列作为索引：对于经常出现在WHERE子句、JOIN条件、ORDER BY和GROUP BY中的列建立索引。

• 避免过度索引：不要为每一列都建立索引，过多的索引会降低写操作的性能。

• 考虑索引维护的成本：索引虽然可以提高查询速度，但也会增加插入、删除和更新操作的成本。

1. 问题：数据库三范式，为什么要打破三范式？ 答案：数据库三范式是指：

• 第一范式（1NF）：确保每列的原子性，即每列都是不可分割的最小数据单位。

• 第二范式（2NF）：在1NF的基础上，非主键属性完全依赖于主键。

• 第三范式（3NF）：在2NF的基础上，非主键属性不仅依赖于主键，而且不存在传递依赖。

为什么要打破三范式：

• 性能优化：为了提高查询性能，有时会故意引入一些冗余数据，这可能会违反第三范式。

• 简化查询：通过牺牲一些范式规则，可以简化复杂的查询，减少表之间的连接操作。

1. 问题：为什么要打破三范式、冗余数据的时候有哪些原则？ 答案：打破三范式通常是为了提高查询性能和简化查询逻辑。在引入冗余数据时，应遵循以下原则：

• 保持数据一致性：确保冗余数据与原始数据保持同步更新，避免数据不一致。

• 控制冗余程度：只引入必要的冗余数据，避免过度冗余导致的数据管理复杂度增加。

• 透明性：冗余数据的更新应该对应用层透明，应用层不需要关心数据的冗余情况。

1. 问题：对于冗余的数据，怎么保证数据的一致性？ 答案：保证冗余数据一致性的方法：

• 使用触发器：在数据库层面，通过触发器在数据变更时自动更新冗余数据。

• 应用层逻辑：在应用层维护冗余数据的一致性，确保每次数据更新时，相关的冗余数据也被同步更新。

• 事务管理：使用数据库事务来确保数据更新操作的原子性，要么全部成功，要么全部失败。

• 定期校验：通过定时任务定期检查冗余数据的一致性，并修复发现的差异。

1. 问题：Redis的使用场景有哪些？ 答案：Redis的使用场景包括：

• 缓存：作为数据缓存，减少数据库的访问压力。

• 会话缓存：存储用户会话信息，如购物车、用户登录状态等。

• 消息队列：利用发布/订阅模式或列表结构实现消息队列。

• 实时排行榜：利用Redis的数据结构和原子操作实现实时排行榜。

• 分布式锁：利用Redis的SETNX命令实现分布式环境下的锁机制。

1. 问题：热点key问题，怎么发现热点key？ 答案：热点key问题指的是在Redis中，某些key的访问量非常高，导致服务器负载不均。发现热点key的方法：

• 监控分析：使用Redis的监控工具，如Redis-stat、Redis-faina等，分析访问频率高的key。

• 日志分析：分析应用日志，找出频繁访问的key。

• 业务分析：结合业务特点，预测可能成为热点key的数据。

1. 问题：BIO、NIO、多路复用分别介绍一下。 答案：BIO（Blocking I/O）：

阻塞I/O，每个客户端连接对应一个线程，当线程在等待I/O操作（如读写操作）时，它会阻塞，直到I/O操作完成。这种方式在处理大量连接时会导致资源浪费，因为每个线程在大部分时间可能都是阻塞状态。

NIO（Non-blocking I/O）：非阻塞I/O，使用单个线程来管理多个通道（Channel），通过选择器（Selector）来监听多个通道的事件。当某个通道准备好进行I/O操作时，线程会执行相应的操作，而不会一直阻塞等待。这种方式可以有效地处理大量连接，因为它不需要为每个连接创建一个线程。

多路复用（I/O Multiplexing）：是一种同步I/O模型，允许单个线程同时监视多个文件描述符，等待它们中的一个或多个变得“就绪”可以进行I/O操作。常见的多路复用机制有select、poll、epoll等。在Java中，NIO的多路复用就是通过Selector实现的。

1. 问题：Java NIO中Buffer的三个核心参数是什么？ 答案：Java NIO中Buffer的三个核心参数是：

• position：缓冲区的位置，表示下一个要读取或写入的数据元素的索引。位置的范围从0到limit-1。

• limit：缓冲区的限制，表示缓冲区中第一个不能被读或写的元素的索引。缓冲区的容量永远不会小于其限制。

• capacity：缓冲区的容量，表示缓冲区可以存储的数据元素的最大数量。缓冲区的容量是固定的，一旦创建就不会改变。

47.深信服二面

1. 问题：消息队列怎么保证不丢失信息？

答案：为了保证消息队列不丢失信息，可以采取以下措施：

• 使用可靠的消息队列中间件，如RabbitMQ、Kafka等，它们提供了消息持久化的功能。

• 确保消息在被消费之前已经持久化到磁盘。

• 采用事务消息，确保消息发送和数据库操作的事务性。

• 使用消息确认机制（如ACK），确保消息被正确消费。

• 设置副本和备份，如Kafka的副本因子大于1，确保消息在某个节点故障时仍然可用。

1. 问题：MQ怎么发送消息的，MQ的消息如何保证幂等性？

答案：MQ发送消息的过程如下：

• 生产者将消息发送到MQ服务器。

• MQ服务器将消息存储在队列中。

• 消费者从队列中取出消息进行消费。

保证幂等性的方法有：

• 使用唯一标识（如消息ID）来确保消息处理的唯一性。

• 在数据库中为消息创建唯一索引，避免重复处理。

• 使用幂等接口设计，即使多次调用也不会产生副作用。

1. 问题：如何保证消费失败来进行处理？

答案：为了保证消费失败进行处理，可以采取以下措施：

• 实现重试机制，当消费失败时进行重试。

• 使用死信队列，将无法处理的消息放入死信队列，后续进行人工处理。

• 记录错误日志，便于排查问题。

• 监控消费进度，及时发现消费失败的情况。

1. 问题：如何站内用户间互相发送实时信息？ 答案：站内用户间互相发送实时信息可以通过以下方式实现：

   1. 使用WebSocket协议建立长连接，实现服务器与客户端的双向通信。

   2. 利用消息队列实现消息的实时推送，如使用RabbitMQ的发布/订阅模式或者Kafka的流处理。

   3. 使用第三方实时通讯服务，如Firebase Cloud Messaging、Pusher等。

   4. 在客户端实现消息的即时显示，通常使用JavaScript框架如Socket.IO或STOMP over WebSocket。

2. 问题：站内如何发全站广播邮件？ 答案：站内发全站广播邮件的方法如下：

   1. 使用邮件发送服务，如SendGrid、Amazon SES等。

   2. 设计邮件模板，并准备邮件内容。

   3. 从用户数据库中获取所有用户的邮件地址。

   4. 使用批处理或队列异步发送邮件，避免邮件发送过程中的性能问题。

   5. 监控邮件发送状态，确保邮件成功送达。

3. 问题：用户之间怎么进行(群聊单聊)实时通讯？ 答案：用户之间进行实时通讯（包括群聊和单聊）的方法包括：

   1. 单聊：通过点对点的WebSocket连接实现，或者通过服务器中转消息。

   2. 群聊：使用发布/订阅模式，所有群成员订阅同一个主题，发送的消息会广播给所有订阅者。

   3. 使用即时通讯框架，如XMPP、Matrix等，它们提供了单聊和群聊的解决方案。

   4. 在服务器端维护用户在线状态和会话信息，确保消息的准确推送。

4. 问题：你怎么观察消息队列的发送速率和队列处理信息的速率？ 答案：观察消息队列的发送速率和队列处理信息的速率可以通过以下方式：

   1. 使用消息队列中间件提供的监控工具，如RabbitMQ的Management Plugin、Kafka的Kafka Manager。

   2. 利用日志分析工具，如ELK栈（Elasticsearch, Logstash, Kibana）来分析日志数据。

   3. 自定义监控脚本或使用现有的监控框架，如Prometheus配合Grafana进行数据可视化。

   4. 检查系统性能指标，如CPU、内存使用情况，网络I/O等。

5. 问题：你平时在实习当中怎么发现bug并解决？ 答案：在实习中，发现并解决bug的方法如下：

   1. 仔细阅读代码，理解业务逻辑和功能需求。

   2. 利用日志文件，查看异常信息和错误栈跟踪。

   3. 使用调试工具，如IDE的调试器进行断点调试。

   4. 编写单元测试和集成测试，通过测试用例发现问题。

   5. 询问团队成员，获取可能的线索和解决方案。

   6. 通过版本控制系统（如Git）查看代码变更历史，分析引入bug的可能原因。

6. 问题：那么在你的项目中如何快速定位异常并解决？ 答案：在项目中快速定位异常并解决的方法包括：

   1. 实现全局异常处理机制，捕获并记录异常信息。

   2. 利用日志框架记录详细的错误日志，包括异常类型、堆栈信息等。

   3. 使用APM（应用性能管理）工具，如New Relic、Datadog等，监控应用性能和异常。

   4. 定期进行代码审查，提前发现潜在问题。

   5. 建立问题追踪系统，如JIRA，对异常进行跟踪和管理。

7. 问题：问有没有系统学习书籍，如果因为没有系统学习导致的bug在测试阶段都没有查出，到生产环境出了事故怎么办？ 答案：系统学习书籍推荐如下：

• 《Java并发编程实战》

• 《深入理解Java虚拟机》

• 《Effective Java》

• 《大型网站技术架构》

• 《高性能MySQL》 如果因为没有系统学习导致的bug在生产环境出现，应该：

• 立即回滚到上一个稳定版本，减少影响。

• 分析事故原因，总结教训，更新文档和测试用例。

• 加强代码审查和质量保证流程，防止类似问题再次发生。

• 对受影响的用户进行补偿或解释，恢复信誉。

1. 问题：为什么用ElasticSearch做搜索，而不用Mysql？ 答案：使用ElasticSearch做搜索而不用Mysql的原因包括：

• ElasticSearch是基于Lucene构建的搜索引擎，它专为全文搜索和数据分析而设计，具有优化的搜索算法和数据结构。

• ElasticSearch支持复杂的搜索条件，如模糊匹配、同义词处理、自动完成等，而Mysql主要用于结构化数据的查询。

• ElasticSearch可以横向扩展，支持大规模的数据搜索和分析，而Mysql通常用于事务处理，扩展性相对较低。

• ElasticSearch提供了实时的搜索结果，而Mysql在处理大量数据时可能会有延迟。

1. 问题：ElasticSearch有些组件，有什么特点，单机qps多少？ 答案：ElasticSearch的主要组件和特点如下：

• Elasticsearch集群：由多个节点组成，可以协同工作，共享数据并提供故障转移和扩展功能。

• Index：相当于数据库中的表，用于存储具有相似特征的数据。

• Type（已弃用）：在Elasticsearch 7.x中弃用，之前用于区分同一个索引下的不同类型数据。

• Document：相当于数据库中的行，是Elasticsearch中的基本数据单元。

• Shard：索引可以被分为多个分片，分片可以在集群中的不同节点上，提供分布式存储和搜索能力。

• Replica：分片的副本，用于提供数据的冗余和高可用性。

• 单机QPS（每秒查询率）取决于具体的硬件配置、索引设计、查询复杂度等因素，一般可以达到几千到几万不等。

1. 问题：ElasticSearch不也可以做数据库存储吗，为什么他不能在正常的项目中广泛使用？ 答案：虽然ElasticSearch可以用于数据存储，但它不适合在所有项目中广泛使用的原因包括：

• ElasticSearch是为搜索和分析而优化的，不是为事务处理而设计，因此它不支持ACID事务。

• 它的数据模型是扁平的，不适合存储具有复杂关系的数据。

• 写入性能不如传统数据库，特别是在高并发写入场景下。

• 数据更新和删除操作相对昂贵，不适合频繁更新的应用场景。

• 因此，ElasticSearch通常作为补充工具，用于需要全文搜索和复杂分析的场景，而不是作为主要的数据库存储。

1. 问题：SpringSecurity 你是怎么实现鉴权和认证，你说说ACL怎么跟SpringSecurity 配合的？ 答案：在SpringSecurity中实现鉴权和认证的方法如下：

• 配置WebSecurityConfigurerAdapter，定义哪些URL需要认证，哪些不需要。

• 使用AuthenticationManagerBuilder配置认证管理器，定义用户详细信息服务的来源（如数据库）。

• 实现UserDetailsService接口，加载用户详细信息和权限。

• 使用各种AuthenticationProvider进行认证，如UsernamePasswordAuthenticationToken。 ACL（Access Control List）与SpringSecurity配合的方式：

• 使用SpringSecurity的ACL模块，为域对象提供细粒度的访问控制。

• 定义AclService和AclEntry，将访问控制规则应用到具体的对象实例上。

• 结合MethodSecurityExpressionRoot，在方法安全性表达式中使用ACL表达式，如hasPermission()。

1. SpringSecurity的业务场景使用

     业务场景：在线教育平台用户权限管理

     场景描述：

     在线教育平台包含多种用户角色，如学生、教师、管理员等。不同角色的用户拥有不同的权限，例如学生可以观看课程、提交作业，教师可以发布课程、批改作业，管理员可以管理用户、课程等。为了保障平台的安全性，我们需要使用Spring Security来实现用户权限管理。

     场景具体实现：

     使用Spring Security实现用户登录认证。用户在登录页面输入用户名和密码，Spring Security对用户身份进行校验。

     根据用户角色分配不同的权限，具体如下：

     （1）学生角色：

     （2）教师角色：

     （3）管理员角色：

     使用Spring Security的URL权限控制，对不同角色的用户访问特定URL进行限制。以下是一些示例：

     在服务层方法上使用Spring Security注解，实现方法级别的权限控制。例如：

   @Service public class CourseService { @PreAuthorize("hasRole('ROLE_TEACHER')") public void addCourse(Course course) { // 教师添加课程 } @PreAuthorize("hasRole('ROLE_ADMIN')") public void deleteUser(User user) { // 管理员删除用户 } }

     通过以上业务场景，我们可以看到Spring Security在在线教育平台用户权限管理中的应用，有效保障了平台的安全性和用户体验。

     E. 整体代码预览

     要创建一个使用Vue.js前端和Spring Boot + Spring Security后端的项目，你需要设置两个独立的部分：前端和后端。下面是一个简化的指南，说明如何设置这样的项目。

     项目结构

     你的项目结构可能如下所示：

   my-education-platform/ ├── backend/ (Spring Boot project) │ ├── src/ │ ├── pom.xml │ └── ... └── frontend/ (Vue.js project) ├── src/ ├── public/ ├── package.json └── ...

     后端 (Spring Boot + Spring Security)

     以下是后端部分的关键代码示例：

     SecurityConfig.java:

   /** * @author 海加尔金鹰 www.hjljy.cn * @apiNote websecurtiy权限校验处理 * @since 2020/9/11 **/ @Configuration @EnableWebSecurity @EnableGlobalAuthentication public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter { /** * 描述: * http方式走 Spring Security 过滤器链，在过滤器链中，给请求放行，而web方式是不走 Spring Security 过滤器链。 * 通常http方式用于请求的放行和限制，web方式用于放行静态资源 **/ @Override protected void configure(HttpSecurity http) throws Exception { http .authorizeRequests() //用于配置直接放行的请求 .antMatchers("/login").permitAll() //其余请求都需要验证 .anyRequest().authenticated() //授权码模式需要 会弹出默认自带的登录框 .and().httpBasic() //禁用跨站伪造 .and().csrf().disable(); //如果项目没有前后端分离，还可以通过 formlogin配置登录相关的页面和请求处理 // 使用自定义的认证过滤器 // http.addFilterBefore(new MyLoginFilter(authenticationManager()),UsernamePasswordAuthenticationFilter.class); } /** * 描述: 静态资源放行，这里的放行，是不走 Spring Security 过滤器链 **/ @Override public void configure(WebSecurity web) { // 可以直接访问的静态数据 web.ignoring() .antMatchers("/css/**") .antMatchers("/404.html") .antMatchers("/500.html") .antMatchers("/html/**") .antMatchers("/js/**"); } /** * 描述：设置授权处理相关的具体类以及加密方式 */ @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { DaoAuthenticationProvider provider = new DaoAuthenticationProvider(); // 设置不隐藏 未找到用户异常 provider.setHideUserNotFoundExceptions(true); // 用户认证service - 查询数据库的逻辑 provider.setUserDetailsService(userDetailsService()); // 设置密码加密算法 provider.setPasswordEncoder(passwordEncoder()); auth.authenticationProvider(provider); } /** * 描述: 通过自定义的UserDetailsService 来实现查询数据库用户数据 **/ @Override @Bean protected UserDetailsService userDetailsService() { return new UserDetailsServiceImpl(); } /** * 描述: 密码加密算法 BCrypt 推荐使用 **/ @Bean public BCryptPasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } /** * 描述: 注入AuthenticationManager管理器 **/ @Override @Bean public AuthenticationManager authenticationManager() throws Exception { return super.authenticationManager(); } }

     CourseController.java:

   import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class CourseController { @GetMapping("/api/public/courses") public String getPublicCourses() { return "List of public courses"; } @GetMapping("/api/private/courses") @PreAuthorize("hasRole('ROLE_TEACHER') or hasRole('ROLE_ADMIN')") public String getPrivateCourses() { // 只有教师或管理员可以访问 return "List of private courses"; } }

     前端 (Vue.js)

   vue create frontend

   cd frontend npm install axios

     CourseList.vue:

   <template> <div> <h1>Courses</h1> <button @click="fetchPublicCourses">Get Public Courses</button> <button @click="fetchPrivateCourses">Get Private Courses</button> <p>{{ courses }}</p> </div> </template> <script> import axios from 'axios'; export default { data() { return { courses: '' }; }, methods: { async fetchPublicCourses() { try { const response = await axios.get('/api/public/courses'); this.courses = response.data; } catch (error) { console.error(error); } }, async fetchPrivateCourses() { try { const response = await axios.get('/api/private/courses', { auth: { username: 'admin', password: 'admin' } }); this.courses = response.data; } catch (error) { console.error(error); } } } }; </script>

   npm run serve

     集成与测试

     请注意，为了简化示例，这里使用了HTTP Basic认证。在实际应用中，您可能需要实现更复杂的认证机制，如JWT。

     以上步骤提供了一个基础的框架，用于创建一个使用Vue.js和Spring Boot + Spring Security的Web应用。根据实际需求，您可能需要添加更多功能，如用户注册、登录表单、权限验证等。

   1. 用户认证

   2. 角色权限控制

   3. 可以访问课程列表、观看课程视频

   4. 可以提交作业、查看作业成绩

   5. 可以发布课程、管理课程内容

   6. 可以布置作业、批改作业

   7. 可以查看所教授课程的学生名单及成绩

   8. 可以管理用户（包括学生、教师）信息，如添加、删除、修改用户

   9. 可以管理课程，如添加、删除、修改课程

   10. 可以查看平台运营数据

   11. URL权限控制

   12. 学生无法访问教师管理课程的URL

   13. 教师无法访问管理员管理用户的URL

   14. 未登录用户无法访问课程列表、课程详情等页面

   15. 方法权限控制

   16. 创建Spring Boot项目：使用Spring Initializr或IDE创建一个新的Spring Boot项目。

   17. 添加依赖：确保在pom.xml中添加Spring Security和Web依赖。

   18. 配置Spring Security：创建一个SecurityConfig类，配置用户认证和授权规则。

   19. 创建REST API：创建RESTful endpoints供前端调用。

   20. 创建Vue.js项目：使用Vue CLI创建一个新的Vue.js项目。

   21. 安装Axios：用于发送HTTP请求。

   22. 创建Vue组件：编写Vue组件以显示数据和与后端交互。

   23. 配置Vue Router（如果需要）。

   24. 启动Vue开发服务器：

   25. 启动后端服务：确保Spring Boot应用正在运行。

   26. 访问前端应用：在浏览器中访问Vue应用（通常是http://localhost:8080/）。

   27. 测试API访问：点击Vue应用中的按钮，观察是否能够正确地访问后端API。

48.百度社招一面

1. 问题：如果有一张一亿用户的用户表，你会怎么设计？

答案：设计一亿用户的用户表时，可以考虑以下策略：

• 分表分库：根据业务需求，可以将用户表进行水平拆分，比如按照用户ID进行哈希分片，将数据分散到多个数据库表中。

• 索引优化：为常用查询字段（如用户名、邮箱、手机号等）建立索引，提高查询效率。

• 字段选择：避免使用过多的大字段，如大文本、大图片等，可以考虑将大字段单独存储。

• 数据归档：对于不经常访问的历史数据，可以定期进行归档，减少在线数据量。

• 读写分离：通过主从复制实现读写分离，提高数据库的并发处理能力。

1. 问题：mysql数据达到多少会产生瓶颈？

答案：MySQL产生瓶颈的数据量没有固定的标准，它取决于多种因素，如硬件配置、数据库设计、索引优化、查询复杂度等。一般来说，当单表数据量达到千万级别时，可能会开始出现性能瓶颈。但通过优化索引、查询语句、硬件升级等方式，可以显著提高处理能力。

1. 问题：id哈希映射分库的话会产生什么问题？如何解决？

答案：问题：

• 数据分布不均：哈希映射可能导致某些分片数据量过大，而其他分片数据量较小。

• 扩容困难：增加或减少分片数量时，需要重新进行哈希映射，数据迁移成本高。

解决方法：

• 一致性哈希：使用一致性哈希算法，可以在扩容时减少数据迁移量。

• 预分片：提前规划分片数量，预留足够的空间，减少扩容频率。

• 动态调整：实现动态数据迁移策略，根据各分片的数据量和访问负载自动调整数据分布。

1. 问题：mysql 主从复制的过程。

答案：MySQL主从复制的过程大致如下：

• 主库操作：当主库上有数据更新时，这些操作会记录到二进制日志（binlog）中。

• 从库请求：从库上的I/O线程会请求主库的binlog，并将日志文件复制到自己的中继日志（relay log）中。

• 执行复制：从库的SQL线程会从中继日志中读取事件，并在从库上执行这些事件，从而实现数据的同步。

1. 问题：一道mysql，十岁为一组，统计每个年龄段的用户数量。

答案：可以使用以下SQL语句进行统计：

SELECT FLOOR(age / 10) * 10 AS age_group, COUNT(*) AS user_count FROM users GROUP BY age_group ORDER BY age_group;

这里假设用户表中有一个名为age的字段，表示用户年龄。

1. 问题：redis的内存淘汰策略？一组曾经是热点数据，后面不是了，对于lru和lfu处理时会有什么区别？ 答案：

   1. 内存淘汰策略：Redis的内存淘汰策略包括但不限于以下几种：volatile-lru（淘汰最近最少使用的设置了过期时间的键）、allkeys-lru（淘汰最近最少使用的键）、volatile-lfu（淘汰设置了过期时间的键中最少使用的键）、allkeys-lfu（淘汰最少使用的键）、volatile-random（随机淘汰设置了过期时间的键）、allkeys-random（随机淘汰键）等。

   2. LRU与LFU处理区别：

      • LRU（Least Recently Used）：当数据不再频繁访问时，这些数据最终会被淘汰，即使它们过去是热点数据。LRU主要考虑的是数据的使用时间。

      • LFU（Least Frequently Used）：LFU淘汰的是访问频率最低的数据。如果一组数据曾经是热点数据，但后来不再频繁访问，它们的访问频率会下降，最终可能被淘汰。LFU相比LRU，更加关注数据的访问频率而不是时间。

2. 问题：手撕：使用线程池获取10的阶乘 答案：以下是使用Java线程池来计算10的阶乘的示例代码：

import java.util.concurrent.*; public class FactorialCalculator implements Callable<Long> { private final int number; public FactorialCalculator(int number) { this.number = number; } @Override public Long call() { long result = 1; for (int factor = 2; factor <= number; factor++) { result *= factor; } return result; } public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(1); FactorialCalculator task = new FactorialCalculator(10); Future<Long> futureResult = executor.submit(task); try { long factorial = futureResult.get(); System.out.println("10的阶乘是: " + factorial); } catch (InterruptedException | ExecutionException e) { e.printStackTrace(); } finally { executor.shutdown(); } } }

49.顺丰Java一面

1. 问题：设计模式的实际应用，学过哪些设计模式，状态模式跟策略模式的区别？

答案：

• 实际应用：设计模式在软件开发中广泛应用于解决特定的问题，例如：

  • 单例模式：用于确保一个类只有一个实例，例如数据库连接池。

  • 工厂模式：用于创建对象，而不暴露创建逻辑，例如日志记录器。

  • 观察者模式：当一个对象状态改变时，所有依赖于它的对象都会得到通知，例如事件处理系统。

• 学过的设计模式：除了上述提到的，还有适配器模式、装饰器模式、代理模式、命令模式、责任链模式、中介者模式、原型模式、模板方法模式等。

• 状态模式与策略模式的区别：

  • 状态模式：它允许一个对象在其内部状态改变时改变其行为。状态模式通常用来实现状态机，状态对象通常代表不同的状态，并且封装了特定状态下的行为。

  • 策略模式：它定义了一系列算法，并将每个算法封装起来，使它们可以互相替换。策略模式让算法的变化独立于使用算法的客户。

1. 问题：mysql的mvcc机制？

答案：MVCC（多版本并发控制）是MySQL中InnoDB存储引擎实现事务的一种机制。它允许数据在事务中保持一致性，即使有其他事务正在修改相同的数据。MVCC通过以下方式实现：

• 隐藏版本列：每行数据都有一个隐藏的版本号，用于记录数据行的创建时间和删除时间。

• 读取视图：当事务开始时，它会创建一个一致性视图，用于读取数据。即使其他事务修改了数据，当前事务仍然看到的是创建视图时的数据版本。

• 非锁定读取：MVCC使得大多数读操作（如SELECT）不需要锁定数据行，从而提高了并发性能。

1. 问题：redis的aof、rdb的区别是什么，缓存穿透、缓存雪崩、缓存击穿这些是什么？

答案：

• AOF与RDB的区别：

  • RDB（快照）：定期将内存中的数据以快照形式保存到磁盘上，恢复速度快，但可能会丢失最后一次快照后的数据。

  • AOF（追加文件）：记录每个写操作命令到日志文件中，重启时通过重新执行这些命令来恢复数据，数据安全性更高，但文件体积可能较大，恢复速度较慢。

• 缓存穿透：查询不存在的数据，导致请求直接打到数据库上，造成数据库压力过大。

• 缓存雪崩：缓存中大量数据同时过期，导致大量请求直接访问数据库，造成数据库压力过大。

• 缓存击穿：热点数据在缓存中失效，导致大量请求在短时间内直接访问数据库。

1. 问题：死锁是什么？

答案：死锁是指两个或多个进程在执行过程中，因争夺资源而造成的一种互相等待的现象，如果没有外力干涉，它们都无法继续执行下去。在数据库中，死锁通常发生在两个或多个事务互相等待对方释放锁定的资源。

1. 问题：Jvm类加载的过程？

答案：Jvm类加载的过程包括以下五个步骤：

• 加载：通过类加载器读取字节码文件，生成一个Class对象。

• 验证：确保加载的类信息符合JVM规范，没有安全方面的问题。

• 准备：为类变量分配内存，并设置默认初始值。

• 解析：将符号引用替换为直接引用。

• 初始化：执行类构造器<clinit>()方法，为类变量赋予正确的初始值。

1. 问题：kafka的消息确认过程是什么？ 答案：在Kafka中，消息确认通常指的是消费者确认它已经成功处理了消息。这个过程涉及以下步骤：

   1. 消费消息：消费者从Kafka主题的分区中拉取消息。

   2. 处理消息：消费者对消息进行处理。

   3. 提交偏移量：处理完消息后，消费者会向Kafka提交它已经成功消费的消息的偏移量。这个偏移量是在消费者组内部进行维护的，以确保每个消费者在重新启动后能够从上次提交的偏移量继续消费。

   4. 确认机制：Kafka提供了至少一次（at least once）和最多一次（at most once）的消息投递保障，这取决于消费者的配置。通常是通过enable.auto.commit配置项来控制是否自动提交偏移量，或者手动调用commitSync()或commitAsync()方法来提交。

2. 问题：RabbitMq和kafka的区别什么，适用场景有哪些？ 答案：

   1. 区别：

      • 消息模型：RabbitMQ遵循AMQP协议，支持多种消息模型，如点对点、发布/订阅等。Kafka基于发布/订阅模型，但提供了分布式流处理的功能。

      • 数据持久化：RabbitMQ默认情况下消息是存储在内存中的，可以配置为持久化到磁盘。Kafka默认将消息持久化到磁盘，并且设计为高吞吐量。

      • 分布式：Kafka是为分布式设计，支持水平扩展，而RabbitMQ虽然也支持集群，但通常用于更传统的消息队列场景。

   2. 适用场景：

      • RabbitMQ：适用于需要保证消息可靠传输、事务支持、复杂的消息路由等场景。

      • Kafka：适用于需要高吞吐量、可扩展的消息处理系统，特别是在大数据和实时数据流处理领域。

3. 问题：dubbo为什么快，RPC跟http的区别是什么？ 答案：

   1. Dubbo为什么快：

      • 高效序列化：Dubbo默认使用Hessian序列化，它比Java序列化更快，数据包体积也更小。

      • NIO通信：Dubbo使用Netty等NIO框架进行网络通信，提供了非阻塞的网络调用，提高了网络通信效率。

      • 服务治理：Dubbo内置了服务发现、负载均衡等治理功能，可以优化服务调用链路。

   2. RPC与HTTP的区别：

      • 传输协议：RPC通常使用二进制协议，而HTTP使用基于文本的协议，RPC的传输效率更高。

      • 抽象程度：RPC提供了更高级别的抽象，允许像调用本地方法一样调用远程服务，而HTTP则需要处理请求和响应的细节。

      • 性能开销：RPC通常比HTTP更轻量，因为它省略了很多HTTP协议中的冗余信息。

4. 问题：tcp三次握手过程，为什么三次，两次行不行？ 答案：

   1. 三次握手过程：

      • 第一次握手：客户端发送一个SYN报文到服务器，并进入SYN_SENT状态，等待服务器确认。

      • 第二次握手：服务器收到SYN报文，会应答一个SYN+ACK报文，并将连接状态设置为SYN_RCVD。

      • 第三次握手：客户端收到服务器的SYN+ACK报文后，发送一个ACK报文，然后双方进入ESTABLISHED状态，完成握手。

   2. 为什么是三次：

      • 确保双方都有发送和接收的能力。

      • 防止已失效的连接请求突然又传送到了服务端而产生错误。

   3. 两次行不行：

      • 不行。如果只有两次握手，客户端发送的SYN可能会在网络中长时间滞留，最终到达服务器。如果没有第三次握手来确认这个SYN的有效性，服务器可能会错误地认为这是一个新的连接请求，从而建立不必要的连接，浪费资源。

50.字节一面

1. 问题：Canal 监听 binlog 同步缓存，canal binlog 断流怎么办？

答案：Canal 是一个用于数据库实时增量数据订阅和消费的应用程序，它会监听 MySQL 的 binlog 来同步数据。如果遇到 canal binlog 断流，可以采取以下措施：

• 检查 MySQL 配置：确保 MySQL 的 binlog 日志格式设置为 ROW 模式，并且 binlog 相关的配置参数（如 max_binlog_size、binlog_format、binlog_row_image）是正确的。

• 重连机制：实现自动重连机制，当 Canal 检测到连接断开时，尝试重新连接 MySQL。

• 位点记录：Canal 会记录处理过的 binlog 位点信息，断流后可以从上次记录的位点重新开始同步。

• 监控与报警：设置监控和报警机制，一旦发现 binlog 断流，立即通知运维人员处理。

1. 问题：mysql 用的什么存储引擎？

答案：MySQL 默认的存储引擎是 InnoDB，从 MySQL 5.5 版本开始，InnoDB 成为了默认的存储引擎。除此之外，MySQL 还支持 MyISAM、Memory、Archive、CSV、BLACKHOLE 等多种存储引擎。

1. 问题：innodb 有啥特性？

答案：InnoDB 存储引擎具有以下特性：

• 事务支持：支持 ACID 事务，具有原子性、一致性、隔离性和持久性。

• 行级锁定：支持行级锁定，减少了多用户访问时的锁争用。

• 多版本并发控制（MVCC）：提高了并发读取的性能。

• 崩溃恢复：具有自动崩溃恢复功能，能够保证数据的一致性。

• 外键支持：支持外键约束，维护数据的引用完整性。

• 聚簇索引：使用聚簇索引来存储数据，减少了数据检索时的磁盘 I/O。

1. 问题：myisam 为什么不能支持事务？

答案：MyISAM 不支持事务的原因包括：

• 设计目标：MyISAM 是为读操作优化设计的，它更注重数据读取的效率而非事务的完整性。

• 锁定机制：MyISAM 使用表级锁定，不支持行级锁定，这在并发事务处理中会导致较大的性能问题。

• 缺乏日志机制：MyISAM 没有类似于 InnoDB 的重做日志（redo log）和回滚日志（undo log），因此无法提供事务的原子性和持久性。

1. 问题：innodb 如何实现 acid？

答案：InnoDB 通过以下方式实现 ACID 特性：

• 原子性（Atomicity）：通过事务日志（redo log）和事务回滚日志（undo log）确保事务要么全部成功，要么全部失败。

• 一致性（Consistency）：通过数据库的约束（如外键约束、检查约束）和事务的隔离级别来保证数据的一致性。

• 隔离性（Isolation）：通过多版本并发控制（MVCC）和行级锁定实现不同事务之间的隔离。

• 持久性（Durability）：通过将事务日志写入磁盘，并确保在系统崩溃后能够恢复，来保证事务的持久性。

1. 问题：Innodb 那个底层的索引用的什么数据结构？

答案：InnoDB 底层的索引使用的数据结构是 B+ 树。B+ 树是一种自平衡的树结构，它能够保持数据有序，并且提供高效的插入、删除和查找操作。

1. 问题：如果我建了一个联合索引，在 b+树上它是怎么存的呢？它是存一个节点还是存多个节点？

答案：联合索引在 B+ 树上的存储方式是，每个节点（包括非叶子节点和叶子节点）都会包含索引列的所有值。对于联合索引来说，每个索引节点会按照索引定义的列顺序存储数据，而不是分开存储。因此，每个节点实际上是存储了多个列的值。

1. 问题：为什么查询会有一个最左前缀原则？

答案：最左前缀原则是指在联合索引中，如果查询条件中使用了索引的第一个列，那么索引将会被使用。这是因为联合索引在 B+ 树中的存储顺序是按照索引定义的列顺序来排序的。如果查询条件不包含最左边的列，那么无法保证其余列的顺序，因此无法使用索引进行有效的查找。

1. 问题：Java 里面的 map 大概分为你知道的有哪些种类，介绍一下他们各自的适用场景？

答案：Java 中的 Map 接口有几种常见的实现：

• HashMap：基于哈希表实现，适用于在查找、插入和删除操作中需要高效率的场景，不保证顺序。

• LinkedHashMap：继承自 HashMap，但它维护了一个双向链表来记录插入顺序或者访问顺序，适用于需要保持插入顺序或者访问顺序的场景。

• TreeMap：基于红黑树实现，能够实现键的排序，适用于需要按键的自然顺序或者自定义顺序遍历键值对的场景。

• Hashtable：是线程安全的，但性能不如 HashMap，适用于需要线程安全且不介意性能稍低的场景。

• ConcurrentHashMap：提供了更好的并发性能，适用于高并发场景，通过分段锁技术减少了锁竞争。

• WeakHashMap：允许键对象被垃圾回收器回收，适用于缓存实现，其中键的生命周期不需要比值更长。

• IdentityHashMap：使用 == 而不是 equals 来比较键，适用于需要比较对象身份的场景。

1. 问题：算法：二叉树锯齿遍历？ 答案：二叉树的锯齿遍历（Zigzag Traversal）是指按照之字形层序遍历二叉树。以下是使用 Java 实现的一种方法：

import java.util.*; public class ZigzagTraversal { public List<List<Integer>> zigzagLevelOrder(TreeNode root) { List<List<Integer>> result = new ArrayList<>(); if (root == null) return result; Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root); boolean leftToRight = true; while (!queue.isEmpty()) { int levelSize = queue.size(); List<Integer> currentLevel = new ArrayList<>(); for (int i = 0; i < levelSize; i++) { TreeNode currentNode = queue.poll(); // Add the node value to the current level based on the direction if (leftToRight) { currentLevel.add(currentNode.val); } else { currentLevel.add(0, currentNode.val); } // Add child nodes to the queue if (currentNode.left != null) queue.offer(currentNode.left); if (currentNode.right != null) queue.offer(currentNode.right); } // Add the current level to the result and toggle the direction result.add(currentLevel); leftToRight = !leftToRight; } return result; } // Definition for a binary tree node. public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } }

在这个算法中，我们使用一个队列来进行层序遍历，并通过一个布尔变量 leftToRight 来控制每一层的添加顺序。当 leftToRight 为 true 时，我们正常地从左到右添加节点值；当 leftToRight 为 false 时，我们使用 add(0, currentNode.val) 来从右到左添加节点值，从而实现锯齿遍历的效果。

51.字节三面

1. 问题：为什么要进入MQ这个组件？当时是如何选型的？为什么不考虑别的MQ？RabbitMQ这么快，你了解他的底层实现原理吗？

答案：

• 为什么要使用MQ：消息队列（MQ）用于解耦系统组件，提高系统的异步通信能力，增强系统的可伸缩性和可靠性。

• 选型过程：选型通常会考虑以下因素：社区活跃度、稳定性、性能、特性支持、易用性、文档齐全程度等。通过对比不同MQ产品的优缺点，选择最适合项目需求的产品。

• 为什么选择RabbitMQ：RabbitMQ 具有良好的文档支持，社区活跃，支持多种消息协议，且易于部署和使用。

• RabbitMQ的底层实现原理：RabbitMQ基于Erlang语言开发，利用Erlang的并发优势，实现了高效的消息路由和处理。它使用AMQP协议进行通信，内部采用交换机（Exchange）、队列（Queue）和绑定（Binding）的概念来实现消息的路由和分发。

1. 问题：你聊一聊arrayList，扩容机制是怎么样子的？（不触发扩容的时候也会进行拷贝吗？）

答案：

• ArrayList的扩容机制：ArrayList在添加元素时，如果当前数组容量不足以容纳更多元素，会进行扩容。扩容通常是创建一个新的数组，其容量是原数组容量的1.5倍，然后将原数组中的元素复制到新数组中。

• 不触发扩容时的拷贝：如果不触发扩容（即数组容量足够），则不会进行数组的整体拷贝，只会直接在原数组中添加新元素。

1. 问题：谈谈你理解的堆内存和栈内存，说说他们之间的区别；

答案：

• 堆内存（Heap Memory）：是Java虚拟机（JVM）管理的内存区域，用于存储对象实例和数组。堆内存是线程共享的，其生命周期不受线程影响，需要垃圾回收器来管理。

• 栈内存（Stack Memory）：每个线程运行时都有一个栈，用于存储局部变量、方法调用的参数、返回值以及控制方法调用和返回的信息。栈内存是线程私有的，生命周期和线程相同，不需要垃圾回收。

• 区别：栈内存的分配和回收速度通常比堆内存快，栈内存的大小有限，而堆内存的大小可以动态调整。

1. 问题：栈溢出你如何通过写代码去得知，当前发生占内存溢出的这个阈值，需要获得具体的数值；

答案：

• 要通过代码检测栈溢出，可以编写一个递归方法，不断增加栈的深度，直到发生StackOverflowError。通过捕获这个异常，可以得知栈溢出的阈值。以下是一个简单的示例代码：

public class StackOverflowTest { private static int depth = 0; public static void main(String[] args) { try { recursiveMethod(); } catch (StackOverflowError e) { System.out.println("Stack overflow at depth: " + depth); } } private static void recursiveMethod() { depth++; recursiveMethod(); } }

在这个例子中，depth 变量用来记录递归调用的深度，当发生栈溢出时，会打印出当前的深度值。

1. 问题：聊一聊四次挥手的过程；是否可以变为三次？close_wait具体在那个阶段（回答错了，脑子抽了，听错了）？ 答案：

   1. 四次挥手过程：

      • 第一次挥手：客户端发送一个FIN报文，用来关闭客户端到服务器的数据传送，然后客户端进入FIN_WAIT_1状态。

      • 第二次挥手：服务器收到这个FIN报文，发回一个ACK报文，然后服务器进入CLOSE_WAIT状态，客户端收到这个确认后进入FIN_WAIT_2状态。

      • 第三次挥手：服务器发送一个FIN报文，用来关闭服务器到客户端的数据传送，然后服务器进入LAST_ACK状态。

      • 第四次挥手：客户端收到这个FIN报文，发回一个ACK报文，然后客户端进入TIME_WAIT状态，服务器收到这个确认后进入CLOSED状态，客户端在经过2MSL（最大报文生存时间）后也进入CLOSED状态。

   2. 是否可以变为三次：理论上，四次挥手不能简化为三次，因为每个方向的连接都需要单独进行关闭。如果一方发送了FIN，它就不能再发送数据，但仍然可以接收数据，因此需要两次FIN和两次ACK来确保双方的数据都能被完整地发送和接收。

   3. CLOSE_WAIT阶段：CLOSE_WAIT是在服务器收到客户端的FIN报文后，发送了ACK报文，但还没有发送自己的FIN报文时所处的状态。

2. 问题：redis的持久化机制，aof如何进行优化？ 答案：

   1. Redis的持久化机制：Redis提供了两种持久化机制，RDB（快照）和AOF（追加文件）。

   2. AOF优化：

      • 写入频率调整：通过配置appendfsync参数，可以控制AOF日志同步到磁盘的频率，例如设置为everysec可以每秒同步一次，减少磁盘I/O压力。

      • AOF重写：定期执行AOF重写，可以减少AOF文件的大小，去除无效命令，合并多条命令。

      • 使用更快的磁盘：将AOF文件存储在更快的磁盘上，比如SSD，可以提高写入性能。

      • 限制AOF文件大小：通过配置auto-aof-rewrite-min-size和auto-aof-rewrite-percentage参数，可以控制AOF文件重写的触发条件。

3. 问题：使用redis会遇到一些热点Key的问题，如何进行解决？ 答案：

   1. 热点Key问题解决方法：

      • 分散热点：使用哈希标签将热点Key分散到不同的分片中。

      • 增加副本：为热点Key设置多个副本，分散读请求。

      • 使用缓存：在应用层使用本地缓存或者分布式缓存，减少对Redis的直接访问。

      • 限流：对热点Key的访问进行限流，防止过高的访问量打垮Redis。

4. 问题：如果redis的这个key没有过期，但是并不能抗住当前的并发量，你如何去做? 答案：

• 应对高并发Key：

  • 增加资源：升级Redis服务器的硬件资源，如CPU、内存和带宽。

  • 读写分离：实现Redis的读写分离，将读请求分散到多个从节点。

  • 使用分布式Redis：通过Redis Cluster或者其他分布式Redis解决方案，将数据分散到多个节点。

  • 优化命令：分析并优化访问热点Key的命令，减少不必要的操作。

1. 问题：Linux找一个现成的PID如何找？在linux里面有两个进程，一个进行在修改这个文件，另外一个去删除这个文件，会发生什么？ 答案：

• 查找PID：可以使用ps、pgrep、pidof等命令来查找正在运行的进程的PID。

• 文件修改和删除：

  • 如果一个进程正在修改文件，而另一个进程尝试删除该文件，通常会发生以下情况：

    • 删除失败：如果文件被另一个进程占用，删除操作可能会失败，并返回错误。

    • 原子操作：Linux的文件系统通常会保证删除操作是原子性的，这意味着即使文件正在被修改，删除操作也会成功，但可能会导致数据丢失或者文件系统的不一致性。

    • 文件系统状态：在极端情况下，这可能导致文件系统处于不一致的状态，可能需要fsck（文件系统检查）来修复。

1. 问题：Linux里面的PID是什么？

答案：

• PID（Process ID）：在Linux系统中，PID是进程的唯一标识符，每个运行中的进程都有一个唯一的PID。PID由系统分配，并且一旦进程被创建，PID就不会改变。

• PID的作用：PID用于进程管理，包括启动、停止、监控和资源分配。通过PID，操作系统可以跟踪进程的状态，确保每个进程都能得到适当的资源，并能够与其他进程协调工作。

1. 问题：在Linux里面有两个进程，一个进行在修改这个文件，另外一个去删除这个文件，会发生什么？

答案：

• 修改和删除操作：在Linux中，当两个进程同时尝试修改和删除同一文件时，会发生以下情况：

  • 原子性操作：文件系统的删除操作通常是原子性的，这意味着一旦删除操作开始，它就会一直执行直到完成。

  • 修改冲突：如果一个进程正在修改文件，而另一个进程尝试删除文件，删除操作将成功，但修改操作可能会失败，导致数据丢失。

  • 文件系统一致性：文件系统的元数据（如inode）会更新以反映文件已被删除，但文件内容可能不会立即被删除，这取决于文件系统的实现和配置。

  • 安全问题：在某些情况下，如果一个进程正在修改文件，另一个进程可能无法访问该文件，这可能会导致应用程序的逻辑错误。

  • 资源竞争：在多进程环境中，多个进程竞争对文件的访问权，可能导致性能问题或死锁。

1. 问题：Linux下如何查看进程的PID？

答案：

• 查看进程PID：在Linux中，可以使用多种方法来查看进程的PID：

  • ps命令：使用ps aux或ps -ef命令可以列出所有进程的PID。

  • pgrep命令：通过pgrep命令可以基于进程名称或进程ID查找PID。

  • pidof命令：使用pidof命令可以基于进程名称查找PID。

  • top命令：使用top命令可以实时查看系统进程，包括PID。

  • jobs命令：在多任务环境中，可以使用jobs命令来查看当前进程的PID。

1. 问题：Linux下如何结束进程？

答案：

• 结束进程：在Linux中，可以使用kill命令来结束进程。例如，要结束PID为1234的进程，可以使用以下命令：

  kill 1234

• 信号发送：kill命令默认发送SIGTERM信号，这是一个优雅的退出信号。如果需要强制结束进程，可以使用SIGKILL信号，例如：

  kill -9 1234

• 注意事项：结束进程时应谨慎，因为强制结束进程可能会导致数据丢失或系统不稳定。最好先尝试发送SIGTERM信号，如果进程没有响应，再考虑使用SIGKILL。

52.游族网络暑期实习一面

1. 问题：JVM线上调优，就比如如果gc后，内存还是有很多对象怎么解决？

答案：

• 检查内存分配：使用JVM工具如VisualVM、JConsole或MAT（Memory Analyzer Tool）来分析内存分配情况，找出占用内存的对象。

• 优化代码：检查是否有大量不必要的对象创建和持有，比如循环中创建的临时对象、长时间存在的对象等。

• 使用更合适的GC算法：根据应用的特点选择合适的GC算法，例如CMS（Concurrent Mark Sweep）适合多核CPU和低延迟需求，G1（Garbage-First）适合大堆内存和长暂停时间。

• 调整堆大小：根据应用的内存需求和硬件资源调整年轻代和老年代的大小，避免频繁GC。

• 启用内存压缩：如果使用的是CMS GC，可以考虑启用内存压缩以减少内存碎片。

1. 问题：垃圾收集算法？

答案：

• 标记-清除（Mark-Sweep）：标记所有存活的对象，然后清除未被标记的对象。

• 标记-整理（Mark-Compact）：标记所有存活的对象，然后将存活的对象压缩到内存的一端，然后清理未使用的内存。

• 分代收集（Generational Collection）：将内存分为新生代和老年代，新生代使用标记-清除或标记-整理，老年代使用标记-清除。

• 复制（Copying）：将内存分为两块，每次只使用其中一块，当这一块内存用完时，将存活的对象复制到另一块内存上，然后清理用完的内存。

• Garbage-First（G1）：将内存分为多个区域，优先回收老年代中垃圾最多的区域。

1. 问题：Java内存区域分布情况？

答案：

• 新生代（Young Generation）：包括Eden区、Survivor0（From）和Survivor1（To）区，用于存储新生对象。

• 老年代（Old Generation）：用于存储长时间存活的对象。

• 持久代（PermGen，在JDK 8之前）/元空间（Metaspace，在JDK 8及以后）：用于存储类信息、常量、静态变量等。

1. 问题：有几种类加载器？

答案：

• 类加载器：在Java中，类加载器负责将类文件加载到JVM中。主要有一下几种类加载器：

  • 启动类加载器（Bootstrap ClassLoader）：负责加载JDK核心类库。

  • 扩展类加载器（Extension ClassLoader）：负责加载JDK扩展目录中的jar包。

  • 应用程序类加载器（Application ClassLoader）：负责加载用户类路径（CLASSPATH）上的类。

  • 自定义类加载器：根据需要创建的自定义类加载器。

1. 问题：双亲委派？

答案：

• 双亲委派模型：在Java类加载器中，当应用程序类加载器遇到一个类时，会先将其委派给父类加载器（扩展类加载器或启动类加载器）来加载，如果父类加载器无法加载，才由自己加载。这样可以确保类加载的安全性，防止类的重复加载。

1. 问题：为什么要这样弄几层类加载器：树、基类？

答案：

• 层次结构：通过建立层次化的类加载器体系，可以确保类加载的安全性和可控性。

• 避免重复加载：双亲委派模型可以避免不同类加载器加载相同的类，从而防止类的重复加载。

• 隔离不同类路径：层次化的类加载器可以隔离不同类路径上的类，防止类冲突。

1. 问题：在自定义的包下弄String类，可以使用吗？

答案：

• 不可以使用：Java中的String类是Java语言规范中定义的一个类，由启动类加载器加载。在自定义包下创建的String类是不同的类，无法被Java语言规范所识别。

1. 问题：ScheduledExecutorService通过这个去问线程池的七个参数？

答案：

• ScheduledExecutorService：这是一个执行周期性或定时任务的线程池。

• 线程池的七个参数：

  • corepoolsize：线程池的核心线程数，即始终在线的线程数。

  • maximum pool size：线程池的最大线程数，当任务过多时，可以创建超过核心线程数的线程。

  • keep-alive time：当线程数超过核心线程数时，多余的线程将在空闲一定时间后被销毁。

  • unit：keep-alive time的时间单位。

  • work queue：任务队列，用于存放待执行的任务。

  • thread factory：线程工厂，用于创建线程。

  • handler：拒绝策略，当任务队列满且线程数达到最大时，如何处理新任务。

  • 问题：synchronized 底层原理？ 答案：

    1. 底层原理：synchronized 是 Java 中的一个关键字，用于实现同步锁。在 Java 虚拟机（JVM）层面，synchronized 采用 monitor（监视器）来实现，每个对象或 Class 都关联一个 monitor。

    2. 使用方式：

       • 修饰实例方法：作用于当前对象实例，锁是当前对象实例。

       • 修饰静态方法：作用于当前类的 Class 对象，锁是当前类的 Class 对象。

       • 修饰代码块：可以指定一个对象实例作为锁，锁是该对象实例。

  • 问题：mysql的锁可以分为哪几种？ 答案：

  • 行锁：对单行数据进行锁定，适用于读写操作。

  • 表锁：对整个表进行锁定，适用于读写操作。

  • 乐观锁：在更新数据时，先读取数据，再更新数据，最后提交。如果提交时发现数据已经被其他事务修改，则更新失败。

  • 悲观锁：在执行更新操作时，先获取锁，再执行更新。

  • 读写锁：分为读锁和写锁，适用于读多写少的场景。

  • 问题：聚簇索引和非聚簇索引？ 答案：

  • 聚簇索引：数据记录按照索引键的顺序存储在磁盘上，读取数据时可以直接定位到数据。

  • 非聚簇索引：数据记录存储在磁盘上，索引项只是数据记录的引用，读取数据时需要先找到索引项，再根据索引项找到数据记录。

  • 问题：Integer缓存问题？ 答案：

  • Integer缓存：Java 的 Integer 类中有一个缓存，用于存储 -128 到 127 的整数，当需要创建这个范围内的整数时，会直接从缓存中获取，而不是创建新的对象。

  • 缓存范围：当使用 new Integer(1) 时，会创建一个新的对象，因为 1 超出了缓存范围。

  • 缓存范围外的对象：当使用 new Integer(129) 时，会创建一个新的对象，因为 129 超出了缓存范围。

  • 缓存范围内的对象：当使用 Integer.valueOf(1) 时，会从缓存中获取对象，因为 1 在缓存范围内。

  • 问题：针对 new Integer(1) == (new Integer(1))，源码没有做特殊处理，就是 new 了两个不同的对象，他们当然是不相等的，返回 false； 答案：

  • 比较原理：在 Java 中，两个对象通过 == 比较时，比较的是对象的引用是否相同，而不是对象的内容是否相同。

  • Integer 对象：由于 new Integer(1) 和 new Integer(1) 创建了两个不同的对象，它们的引用是不同的，所以通过 == 比较时返回 false。

  • 问题：针对 new Integer(1).equals(new Integer(1))，可以看一下 Integer.equals() 函数的实现，函数内部是直接比较两个对象的 value 是否相等，他们的 value 都是 1，所以返回 true； 答案：

  • equals 方法：在 Java 中，equals 方法用于比较两个对象的内容是否相同，而不是引用是否相同。

  • Integer.equals() 实现：当调用 Integer.equals(1, 1) 时，实际上比较的是两个对象的 value 是否相等，因为 value 都是 1，所以返回 true。

1. metaspace包含哪些信息

MetaSpace是Java虚拟机（JVM）中用来存放类元数据的空间，它是JVM规范中方法区（Method Area）的一种实现方式。在Java 8及之后的版本中，PermGen（永久代）被MetaSpace取代。MetaSpace主要存放以下内容：

1. 类的相关信息：包括类的名称、访问修饰符、直接父类名称、接口名称、字段信息、方法信息等。

2. 常量池：每个类都包含一个常量池，用于存储编译器生成的字面量和符号引用。

3. 字段数据：包括字段名称、类型、修饰符等。

4. 方法数据：包括方法名称、返回类型、参数类型、修饰符、方法字节码、操作数栈大小、局部变量表大小等。

5. 方法表：用于实现多态，记录了指向父类方法表和实现接口方法表的指针。

6. 构造函数信息。

MetaSpace的特点是它位于本地内存（Native Memory），不再局限于JVM的堆内存中，因此它的最大可使用空间只受系统内存的限制，而不再有固定的最大值限制（PermGen有固定大小限制，容易发生内存溢出错误）。这使得MetaSpace可以根据需求动态扩展和收缩，提高了JVM管理的灵活性。

由于MetaSpace使用的是本地内存，所以也需要合理配置，以避免出现内存泄漏或者内存占用过大的问题。可以通过JVM启动参数来调整MetaSpace的大小，例如使用-XX:MaxMetaspaceSize参数来设置MetaSpace的最大容量。

1. 介绍一下栈帧中的元素以及作用

在Java虚拟机（JVM）中，每当一个方法被调用时，JVM就会在当前线程的栈（Java方法栈）中为该方法创建一个新的栈帧（Stack Frame）。栈帧是用于存储方法调用过程中的局部变量、操作数栈、动态链接、方法出口等信息的数据结构。以下是栈帧中的主要元素及其作用：

1. 局部变量表（Local Variables Table）：

   1. 作用：用于存储方法执行过程中的局部变量（包括方法参数和局部变量）。

   2. 元素：局部变量表中的变量可以是基本数据类型、对象引用（指向对象实例的指针）或返回地址。

   3. 特点：局部变量表的大小在编译期就已经确定，并随栈帧的创建而分配空间。

2. 操作数栈（Operand Stack）：

   1. 作用：用于存储计算过程中的中间结果，也作为计算过程中变量临时的存储空间。

   2. 元素：操作数栈中的元素可以是任意的Java虚拟机类型，包括基本数据类型、对象引用等。

   3. 特点：操作数栈的大小在编译期就已经确定，其最大深度由方法的code属性中的max_stack指定。

3. 动态链接（Dynamic Linking）：

   1. 作用：每个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用，用于支持方法调用过程中的动态链接。

   2. 元素：主要包括指向常量池中方法的符号引用、实际方法的直接引用等。

   3. 特点：动态链接使得方法调用更加灵活，可以在运行期解析确定要调用的方法。

4. 返回地址（Return Address）：

   1. 作用：当方法执行完成后，需要返回到方法被调用的位置继续执行，返回地址就是记录这个位置的指针。

   2. 元素：返回地址通常存储在调用者的操作数栈中，或者特定于虚拟机的寄存器中。

   3. 特点：只有当前方法不是native方法，并且不是通过invokespecial指令调用的实例初始化方法、私有方法和父类方法时，才会设置返回地址。

5. 附加信息：

   1. 作用：虚拟机可能会在栈帧中添加一些额外的信息，以支持特定的虚拟机操作。

   2. 元素：这些信息可能包括与调试相关的信息、与垃圾回收相关的信息等。

栈帧的创建和销毁伴随着方法的调用和返回。当方法调用结束时，当前栈帧会从Java方法栈中弹出，并且其占用的内存空间可以被回收。栈帧的结构和操作是JVM实现细节的一部分，但它们对理解Java程序运行时的内存模型非常重要。

动态链接是Java虚拟机（JVM）栈帧中的一个重要概念，它涉及到Java程序运行时的方法调用机制。下面详细分析动态链接的组成部分和作用：

动态链接的组成部分

1. 符号引用（Symbolic Reference）：

   1. 符号引用是编译器在编译Java类文件时生成的一种引用，它包含了被调用方法的名称、参数描述符、返回值类型等信息。

   2. 符号引用存储在类的常量池中，它并不直接指向方法的实际内存地址。

2. 实际方法引用（Actual Method Reference）：

   1. 实际方法引用是在程序运行期间，符号引用被解析后得到的直接内存地址或指针。

   2. 解析过程通常发生在类加载的解析阶段，或者在第一次调用方法时进行。

动态链接的作用

1. 延迟解析：

   1. 动态链接允许方法调用不立即解析，而是延迟到实际运行时。

   2. 这种延迟解析可以减少类加载时的开销，因为不需要一开始就解析所有的符号引用。

2. 支持多态：

   1. 动态链接使得方法调用可以根据对象的实际类型来确定调用哪个方法，这是Java多态性的基础。

   2. 当子类重写了父类的方法时，通过动态链接可以确保调用的是子类中的方法。

3. 类加载器的灵活性：

   1. 动态链接使得不同的类加载器可以在运行时解析符号引用，从而可以加载不同的类版本。

   2. 这为Java提供了极高的灵活性，比如热部署、模块化等。

动态链接的实现机制

1. 解析过程：

   1. 当JVM执行到一个方法调用指令时，它会检查当前栈帧中的动态链接信息。

   2. 如果符号引用还没有被解析，JVM会查找符号引用所指向的方法的实际内存地址，并将其存储在栈帧中，供后续调用使用。

2. 方法表：

   1. 对于每个类，JVM都会为其生成一个方法表（Method Table），其中包含了该类及其父类中所有方法的实际引用。

   2. 当需要调用一个方法时，JVM会根据对象的实际类型查询方法表，以确定应该调用哪个方法。

3. 虚拟机指令：

   1. JVM指令集中包含了用于处理方法调用的指令，如invokevirtual、invokespecial、invokestatic、invokeinterface等。

   2. 这些指令在执行时会使用动态链接来确定方法调用的目标。

动态链接的优势

• 减少内存使用：由于符号引用不直接指向内存地址，因此可以减少内存占用。

• 提高性能：延迟解析可以减少类加载时间，提高程序的启动速度。

• 增加灵活性：动态链接使得Java程序更加灵活，可以动态地替换方法实现，支持动态绑定。

总之，动态链接是Java运行时环境的一个关键特性，它确保了Java程序可以在运行时高效、灵活地调用方法，同时支持Java的核心特性——多态。

当然，以下是一个关于符号引用和实际引用的例子，我们将通过一个简单的Java类和方法调用来说明这一概念。

Java 类定义

假设我们有以下简单的Java类：

public class Animal { public void makeSound() { System.out.println("Some generic sound"); } } public class Dog extends Animal { @Override public void makeSound() { System.out.println("Woof!"); } }

符号引用

在编译上述类时，编译器会在Dog类的常量池中为makeSound方法创建一个符号引用。这个符号引用可能看起来像这样（这里用伪代码表示）：

#12 = Methodref #13.#15 // Animal.makeSound:()V #13 = Class #16 // Animal #16 = Utf8 Animal #15 = NameAndType #17:#18 // makeSound:()V #17 = Utf8 makeSound #18 = Utf8 ()V

这里的#12是一个指向Animal类的makeSound方法的符号引用。它包含了类的名称（Animal）和方法的名称及描述符（makeSound:()V，其中V代表void返回类型）。

实际引用

当Dog类的实例在运行时调用makeSound方法时，JVM将执行以下步骤：

1. JVM查找Dog类的方法表，以确定makeSound方法的具体实现。

2. 由于Dog类重写了Animal类的makeSound方法，方法表中makeSound的实际引用将指向Dog类中makeSound方法的内存地址。

3. 当Dog类的实例调用makeSound方法时，JVM将使用这个实际引用来调用Dog类中定义的makeSound方法。

以下是实际引用的伪代码表示：

0x00000012: Method Address of Dog.makeSound:()V

这里的0x00000012是假设的内存地址，代表了Dog类中makeSound方法的实际内存位置。

代码示例

以下是如何在Java代码中使用这些引用的例子：

public class Main { public static void main(String[] args) { Animal myDog = new Dog(); // 创建Dog实例，但以Animal类型引用 myDog.makeSound(); // 调用makeSound方法 } }

在这个例子中，当我们调用myDog.makeSound()时，JVM将执行以下操作：

1. 查看符号引用#12，确定要调用的方法是Animal类的makeSound。

2. 由于myDog实际引用的是一个Dog对象，JVM会查找Dog类的方法表。

3. JVM在方法表中找到makeSound的实际引用，并调用它，输出“Woof!”。

这个例子展示了符号引用在编译时用于引用方法，而实际引用在运行时用于执行方法调用。

1. 虚方法与非虚方法

动态链接

• 动态链接主要就是指向运行时常量池的方法引用

• 每一个栈帧内存都包含一个指向运行时常量池中该栈帧所属方法的引用，包含这个引用的目的就是为了支持当前方法的代码能够实现动态链接(Dynamic Linking)。比如invokedynamic 指令

• 在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用(Symbolic Reference )保存在class文件的常量池里。比如，描述一个方法调用其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用

1、方法的调用

在JVM中，将符号引用转换为调用方法的直接引用与方法的绑定机制有关

方法的静态链接与动态链接

• 静态链接：当一个字节码文件被装在进JVM内存时，如果被调用的目标方法在编译期可知，且运行期保持不变时，这种情况下将调用方法的符号引用转换为直接而引用的过程称之为静态链接。 例如，super()方法

• 动态链接：如果被调用的方法无法在编译期确定下来，也就是说，只能够在程序运行期将调用方法的符号引用转换为直接引用，由于这种引用转换过程中具备动态性，因此也被称之为动态链接。对应着接口回调，多态动态绑定等

与之对应的则是方法的绑定机制。早期绑定(Early Binding)和晚期绑定(late Binding)。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，这里仅仅发生一次。

• 早期绑定：早期绑定就是被调用的目标函数如果在编译期可知，且运行期间保持不变，即可将这个方法与所属的类型进行绑定。

• 晚期绑定：如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型确定相关的方法，被称之为晚期绑定。其实也就是动态绑定

2、虚方法与非虚方法

• 对应着进行早期绑定和静态链接的定义，即在编译期就确定了具体的调用版本，在运行时不可变，称之为非虚方法

• 静态方法、私有方法、final方法、实例构造器、父类方法都是非虚方法

• 其他方法称之为虚方法

• 子类对象的多态性使用的前提为：类的继承关系，方法的重写

• 可以简单的理解为自己写的方法就是虚方法。

  • 在面向对象的编程中，会很频繁的使用到动态分派，如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话可能影响到执行效率，因此，为了提高性能，JVM采用在类的方法区建立一个虚方法表(virtual method table)(非虚方法不会出现在表中)来实现，使用索引表来替代查找

  • 每个类中都有一个虚方法表，表中存放着各个方法的实际入口

  • 虚方法表会在类加载的链接阶段被创建并开始初始化，类的变量初始值准备完成以后，JVM会把该类的方法表也初始化完毕

3、方法的调用指令

• 普通调用指令

  • invokestatic：调用静态方法，解析阶段确定唯一方法版本

  • invokesopecial：调用<init>方法、私有即父类犯法，解析阶段确定唯一方法版本

  • invokevirtual：调用所有虚方法

  • invokeinterface：调用接口方法

• 动态调用指令:

  • invokedynamic：动态解析出所有需要的方法，然后执行，(lamble表达式)，和python一样，变量不需要自己执行，运行时才知道

4、方法重写的本质

• 找到操作数栈顶的第一个元素所执行的对象的实际类型，记作C

• 如果在类型C中找到与常量中的描述符合简单名称都相符的方法，则进行访问权限校验，如果通过则放回这个方法的直接引用，查找过程结束；如果不通过，则返回java.lang.illegalAccessError异常

• 否则，按照继承关系从上往下依次对C的各个父类进行第2步的搜索和验证过程

• 如果始终没有找到合适的方法，则抛出java.lang.AbstactMethodError异常