每日大厂面试题大汇总 —— 今日的是“美团-后端开发-一面”

欢迎来到dream_ready的博客，相信您也对这篇博客也感兴趣o (ˉ▽ˉ；)

祝诸君前程似锦，归来仍初心不忘！

每日大厂面试题大汇总 —— 今日的是“京东-后端开发-一面”

 美团面试题如下：

1. 哈希表是什么结构，发生了哈希冲突有什么解决的方法
2. hashMap 里面每一个节点存了什么东西，hashMap是线程安全的吗，如果出现线程并发问题时，会出现哪些异常？
3. 二叉树遍历有几种遍历方式，讲一讲层序遍历
4. B与B+的区别
5. mysql里面的联合索引构建索引的过程是怎么样的。b+树的高度要怎么预估
6. 死锁相关
7. 数据库三范式
8. 数据库的4个特性。 多个日志如何保证ACID
9. 事务隔离级别。脏读和幻读的区别
10. 覆盖索引
11. 建立索引需要评估索引是否有必要去建立，我们怎么来评估。
12. java里面判断对象相等怎么做
13. java里面多态绑定是什么，只有在运行时才知道某个具体的实例，底层是怎么做的（JVM）。类加载机制说一下
14. 线程池的几种拒绝策略。
15. CAS的相关问题
16. 设计模式的三种分类
17. spring源码有了解吗？spring的事务传播机制，底层是怎么实现的。比如A调用B,B是怎么知道A的事务的。
18. rpc通信中序列化和反序列化有哪些工具等
19. 有重复数字的全排序 

---

1、哈希表是什么结构，发生了哈希冲突有什么解决的方法

哈希表（Hash Table）是一种常用的数据结构，用于实现键值对的映射。它基于哈希函数将键映射到存储数据的数组中。哈希表具有以下关键特点：

1. 快速查找：哈希表具有平均O(1)的查找时间复杂度，因为它通过哈希函数可以快速定位到存储位置。

2. 键值对存储：每个元素都是一个键值对，其中键是通过哈希函数计算得到的数组索引，值是存储在该索引处的数据。

3. 动态大小：哈希表通常具有可动态调整大小的能力，以适应不同数量的键值对。

4. 哈希冲突：哈希冲突是指多个键被映射到同一数组索引的情况。哈希表需要一种方法来处理这种冲突，以确保数据的准确存储和检索。

解决哈希冲突的常见方法包括：

1. 链地址法（Chaining）：在这种方法中，每个哈希表的槽（或桶）都包含一个链表，每当发生冲突时，新的键值对被添加到链表中。这样，具有相同哈希值的键值对都存储在同一个槽中的链表中。

2. 开放寻址法（Open Addressing）：在这种方法中，当发生哈希冲突时，新的键值对被插入到数组中的下一个可用槽位，而不是链表中。这可以通过线性探查、二次探查或双重哈希等技术来实现。

3. 再哈希（Rehashing）：当哈希表达到一定负载因子（已存储键值对数量与数组大小的比例）时，可以执行再哈希操作，将数组大小增加一倍，并重新分配所有键值对，以减少冲突的可能性。

4. 完美哈希函数：一些应用中使用完美哈希函数，这些函数几乎不会导致冲突。它们通常是特定于应用的，并需要仔细的设计和计算。

不同的哈希表实现和应用可能会选择不同的冲突解决方法，取决于性能需求和设计考虑。解决哈希冲突是哈希表设计中重要的一部分，它确保了数据的可靠性和高效的操作。

---

2、hashMap 里面每一个节点存了什么东西，hashMap是线程安全的吗，如果出现线程并发问题时，会出现哪些异常？

在Java中，HashMap 是一种散列表（Hash Table）实现，用于存储键值对。每个 HashMap 节点存储两个主要信息：

1. 键（Key）：用于唯一标识值的对象。
2. 值（Value）：与键相关联的数据对象。

HashMap 以键的哈希值作为索引，将键值对存储在数组中。当你想要查找一个键对应的值时，HashMap 首先计算键的哈希值，然后使用哈希值查找对应的数组索引，最终返回与该键相关联的值。

至于线程安全性，标准的 HashMap 是非线程安全的。如果多个线程同时对一个 HashMap 进行读写操作，可能会导致数据不一致、丢失或其他异常情况。为了在多线程环境中安全使用 HashMap，可以采用以下方式之一：

1、使用同步机制：你可以使用 Collections.synchronizedMap 方法将 HashMap 包装成一个同步的 Map，从而确保多线程访问时的线程安全。例如：

Map synchronizedMap = Collections.synchronizedMap(new HashMap());

  然后，多个线程可以安全地对 synchronizedMap 进行读写操作。

2、使用并发集合：Java提供了线程安全的替代品，如 ConcurrentHashMap，它是一种高性能的并发哈希表实现。它采用粒度更细的锁机制，以支持并发读取和写入操作。

如果在多线程环境中使用非线程安全的 HashMap，可能会出现以下异常或问题：

• ConcurrentModificationException：当一个线程在迭代 HashMap 的同时，另一个线程修改了 HashMap 的结构（添加、删除元素）时，会抛出此异常。

• 数据不一致性：并发读写操作可能导致数据不一致，即多个线程同时访问和修改 HashMap 可能会导致意外结果。

• 丢失数据：并发写操作可能导致数据丢失，即一个线程的写入可能覆盖另一个线程的写入，导致数据丢失。

为了避免这些问题，建议在多线程环境中使用线程安全的 HashMap 替代品，或者使用同步机制来保护非线程安全的 HashMap。

---

3、二叉树遍历有几种遍历方式，讲一讲层序遍历

在二叉树中，常见的遍历方式包括三种深度优先遍历（Depth-First Traversal）和一种广度优先遍历（Breadth-First Traversal），它们分别是：

1. 前序遍历（Preorder Traversal）：从根节点开始，先访问根节点，然后依次遍历左子树和右子树。通常用递归方式实现。

2. 中序遍历（Inorder Traversal）：从根节点开始，先遍历左子树，然后访问根节点，最后遍历右子树。通常用递归方式实现。在二叉搜索树中，中序遍历可以按照升序访问节点。

3. 后序遍历（Postorder Traversal）：从根节点开始，先遍历左子树，然后遍历右子树，最后访问根节点。通常用递归方式实现。

4. 层序遍历（Level-Order Traversal）：从根节点开始，逐层遍历二叉树，从左到右访问每一层的节点。这是一种广度优先遍历方式，通常使用队列来实现。

下面让我们详细介绍一下层序遍历：

层序遍历是一种广度优先遍历，通过逐层遍历二叉树，可以按照从上到下、从左到右的顺序访问每个节点。层序遍历通常使用队列来实现，它的基本思想如下：

1. 首先，将根节点放入队列中。

2. 然后，从队列中取出节点，并访问该节点。

3. 接下来，将该节点的左子节点和右子节点（如果存在）依次放入队列中。

4. 重复步骤2和3，直到队列为空。

这样，通过层序遍历，你可以按照层级顺序逐个访问树的节点。层序遍历在二叉树中的许多应用中非常有用，例如查找二叉树的最小深度、最大深度，或在图像处理中处理图像中的像素等。这种遍历方式确保了你能够逐层遍历树的节点，而不会跳跃地访问它们。

---

4、B与B+的区别

B树（B-Tree）和B+树（B+ Tree）是两种常见的自平衡树数据结构，通常用于数据库系统中来组织和维护索引。它们在结构和用途上有一些显著的区别：

B树（B-Tree）：

1. 平衡性： B树是一种平衡树，所有叶子节点到根节点的深度是相同的。这使得B树在读取时的性能相对均匀。

2. 节点结构： B树的每个节点可以存储多个键值对，包括子节点的引用。这意味着B树的节点比B+树更大，存储更多的数据。

3. 数据存储： B树的所有数据都存储在内部节点和叶子节点中。这使得B树适用于磁盘存储，因为它可以减少I/O访问。

4. 查找操作： 在B树中，键值对可以出现在内部节点或叶子节点。因此，在查找操作中，如果找到匹配的键，查找操作可以立即终止。

B+树（B+ Tree）：

1. 平衡性： B+树也是一种平衡树，但它具有更加严格的平衡性，所有叶子节点都在同一层级。这有助于提高范围查询性能。

2. 节点结构： B+树的内部节点只存储键，而数据仅存储在叶子节点中。这意味着B+树的内部节点相对较小，叶子节点相对较大。

3. 数据存储： B+树的数据只存储在叶子节点中，而内部节点仅用于导航。这使得B+树在内部和叶子节点之间减少了数据冗余，有助于节省内存。

4. 查找操作： 在B+树中，查找操作通常需要遍历到叶子节点。因此，如果需要执行范围查询，可以轻松地遍历叶子节点。

总的来说，B+树通常比B树更适用于数据库索引，特别是在范围查询方面。B+树的严格平衡性和数据存储方式使其在范围查询时性能更加稳定，而B树则更适用于通用的查找操作。选择B树还是B+树取决于具体应用场景和性能需求。

---

5、mysql里面的联合索引构建索引的过程是怎么样的。b+树的高度要怎么预估

MySQL中的联合索引是一种将多个列组合到一个索引中以加速查询的方式。构建联合索引的过程如下：

1. 选择列：首先，你需要选择要包含在联合索引中的列。这些列通常是你经常用于查询的列，以提高查询性能。

2. 创建索引：使用CREATE INDEX语句或在表的定义中使用INDEX关键字，你可以创建联合索引。例如：

   CREATE INDEX idx_name ON table_name (column1, column2, column3);

   这将在表 table_name 上创建一个名为 idx_name 的联合索引，包括列 column1、column2 和 column3。

3. 索引维护：一旦创建了联合索引，MySQL会自动维护索引，确保它与数据的变化保持同步。这包括在插入、更新和删除数据时更新索引。

关于B+树的高度估计，B+树是一种平衡树，通常情况下，其高度是相对较低的，这使得B+树能够在大型数据集上高效运行。B+树的高度与以下因素有关：

1. 节点容量：B+树的每个节点可以容纳多少键值对。节点容量越大，树的高度通常越低。

2. 数据量：树的高度还取决于数据集的大小。较大的数据集可能需要更深的树，但B+树的高度通常会相对较低。

3. 平衡性：B+树保持平衡，确保所有叶子节点在同一层级。这使得树的高度相对较低，不容易出现不平衡的情况。

通常情况下，可以使用以下公式估计B+树的高度（h）：

h ≈ log_base((n + 1) / 2)

其中，n 表示树中键值对的数量，base 是每个节点的容量。这个估计可以帮助你大致了解B+树的高度，以便更好地理解查询性能。要注意的是，根据具体的实现和数据分布，B+树的高度可能会有所不同，但通常情况下它是相对较低的。

---

6、死锁相关

死锁是多线程或多进程并发编程中常见的问题，它发生在多个线程或进程之间互相等待对方释放资源或锁，导致它们都无法继续执行的情况。死锁是一种严重的并发问题，需要仔细的处理和预防。以下是关于死锁的一些重要信息：

死锁的条件：

死锁通常涉及四个必要条件，这些条件必须同时满足才能引发死锁：

1. 互斥条件：至少有一个资源必须处于互斥状态，即一次只能由一个线程或进程访问。

2. 请求与保持条件：一个线程或进程可以在保持自己已经分配的资源的同时请求其他资源。

3. 不可抢占条件：资源不能被强制从一个线程或进程中抢占，只能由持有它的线程或进程主动释放。

4. 循环等待条件：多个线程或进程之间形成一个循环等待，每个线程或进程等待下一个线程或进程所持有的资源。

避免和解决死锁：

避免死锁是首选方法，但不总是可能的。以下是一些处理死锁的方法：

1. 避免：通过仔细规划资源分配，确保不会发生死锁。这需要了解和分析应用程序的资源需求。

2. 检测和恢复：使用死锁检测算法，周期性地检查是否存在死锁，然后采取适当的措施，如终止某些线程或进程，以解除死锁。

3. 超时和重试：为资源请求设置超时时间，如果超时就放弃或重试。这可以避免无限等待。

4. 资源分级：分配资源时，确保它们按照某种规则（如资源的优先级）获得，以避免循环等待。

5. 资源分配图：使用资源分配图来表示资源分配情况，通过分析图来检测死锁情况。

常见的死锁场景：

• 死锁可以发生在各种应用程序中，包括数据库管理系统、操作系统、网络通信等。数据库中的死锁通常涉及到表锁或行级锁，操作系统中的死锁可能发生在多个进程之间的资源竞争，网络通信中的死锁可能由于多个节点之间的消息传递问题。
• 要成功处理和预防死锁，需要深入了解应用程序和系统的资源需求和分配方式，以制定适当的策略来避免或解决死锁问题。 

---

7、数据库三范式

数据库三范式（Normalization）是关系数据库设计中的一组规范，用于优化数据的存储结构，减少冗余数据，提高数据的完整性和一致性。三范式包括以下三个范式：

1. 第一范式（1NF）：确保每个数据表中的列都是原子的，即每列中的数据都是不可再分的。这意味着每个表中的每个单元格都应该包含一个单一的值，而不是多个值或重复的数据。实现1NF通常需要将数据分解成多个相关的表。

2. 第二范式（2NF）：在满足第一范式的前提下，2NF要求表中的非主键列完全依赖于表的候选键（即主键）。这意味着表中的非主键列不应该部分依赖于候选键。如果存在部分依赖，需要将相关数据分离成新表，并通过外键关系连接。

3. 第三范式（3NF）：在满足第一范式和第二范式的前提下，3NF要求表中的非主键列不依赖于其他非主键列。这意味着表中的数据应该被彻底分解，以确保没有传递依赖关系。如果存在传递依赖，需要将相关数据分离成新表。

        三范式的目标是通过减少数据冗余，提高数据的完整性和一致性，减少数据更新异常，以改进数据库性能和可维护性。但值得注意的是，严格遵循三范式有时可能会导致查询性能下降，因为查询可能需要多次连接多个表。在实际数据库设计中，需要根据具体应用的需求和查询模式来权衡三范式和性能，有时可能会选择部分冗余数据以提高查询性能。这称为反规范化（Denormalization）。

---

8、数据库的4个特性。 多个日志如何保证ACID

数据库系统通常根据ACID特性来评估其事务处理的能力。ACID 是一种用于确保数据库事务的可靠性和一致性的特性集合，包括以下四个关键特性：

1. 原子性（Atomicity）：原子性确保事务是不可分割的操作单元，要么完全执行，要么完全不执行。如果事务中的任何操作失败，整个事务将被回滚，不会留下部分执行的结果。这确保了数据的一致性。

2. 一致性（Consistency）：一致性要求事务在执行前和执行后，数据库的状态必须满足一组完整性约束。如果事务执行成功，数据库状态应该从一个一致状态转移到另一个一致状态。如果事务执行失败，数据库应该回滚到事务前的状态。

3. 隔离性（Isolation）：隔离性确保并发执行的事务彼此不受影响。每个事务应该以一种看似单独执行的方式进行，而不会受到其他事务的干扰。数据库管理系统通常通过锁定和多版本并发控制（MVCC）等技术来实现隔离。

4. 持久性（Durability）：持久性确保一旦事务成功提交，其结果将永久保存在数据库中，即使系统故障也不会丢失。这通常涉及将事务日志写入持久存储介质，以便在系统故障后进行恢复。

关于多个日志如何保证ACID，这通常与数据库的事务日志（Transaction Log）和恢复机制有关。数据库系统通常会维护一个事务日志，记录事务的所有操作，包括开始、提交、回滚以及对数据的更改。事务日志的作用包括：

• 在故障恢复时，用于回滚未提交的事务和重放已提交的事务，以确保持久性。
• 在隔离性中，用于锁定管理和冲突解决。
• 用于记录事务的持久性，即将数据更改写入磁盘之前，首先写入日志，以便在故障发生时可以回滚或重放操作。

通过事务日志，数据库系统可以确保事务的原子性、一致性和持久性。在多个日志中，事务日志是最关键的，因为它包含了事务操作的详细信息，允许数据库系统在故障后对数据进行正确的恢复和维护ACID特性。

---

9、事务隔离级别。脏读和幻读的区别

数据库事务隔离级别定义了不同事务之间的可见性和相互影响的程度。常见的事务隔离级别包括：

1. 读未提交（Read Uncommitted）：允许一个事务读取另一个事务未提交的修改。这是最低的隔离级别，可能导致脏读、不可重复读和幻读问题。

2. 读提交（Read Committed）：一个事务只能读取已提交的其他事务所做的修改。这可以避免脏读，但仍可能导致不可重复读和幻读问题。

3. 可重复读（Repeatable Read）：一个事务在其生命周期内看到的数据保持一致，即使其他事务提交也不会改变。这可以避免脏读和不可重复读，但仍可能导致幻读问题。

4. 串行化（Serializable）：最高级别的隔离，确保事务之间没有交叉。这可以避免脏读、不可重复读和幻读问题，但可能导致性能下降，因为事务需要严格的串行执行。

脏读（Dirty Read）和幻读（Phantom Read）是两种不同的问题：

• 脏读：脏读发生在一个事务读取了另一个事务尚未提交的数据更改。在读未提交隔离级别下可能发生脏读，因为一个事务可以读取未提交的数据。脏读可能导致不准确的数据和不一致的结果。

• 幻读：幻读是指一个事务在两次查询之间，由于其他事务的插入或删除操作，看到了不一致的数据。在读提交隔离级别下，其他事务可以提交插入或删除操作，从而导致幻读。可重复读和串行化隔离级别通常可以解决幻读问题，因为它们保证了一个事务在其生命周期内看到的数据保持一致。

要解决脏读和幻读问题，通常需要选择合适的事务隔离级别，并确保数据访问和操作符合所选隔离级别的要求。不同的应用场景可能需要不同的隔离级别，以平衡数据的一致性和性能需求。

---

10、覆盖索引

覆盖索引（Covering Index）是一种用于优化数据库查询性能的索引策略。它的核心思想是将查询所需的数据列都包含在索引中，从而避免了在查询时需要访问实际数据行。这可以显著提高查询性能，特别是对于大型数据表和复杂查询。

覆盖索引的主要优势包括：

1. 减少 I/O 操作：由于覆盖索引包含了查询所需的数据列，数据库引擎无需访问实际数据行，从而减少了磁盘 I/O 操作，提高查询速度。

2. 减少 CPU 消耗：通过减少不必要的数据读取和处理，覆盖索引可以降低 CPU 消耗，使查询更高效。

3. 降低内存占用：覆盖索引通常需要的内存比完整数据行少，因此可以减少内存占用，有助于提高数据库的整体性能。

4. 支持更复杂的查询：通过覆盖索引，可以支持更多的查询操作，包括排序、分组和聚合，而无需访问实际数据。

要创建覆盖索引，你需要确保索引包含了查询语句中涉及的所有列。例如，如果你有一个包含 ID、Name 和 Age 列的数据表，并且你经常执行类似以下查询的操作：

SELECT Name FROM TableName WHERE Age > 30;

你可以创建一个覆盖索引，它包含 Age 列和 Name 列。这将允许数据库引擎仅通过索引来满足查询，而无需访问实际数据行。

请注意，覆盖索引并不是适用于所有情况的。它主要适用于频繁执行特定查询类型的情况，而且需要权衡索引的大小和维护成本。不必要地创建大量的覆盖索引可能会增加数据库维护负担。因此，在设计索引时，需要谨慎选择哪些列需要包含在索引中，以满足查询性能需求。

---

11、建立索引需要评估索引是否有必要去建立，我们怎么来评估。

建立索引是一项重要的数据库性能优化任务，但不应盲目地为每个列都创建索引，因为不正确或不必要的索引可能会增加数据库的维护开销并降低性能。以下是一些用于评估是否需要创建索引的考虑因素：

1. 查询频率：首先，考虑哪些列经常用于查询条件。如果某列在多数查询中都是筛选条件，那么为该列创建索引可能会提高性能。

2. 查询性能：对于执行时间较长或频繁执行的查询，特别是涉及大型数据集的查询，建立索引可以显著提高性能。在实际查询中测量性能，以确定是否需要索引。

3. 表大小：对于小型表，查询性能可能已经足够好，不需要索引。但对于大型表，索引通常更重要，因为它可以加速查询。

4. 数据分布：考虑数据分布的均匀性。如果某个列上的数据值分布不均匀，那么索引可能不会提供明显的性能改进。在这种情况下，需要权衡是否创建索引。

5. 查询类型：不同类型的查询可能需要不同类型的索引。例如，用于搜索的列需要不同于用于排序或分组的列的索引。

6. 维护成本：每个索引都需要额外的存储空间和维护成本。因此，考虑索引的维护开销，特别是在插入、更新和删除操作频繁的表上。

7. 覆盖索引：有时，可以使用覆盖索引来满足查询需求，而无需访问实际数据行。这可以减少索引的大小和维护开销。

8. 数据库引擎：不同的数据库管理系统（例如，MySQL、PostgreSQL、Oracle）在索引的处理和优化方面可能有差异。了解你使用的数据库引擎的特性和最佳实践也是评估索引需求的重要因素。

9. 查询计划：数据库提供了查询执行计划，它可以帮助你了解哪些查询受益于索引，哪些不受益。通过查看查询计划，可以识别需要进一步优化的查询。

10. 索引合并：在某些情况下，可以考虑使用多列索引（复合索引）来满足不同类型的查询需求，而无需为每个列都创建单独的索引。

综合考虑上述因素，并根据你的应用需求和性能测试结果，可以决定哪些列需要索引，哪些不需要。一种常见的做法是开始时只创建必需的索引，然后在需要优化查询性能时逐步添加其他索引。在数据库优化中，持续的监控和测试是非常重要的，以确保索引仍然有效。

---

12、java里面判断对象相等怎么做

注：此处我说的较为简单(面试够用，但出彩不行)，可以去查询相关详细博客

在 Java 中比较两个对象属性值是否相等，需要考虑到两个方面，一个是对象的引用地址，一个是对象属性的值。如果两个对象的引用地址相同，那么它们是同一个对象，属性值肯定相等；如果两个对象的引用地址不同，那么需要比较对象的属性值是否相等。

 判断两个对象是否相等时，有两种方法，== 和 equals()。

• == : 它的作用是判断两个对象的地址是不是相等。对于基本类型，比较的是值，对于对象，比较的是对象的存放地址。 
• equals() : 它的作用也是判断两个对象是否相等。

                如果类中覆盖了该方法(重写gai'fa)，那么通常是比较两个对象的内容是否相等。如果相         等，则返回 true；如果不等，则返回 false。 
                如果类中没有覆盖该方法，那么比较的是两个对象的地址是否相等，等价于==。

---

13、java里面多态绑定是什么，只有在运行时才知道某个具体的实例，底层是怎么做的（JVM）。类加载机制说一下

多态绑定（也称为动态绑定或运行时绑定）是面向对象编程的一个重要概念，它允许在运行时确定使用哪个方法实现，而不是在编译时静态地决定。多态性使得你可以编写通用的代码，能够处理多个不同类型的对象，而不必显式知道对象的实际类型。

多态绑定的实现是通过 Java 虚拟机（JVM）和 Java 编译器协同工作的结果。下面是多态绑定的工作原理以及与类加载机制的关系：

1. 方法调用：在 Java 中，当你通过对象引用调用方法时，编译器根据引用的静态类型（引用声明的类型）来选择调用哪个方法。

2. 动态分派：在运行时，JVM会根据对象的实际类型（运行时类型）来选择调用哪个方法。这个过程称为动态分派，它实现了多态绑定。这是 Java 的面向对象编程中的一个关键特性。

3. 方法表：JVM内部维护了一个方法表，它将对象的实际类型与相应的方法关联起来。当方法被调用时，JVM会查找方法表以确定要执行的方法。

4. 类加载机制：多态绑定与类加载密切相关。在 Java 中，类的加载分为三个阶段：加载、链接和初始化。在加载阶段，类的字节码被加载到内存中。在链接阶段，会进行验证、准备和解析操作。在初始化阶段，静态变量初始化和静态代码块执行。

多态绑定在链接和初始化阶段发挥作用。JVM会在运行时了解对象的实际类型，并建立方法表，以便在运行时正确地调用方法。这允许 Java 实现多态性，使得相同的方法调用可以根据对象的实际类型来选择不同的方法实现。

总结：多态绑定是 Java 的一个核心特性，它允许在运行时根据对象的实际类型来选择方法实现。这是通过 JVM 在类加载和链接阶段建立方法表来实现的，以便在运行时正确调用方法。类加载机制是多态绑定的实现基础之一。

---

14、线程池的几种拒绝策略。

线程池的拒绝策略是在线程池无法接受新任务时（通常是因为线程池已满或达到了其资源限制）确定如何处理新提交的任务的策略。Java 中的 ThreadPoolExecutor 类允许你设置不同的拒绝策略，以下是几种常见的拒绝策略：

1. AbortPolicy（默认策略）：这是默认的拒绝策略，当线程池无法接受新任务时，会抛出 RejectedExecutionException 异常，通知调用者任务被拒绝。

2. CallerRunsPolicy：如果线程池无法接受新任务，但线程池仍在运行，则会尝试在调用者线程中执行该任务，而不会将其丢弃。这意味着调用者线程会执行新任务。

3. DiscardPolicy：如果线程池无法接受新任务，该策略会默默地丢弃新任务，不抛出异常，也不执行任务。这可能会导致任务被丢弃而不被执行。

4. DiscardOldestPolicy：如果线程池无法接受新任务，该策略会丢弃队列中等待时间最长的任务，以便为新任务腾出空间。

这些拒绝策略允许你根据应用程序的需求来选择适当的策略。例如，如果你更关心不丢失任务而不是性能，可以选择 CallerRunsPolicy，使调用者线程执行新任务。如果你更关心性能而不是任务丢失，可以选择 DiscardPolicy 或 DiscardOldestPolicy，以避免异常并且不执行任务。

要设置特定的拒绝策略，你可以通过 ThreadPoolExecutor 的构造函数或使用 ThreadPoolExecutor 的 setRejectedExecutionHandler 方法来指定。以下是一个示例：

ThreadPoolExecutor executor = new ThreadPoolExecutor(
    corePoolSize,
    maximumPoolSize,
    keepAliveTime,
    TimeUnit.SECONDS,
    new LinkedBlockingQueue(queueSize), // 阻塞队列
    new CallerRunsPolicy()); // 拒绝策略

在上面的示例中，CallerRunsPolicy 被用作拒绝策略，当线程池无法接受新任务时，会尝试在调用者线程中执行该任务。

---

15、CAS的相关问题

CAS（Compare and Swap）是一种并发编程中的原子操作，用于实现多线程环境下的共享数据的同步和互斥访问。CAS 操作在 Java 中由 java.util.concurrent.atomic 包提供，并用于确保多线程之间对共享变量的安全访问。以下是与 CAS 相关的一些常见问题：

1、什么是CAS？

        CAS 是一种原子操作，用于比较内存中的值与期望值是否相等，如果相等，则将内存中的值更新为新值。CAS 操作是原子的，因此它可以用来实现多线程环境下的数据同步。

2、CAS 的基本原理是什么？

        CAS 基于比较和交换的思想，它包括三个参数：内存位置（通常是共享变量）、期望值和新值。CAS 操作会比较内存位置的值与期望值，如果相等，则将内存位置的值更新为新值。这一过程是原子的，如果多个线程同时尝试执行 CAS 操作，只有一个线程会成功，其他线程会重新尝试。

3、CAS 的应用场景是什么？

        CAS 主要用于实现锁、计数器、标志位等多线程环境下的同步和互斥访问。它在并发数据结构中广泛应用，如 AtomicInteger、AtomicBoolean 等。

4、CAS 有什么优势和局限性？

优势：

•         CAS 操作是非阻塞的，不会导致线程进入等待状态，提高了并发性。
•         CAS 操作可以避免死锁。
•         CAS 允许多线程同时更新不同的内存位置，提高并发性。

局限性：

•         CAS 不能解决 ABA 问题，即一个值被改变成其他值，然后再改回原值。为解决这个问题，通常需要使用带有版本号的 CAS 操作。
•         CAS 操作需要硬件的原子指令支持，因此不是在所有平台上都能高效实现。
•         CAS 操作在竞争激烈的情况下可能会导致自旋等待时间过长。

5、在 Java 中如何使用 CAS？

        在 Java 中，你可以使用 java.util.concurrent.atomic 包中的原子类（如 AtomicInteger、AtomicBoolean）来执行 CAS 操作。这些类封装了 CAS 操作，可以方便地用于多线程编程，而无需显式编写底层的 CAS 代码。

6、CAS 和锁之间的区别是什么？

        CAS 是一种乐观锁，它不会阻塞线程，而是在竞争发生时重试。锁是悲观锁，它会阻塞线程，等待其他线程释放锁。CAS 更适合用于低竞争情况下，而锁更适合用于高竞争情况下，但 CAS 的性能通常更好。

CAS 是多线程编程中重要的概念，它允许线程安全地执行共享数据的更新操作。然而，开发人员在使用 CAS 时需要小心处理可能的竞争条件和 ABA 问题。

---

16、设计模式的三种分类

创建型模式、结构型模式、行为型模式

1、创建型模式（Creational Patterns）：这些模式关注对象的创建过程，尽量降低系统耦合度，使系统更灵活、可扩展。创建型模式包括以下几种常见模式：

• 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点。
• 工厂模式（Factory Pattern）：定义一个用于创建对象的接口，但让子类决定实例化哪个类。
• 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。
• 建造者模式（Builder Pattern）：将一个复杂对象的构建与其表示分离，允许同样的构建过程创建不同的表示。
• 原型模式（Prototype Pattern）：通过复制现有对象来创建新对象。

2、结构型模式（Structural Patterns）：这些模式关注对象的组合，帮助你构建更大的结构，同时保持结构的灵活性。结构型模式包括以下几种常见模式：

• 适配器模式（Adapter Pattern）：将一个类的接口转换成客户端希望的另一个接口。
• 桥接模式（Bridge Pattern）：将抽象部分与它的实现部分分离，使它们可以独立变化。
• 组合模式（Composite Pattern）：将对象组合成树结构以表示部分-整体的层次结构。
• 装饰器模式（Decorator Pattern）：动态地给对象添加额外的职责。
• 外观模式（Facade Pattern）：为子系统提供一个统一接口，使其更容易使用。
• 享元模式（Flyweight Pattern）：通过共享来减小对象数量，降低内存占用。

3、行为型模式（Behavioral Patterns）：这些模式关注对象之间的通信和协作，以及如何完成对象的责任分配。行为型模式包括以下几种常见模式：

• 责任链模式（Chain of Responsibility Pattern）：将请求的发送者和接收者解耦，可以按照一定顺序传递请求。
• 命令模式（Command Pattern）：将一个请求封装成一个对象，从而允许参数化客户端操作。
• 解释器模式（Interpreter Pattern）：定义语言的文法，并建立一个解释器来解释语言中的句子。
• 迭代器模式（Iterator Pattern）：提供一种方法顺序访问一个聚合对象的元素，而不需要暴露它的内部表示。
• 中介者模式（Mediator Pattern）：用一个中介对象来封装一系列的对象交互，从而降低对象之间的耦合。
• 备忘录模式（Memento Pattern）：捕获一个对象的内部状态，并在该对象之外保存这个状态。
• 观察者模式（Observer Pattern）：定义对象之间的一对多依赖关系，使得当一个对象改变状态时，所有依赖它的对象都会收到通知。
• 状态模式（State Pattern）：允许对象在其内部状态发生改变时改变它的行为。
• 策略模式（Strategy Pattern）：定义一系列算法，将它们封装起来，使它们可以互相替换。
• 模板方法模式（Template Method Pattern）：定义一个算法的骨架，而将一些步骤延迟到子类中实现。
• 访问者模式（Visitor Pattern）：封装了作用于某对象结构中的各元素的操作，它可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

这些设计模式有助于解决各种不同的问题和挑战，帮助开发人员更好地设计和组织代码。选择适当的设计模式取决于你的具体需求和项目背景。

---

17、spring源码有了解吗？spring的事务传播机制，底层是怎么实现的。比如A调用B,B是怎么知道A的事务的。

        我了解Spring框架的基本原理，但是要详细了解Spring事务管理的底层实现，需要深入研究Spring源代码。Spring的事务传播机制和事务管理是基于AOP（面向切面编程）和代理模式实现的，下面是关于事务传播机制的更详细解释：

        Spring的事务传播机制是基于AOP代理实现的，当你在一个Spring管理的bean方法上使用@Transactional注解或XML配置事务时，Spring会为该bean生成一个代理对象，并将事务管理逻辑织入该代理对象中。

        当一个方法A调用另一个方法B时，如果方法A已经处于一个事务中，方法B会根据事务传播属性来决定如何处理事务。这是如何发生的：

1. 当方法A被调用时，Spring会检查是否已经存在一个事务。如果已经存在一个事务，方法A会加入到这个事务中。这是由事务传播属性来决定的，例如PROPAGATION_REQUIRED表示如果没有事务则创建一个，否则加入已有事务。

2. 方法A调用方法B时，事务的传播属性会继续传递。如果方法B有@Transactional注解并且指定了事务传播属性，它会根据这个属性来决定如何处理事务。如果没有指定，它将继承方法A的传播属性。

3. 如果方法B被调用并且它需要创建一个新的事务，它会在方法B开始时创建一个新的事务。这个事务会嵌套在方法A的事务内部，形成一个事务的嵌套结构。

4. 如果方法B内部出现异常并回滚事务，只会回滚方法B创建的嵌套事务，而不会影响方法A的事务。这是事务传播属性PROPAGATION_REQUIRES_NEW的行为。

        底层的实现是通过AOP代理和事务管理器来完成的。Spring使用AOP来生成事务代理，然后通过事务管理器来管理事务的开始、提交和回滚等操作。当事务传播发生时，代理对象会根据事务传播属性来协调事务管理器的操作。

        要深入了解Spring事务的底层实现，可以研究Spring的事务管理器接口以及具体的事务管理器实现，如DataSourceTransactionManager，并查看AOP代理的生成和管理。这需要深入研究Spring的源代码以了解更多细节。

---

18、rpc通信中序列化和反序列化有哪些工具等

        在RPC（远程过程调用）通信中，序列化和反序列化是非常重要的步骤，用于将数据转换为可在网络传输的二进制格式，以及将接收到的二进制数据还原为数据对象。以下是一些常见的序列化和反序列化工具和格式：

1. Protocol Buffers（ProtoBuf）：ProtoBuf是由Google开发的一种高效、紧凑和跨语言兼容的二进制序列化格式。它使用.proto文件来定义数据结构，然后生成用于不同编程语言的序列化和反序列化代码。在Java中，你可以使用Google的官方库protobuf-java来进行ProtoBuf的序列化和反序列化。

2. Apache Thrift：Thrift是由Apache开发的跨语言RPC框架，它包含了自己的二进制序列化格式。 Thrift也支持多种编程语言，并允许你使用IDL（接口定义语言）来定义数据结构和服务。你可以使用Apache Thrift库来进行序列化和反序列化。

3. Apache Avro：Avro是Apache的一个项目，提供了一种二进制数据序列化框架。它支持动态架构，允许数据的架构在运行时演化。Avro也支持多种编程语言，包括Java。

4. JSON序列化：JSON（JavaScript Object Notation）是一种文本格式，通常用于数据交换。在RPC中，你可以使用JSON来序列化和反序列化数据。Java中有很多JSON库，如Jackson、Gson等，可用于处理JSON数据。

5. XML序列化：XML（eXtensible Markup Language）也常用于数据交换。在Java中，你可以使用JAXB（Java Architecture for XML Binding）或其他XML库来进行序列化和反序列化。

6. MessagePack：MessagePack是一种高效的二进制序列化格式，支持多种编程语言，包括Java。它具有紧凑的二进制表示和高性能特点。

7. Kryo：Kryo是一个高性能的Java序列化库，通常用于处理复杂数据对象。它比Java标准序列化更快，但不具备跨语言兼容性。

        选择序列化工具通常取决于项目的需求，包括性能、跨语言兼容性、数据格式大小和易用性等因素。不同的工具适合不同的场景，因此需要根据具体情况选择适当的序列化和反序列化方式。

---

19、有重复数字的全排序（算法题）

给定一个不含重复数字的整数数组 nums ，返回其 所有可能的全排列 。可以 按任意顺序 返回答案。

• 第一段代码可以由用户输入数组元素
• 第二段代码nums是固定的

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class PermutationsInputWithComments {
    // 递归方法，用于生成全排列
    public List> permute(int[] nums) {
        List> result = new ArrayList<>();
        List current = new ArrayList<>();
        boolean[] used = new boolean[nums.length];
        backtrack(nums, used, current, result);
        return result;
    }

    private void backtrack(int[] nums, boolean[] used, List current, List> result) {
        // 如果当前排列的长度等于数组长度，表示已生成一个全排列
        if (current.size() == nums.length) {
            result.add(new ArrayList<>(current)); // 将当前排列添加到结果列表
            return;
        }

        // 遍历数组中的元素
        for (int i = 0; i < nums.length; i++) {
            if (!used[i]) { // 如果元素未被使用
                used[i] = true; // 标记元素为已使用
                current.add(nums[i]); // 将元素添加到当前排列
                backtrack(nums, used, current, result); // 递归生成下一个元素的排列
                current.remove(current.size() - 1); // 恢复当前排列，以便尝试其他元素
                used[i] = false; // 恢复元素为未使用
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入整数数组（用空格分隔）：");
        String input = scanner.nextLine();
        String[] inputArray = input.split(" ");
        int[] nums = new int[inputArray.length];
        for (int i = 0; i < inputArray.length; i++) {
            nums[i] = Integer.parseInt(inputArray[i]);
        }
        PermutationsInputWithComments solution = new PermutationsInputWithComments();
        List> permutations = solution.permute(nums);
        for (List perm : permutations) {
            System.out.println(perm);
        }
    }
}

这个程序会提示用户输入整数数组，用户可以使用空格分隔整数。然后，程序会生成输入数组的所有可能的全排列，并将它们输出到控制台。

使用递归和回溯方法，同时在递归过程中去除重复的排列：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class PermutationsWithDuplicates {
    public static List> permuteUnique(int[] nums) {
        List> result = new ArrayList<>();
        Arrays.sort(nums);  // 首先排序数组，以便去除重复排列
        backtrack(nums, new boolean[nums.length], new ArrayList<>(), result);
        return result;
    }

    private static void backtrack(int[] nums, boolean[] used, List current, List> result) {
        if (current.size() == nums.length) {
            result.add(new ArrayList<>(current));
            return;
        }

        for (int i = 0; i < nums.length; i++) {
            if (used[i] || (i > 0 && nums[i] == nums[i - 1] && !used[i - 1])) {
                continue;  // 跳过已使用的数字和重复数字
            }

            used[i] = true;
            current.add(nums[i]);
            backtrack(nums, used, current, result);
            current.remove(current.size() - 1);
            used[i] = false;
        }
    }

    public static void main(String[] args) {
        int[] nums = {1, 1, 2};
        List> permutations = permuteUnique(nums);
        for (List perm : permutations) {
            System.out.println(perm);
        }
    }
}

这段代码使用回溯法生成包含重复数字的数组的全排列，并在递归过程中去除重复排列。最后，它将所有可能的排列存储在 result 列表中。在示例中，输入为 {1, 1, 2}，它会生成包含去重排列的结果列表。

欢迎您于百忙之中阅读这篇博客，希望这篇博客给您带来了一些帮助，祝您生活愉快！