Java 热门面试题-05

最近更新：2025-06-20 | 字数总计：12.4k

为什么 TCP 挥手需要有 TIME_WAIT 状态?

TCP连接的TIME_WAIT状态，也称为2MSL（Maximum Segment Lifetime，最大报文段生存时间）等待状态，是TCP挥手（四次挥手）过程中的一个重要状态。它的存在主要有以下几个原因：

保证TCP连接的可靠终止
TIME_WAIT状态确保了主动关闭方（通常称为客户端）发送的最后一个ACK报文段能够被被动关闭方（通常称为服务器）正确接收。如果这个ACK丢失，服务器将重新发送FIN报文段，而客户端需要在TIME_WAIT状态下等待足够的时间来接收并响应这个重发的FIN报文段。
防止旧连接的报文段干扰新连接
TCP连接由四元组（源IP、源端口、目标IP、目标端口）唯一标识。在TIME_WAIT状态下，这个四元组在一段时间内不会被新的连接使用。这可以防止由于网络延迟或路由器缓存等原因，导致旧连接的报文段在新连接建立后仍然到达目的地，从而干扰新连接的正常通信。
允许足够的时间让网络中的报文段过期
TCP报文段在网络中具有一定的生存时间（TTL），超过这个时间报文段将被丢弃。TIME_WAIT状态持续的时间通常是报文段最大生存时间的两倍（2MSL），这样可以确保所有相关的报文段都已经从网络中消失，不会对后续的连接造成影响。
处理延迟的重复报文段
在某些情况下，网络可能会延迟或重复发送报文段。TIME_WAIT状态可以处理这些延迟的重复报文段，防止它们被误认为是新连接的一部分。

TIME_WAIT状态的影响

资源占用：处于TIME_WAIT状态的连接会占用一定的系统资源，如套接字等。
端口耗尽：如果短时间内大量连接进入TIME_WAIT状态，可能会导致端口耗尽，影响新连接的建立。

解决TIME_WAIT状态的问题

调整系统参数：可以通过调整系统的TCP参数来减少TIME_WAIT状态的影响，如增加端口的范围或减少TIME_WAIT的时间。
使用TCP快速打开（TCP Fast Open）：TCP Fast Open允许在TIME_WAIT状态下快速建立新的连接，减少等待时间。

总之，TIME_WAIT状态是TCP连接管理中的一个重要机制，它保证了TCP连接的可靠性和稳定性，尽管可能会带来一些资源占用和性能问题，但通常是必要的。

Spring Boot 的核心特性有哪些？

Spring Boot 的核心特性使其成为快速开发和部署 Spring 应用的理想选择。以下是主要特性：

自动配置（Auto-configuration）
- 自动配置：根据类路径依赖自动配置 Spring 应用，减少手动配置。
- 条件化配置：通过 @Conditional 注解实现条件化配置，确保只在满足条件时生效。
起步依赖（Starter Dependencies）
- 预定义依赖：提供一系列起步依赖，简化依赖管理。
- 依赖传递：起步依赖包含常用库及其传递依赖，减少版本冲突。
嵌入式 Web 服务器
- 内嵌服务器：支持 Tomcat、Jetty 和 Undertow，无需单独部署。
- 简化部署：直接运行 JAR 文件即可启动应用。
Actuator
- 监控和管理：提供生产级监控和管理功能，如健康检查、指标收集、环境信息等。
- 端点扩展：支持自定义端点，满足特定需求。
外部化配置
- 多种配置源：支持 application.properties、application.yml、环境变量、命令行参数等。
- 配置优先级：提供灵活的配置优先级机制，便于不同环境配置管理。
Spring Boot CLI
- 命令行工具：通过命令行快速开发和测试 Spring 应用。
- Groovy 脚本：支持使用 Groovy 脚本编写应用，简化开发。
日志管理
- 默认配置：提供合理的默认日志配置，支持多种日志框架（如 Logback、Log4j2）。
- 自定义配置：支持通过配置文件自定义日志行为。
测试支持
- 测试工具：提供丰富的测试工具和注解（如 @SpringBootTest、@WebMvcTest）。
- 嵌入式数据库：支持嵌入式数据库（如 H2），简化测试环境配置。
Spring Boot DevTools
- 开发工具：提供开发时工具，如自动重启、LiveReload 等，提升开发效率。
- 快速反馈：代码变更后自动重启应用，快速查看效果。
Spring Boot Actuator

生产就绪功能：提供健康检查、审计、指标收集等功能，便于生产环境监控和管理。
自定义端点：支持自定义 Actuator 端点，满足特定需求。

总结

Spring Boot 的核心特性包括自动配置、起步依赖、嵌入式 Web 服务器、Actuator、外部化配置、CLI、日志管理、测试支持、DevTools 和 Actuator。这些特性简化了 Spring 应用的开发、部署和管理，提升了开发效率和应用的可靠性。

为什么 HashMap 在 Java 中扩容时采用 2 的 n 次方倍？

在Java中，HashMap扩容时采用2的n次方倍（即每次扩容时容量翻倍）的设计选择是基于多个原因，主要包括提高哈希表的性能和简化哈希冲突的处理。以下是详细解释：

保持哈希值的分布均匀
HashMap使用哈希值与数组长度的模运算来确定键值对在数组中的位置。如果数组长度是2的n次方，那么哈希值与数组长度的模运算可以简化为与数组长度的二进制表示中最低非零位进行按位与运算。这种运算非常快速，而且能够保证哈希值在数组中的分布更加均匀，减少哈希冲突的概率。
简化扩容时的重新哈希过程
当HashMap扩容时，需要将原有的键值对重新插入到新的数组中。由于数组长度翻倍，每个键值对的位置只有两种可能：保持不变或移动到原位置的两倍位置。这种特性使得重新哈希的过程更加高效，因为不需要重新计算所有键值对的位置，只需要判断哈希值与新数组长度的关系即可。
提高哈希表的扩展性
采用2的n次方倍扩容可以确保哈希表在扩展时保持较好的性能。如果扩容不是翻倍，那么每次扩容后哈希值的分布可能会变得不均匀，导致更多的哈希冲突和性能下降。
兼容性考虑
Java的HashMap设计初衷就是采用2的n次方倍扩容，这种设计在Java社区中被广泛接受和使用。保持这种设计可以确保向后兼容性，使得现有的代码和库能够继续正常工作。
减少内存碎片
翻倍扩容可以减少内存碎片，因为每次扩容都是分配一个全新的数组，而不是在原有数组基础上进行扩展。这有助于提高内存的使用效率。

注意事项

初始容量选择：在使用HashMap时，建议根据预期元素数量选择合适的初始容量，以减少扩容操作的次数。
负载因子：HashMap的负载因子（默认为0.75）决定了扩容的时机。选择合适的负载因子可以平衡空间和时间效率。

总之，HashMap在Java中扩容时采用2的n次方倍的设计是基于性能、简化哈希冲突处理、扩展性、兼容性和内存效率等多方面的考虑。这种设计在实际应用中证明是有效和高效的。

你在项目中使用的 Redis 客户端是什么？

在项目中使用的 Redis 客户端通常是 Jedis 或 Lettuce，两者各有优缺点，具体选择取决于项目需求。

Jedis
- 特点：
  - 阻塞 I/O：基于阻塞 I/O，适合简单场景。
  - 轻量级：API 简单易用，适合快速上手。
  - 连接池：支持连接池，提升性能。
- 适用场景：适合小型项目或对性能要求不高的场景。
1
2
3
4
Jedis jedis = new Jedis("localhost", 6379);
jedis.set("key", "value");
String value = jedis.get("key");
jedis.close();

Lettuce

特点：
- 异步和非阻塞：基于 Netty，支持异步和非阻塞操作，适合高并发场景。
- 线程安全：连接是线程安全的，可在多个线程间共享。
- 高级功能：支持响应式编程、集群模式等高级功能。
适用场景：适合大型项目或高并发场景。

RedisClient client = RedisClient.create("redis://localhost:6379");
StatefulRedisConnection<String, String> connection = client.connect();
RedisCommands<String, String> commands = connection.sync();
commands.set("key", "value");
String value = commands.get("key");
connection.close();
client.shutdown();

Redisson

特点：
- 分布式对象：提供分布式对象和服务（如分布式锁、集合等）。
- 高扩展性：适合复杂分布式系统。
适用场景：需要分布式对象和服务的场景。

Config config = new Config();
config.useSingleServer().setAddress("redis://localhost:6379");
RedissonClient client = Redisson.create(config);
RMap<String, String> map = client.getMap("myMap");
map.put("key", "value");
String value = map.get("key");
client.shutdown();

Spring Data Redis

特点：
- 抽象层：提供对 Redis 的高级抽象，简化操作。
- 集成：与 Spring 生态无缝集成。
适用场景：使用 Spring 框架的项目。

@Autowired
private RedisTemplate<String, String> redisTemplate;

public void setKey(String key, String value) {
    redisTemplate.opsForValue().set(key, value);
}

public String getKey(String key) {
    return redisTemplate.opsForValue().get(key);
}

总结

Jedis：适合小型项目或简单场景。
Lettuce：适合高并发场景，支持异步和非阻塞操作。
Redisson：适合需要分布式对象和服务的场景。
Spring Data Redis：适合使用 Spring 框架的项目。

选择 Redis 客户端时，需根据项目需求和性能要求进行权衡。

TCP 超时重传机制是为了解决什么问题？

TCP超时重传机制是为了解决网络数据传输中可能出现的丢包、延迟和乱序等问题，确保数据的可靠传输。具体来说，它解决了以下几个主要问题：

丢包
在网络传输过程中，数据包可能会因为各种原因（如网络拥塞、设备故障等）而丢失。TCP超时重传机制通过在发送方设置一个定时器，如果在规定的时间内没有收到接收方的确认（ACK）报文，就会认为该数据包丢失，并重新发送该数据包。
延迟
网络延迟可能导致数据包到达接收方的时间延长，从而使得发送方无法在预期时间内收到确认报文。超时重传机制可以确保在延迟情况下，发送方能够等待足够的时间来接收确认，如果超时则重传数据包。
乱序
在某些情况下，数据包可能会到达接收方的顺序与发送方的顺序不同，这称为乱序。虽然TCP通过序列号和确认机制来处理乱序问题，但超时重传机制可以作为补充，确保在乱序导致确认报文延迟到达时，发送方能够重传可能丢失的数据包。
确认报文丢失
即使数据包成功到达接收方，但返回的确认报文可能会在网络中丢失。超时重传机制可以确保在这种情况下，发送方会重新发送数据包，从而触发接收方再次发送确认报文。
提高可靠性
TCP作为一种可靠的传输协议，其目标是在不可靠的网络环境中提供可靠的数据传输服务。超时重传机制是实现这一目标的关键机制之一，它通过重传丢失或延迟的数据包，提高了整体的数据传输可靠性。
拥塞控制
超时重传机制也与TCP的拥塞控制机制密切相关。当网络拥塞导致数据包丢失时，超时重传不仅恢复了丢失的数据包，还通常伴随着拥塞窗口的调整，以减少发送方的发送速率，从而缓解网络拥塞。

总之，TCP超时重传机制是确保数据可靠传输的重要手段，它通过处理丢包、延迟、乱序和确认报文丢失等问题，提高了TCP连接的稳定性和数据传输的可靠性。

简述 MyBatis 的插件运行原理，以及如何编写一个插件？

MyBatis插件运行原理：

MyBatis插件是基于Java的动态代理技术实现的。MyBatis使用了一个名为Interceptor的接口，允许用户通过实现这个接口来定义自己的插件。插件可以拦截MyBatis中的四大对象的方法调用，这四大对象是：

Executor：执行器，负责执行SQL语句。
StatementHandler：语句处理器，负责处理SQL语句。
ParameterHandler：参数处理器，负责设置SQL语句中的参数。
ResultSetHandler：结果集处理器，负责处理SQL查询结果。

MyBatis通过动态代理技术，在运行时对这四大对象的方法调用进行拦截，允许插件在方法执行前后添加自定义逻辑。

插件运行原理简述：

MyBatis启动时，会读取配置文件中的插件配置。
对于每个配置的插件，MyBatis会使用动态代理技术创建对应的代理对象。
当MyBatis执行SQL操作时，会通过代理对象调用相应的方法。
代理对象会拦截方法调用，执行插件中的逻辑（如修改SQL语句、设置参数等）。
执行完插件逻辑后，代理对象会调用原始对象的方法，完成SQL操作。

如何编写一个MyBatis插件：

定义插件类：创建一个类，实现Interceptor接口。

import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import java.util.Properties;
@Intercepts({
    @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class}),
    @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
public class MyPlugin implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        // 插件逻辑
        Object returnObject = invocation.proceed(); // 执行原方法
        return returnObject;
    }
    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }
    @Override
    public void setProperties(Properties properties) {
        // 设置插件属性
    }
}

配置插件：在MyBatis的配置文件中配置插件。

<plugins>
    <plugin interceptor="com.example.MyPlugin">
        <property name="someProperty" value="someValue"/>
    </plugin>
</plugins>

实现插件逻辑：在intercept方法中实现自定义逻辑，如修改SQL语句、设置参数等。
包装目标对象：在plugin方法中使用Plugin.wrap方法将目标对象包装成代理对象。
设置插件属性：在setProperties方法中读取配置文件中设置的插件属性。

通过以上步骤，就可以编写一个自定义的MyBatis插件，用于拦截和扩展MyBatis的行为。

数组和链表在 Java 中的区别是什么？

数组和链表在 Java 中的主要区别体现在数据结构、内存分配、操作效率和使用场景等方面。以下是详细对比：

数据结构
- 数组：
  - 连续内存：元素在内存中连续存储。
  - 固定大小：创建时需指定大小，且不能动态调整。
- 链表：
  - 非连续内存：元素通过指针连接，内存中非连续存储。
  - 动态大小：可动态调整大小。
内存分配
- 数组：
  - 静态分配：内存一次性分配，大小固定。
- 链表：
  - 动态分配：内存按需分配，大小可动态调整。
操作效率
- 访问元素：
  - 数组：O(1)，通过索引直接访问。
  - 链表：O(n)，需从头节点遍历。
- 插入/删除元素：
  - 数组：O(n)，需移动后续元素。
  - 链表：O(1)，只需调整指针（已知节点位置时）。
- 查找元素：
  - 数组：O(n)，需遍历数组。
  - 链表：O(n)，需遍历链表。
使用场景
- 数组：
  - 适合场景：频繁访问元素、元素数量固定。
  - 示例：存储固定大小的数据集合，如矩阵、缓冲区。
- 链表：
  - 适合场景：频繁插入/删除元素、元素数量动态变化。
  - 示例：实现栈、队列、链表等动态数据结构。

代码示例

数组：

1
2
3

int[] array = new int[10];
array[0] = 1; // O(1) 访问
array[1] = 2; // O(1) 访问

链表：

LinkedList<Integer> list = new LinkedList<>();
list.add(1); // O(1) 插入
list.add(2); // O(1) 插入
int first = list.get(0); // O(n) 访问

总结

数组：适合频繁访问和固定大小的场景，访问速度快，但插入/删除效率低。
链表：适合频繁插入/删除和动态大小的场景，插入/删除效率高，但访问速度慢。

选择时需根据具体需求权衡。

Redis 中常见的数据类型有哪些？

Redis 是一个开源的内存数据结构存储系统，可以用作数据库、缓存和消息代理。它支持多种数据类型，以下是Redis中常见的数据类型：

字符串（Strings）：
- 最基本的数据类型，可以存储任何类型的字符串，包括二进制数据。
- 常用于存储简单的键值对，如用户名、密码等。
列表（Lists）：
- 存储有序的字符串列表，可以添加到列表的头部或尾部。
- 常用于实现消息队列、文章列表等。
集合（Sets）：
- 存储无序的唯一字符串集合，支持添加、删除和查找操作。
- 常用于存储标签、用户喜好等。
有序集合（Sorted Sets）：
- 类似于集合，但每个成员都关联一个分数，可以按分数排序。
- 常用于实现排行榜、用户评分等。
哈希表（Hashes）：
- 存储键值对集合，类似于Java中的HashMap。
- 常用于存储对象属性，如用户信息、商品详情等。
地理空间索引半径查询（Geospatial Index Radius Queries）：
- 用于存储地理位置信息，支持半径查询等地理空间操作。
位图（Bitmaps）：
- 通过位操作来存储和操作位数组，常用于实现布隆过滤器等。
超日志（HyperLogLogs）：
- 用于估计大量集合的基数，即集合中不同元素的数量。
流（Streams）：
- 用于存储和操作连续的数据流，支持时间序列数据等。
模块化数据类型（Modules）：
- 通过加载Redis模块，可以扩展新的数据类型。

这些数据类型为Redis提供了强大的功能，使其能够应对各种不同的应用场景。在选择数据类型时，需要根据具体的需求和性能要求来决定。

TCP 滑动窗口的作用是什么？

TCP 滑动窗口的主要作用是实现流量控制和可靠数据传输，确保数据高效、可靠地传输。以下是其具体作用：

流量控制
- 防止接收方过载：通过动态调整窗口大小，控制发送方的发送速率，避免接收方缓冲区溢出。
- 窗口大小调整：接收方在确认报文中通告当前可用缓冲区大小，发送方据此调整发送窗口。
可靠数据传输
- 按序确认：接收方按序确认数据，确保数据顺序正确。
- 重传机制：发送方在未收到确认时会重传数据，确保数据可靠到达。
提高网络利用率
- 批量发送：允许发送方在未收到确认前继续发送数据，减少等待时间，提高网络利用率。
- 自适应调整：根据网络状况动态调整窗口大小，优化传输效率。
拥塞控制
- 拥塞窗口：结合拥塞控制算法（如慢启动、拥塞避免），动态调整发送窗口，避免网络拥塞。
滑动窗口的工作原理
- 发送窗口：发送方维护一个窗口，包含已发送未确认和待发送的数据。
- 接收窗口：接收方维护一个窗口，指示当前可接收的数据范围。
- 窗口滑动：随着数据被确认，窗口向前滑动，允许发送新数据。
1
2
发送方窗口：
[已确认][已发送未确认][待发送][不可发送]
1
2
接收方窗口：
[已接收][可接收][不可接收]
滑动窗口的示例
- 发送方：发送窗口大小为 4，发送数据段 1-4。
- 接收方：确认数据段 1-2，窗口向前滑动，发送方继续发送数据段 5-6。
1
2
发送方窗口滑动：
[1-2][3-4][5-6][7-8]
1
2
接收方窗口滑动：
[1-2][3-4][5-6][7-8]

总结

TCP 滑动窗口通过流量控制、可靠数据传输、提高网络利用率和拥塞控制，确保数据高效、可靠地传输。其动态调整窗口大小的机制，优化了网络性能和数据传输的可靠性。

介绍一下 Reactor 线程模型？

Reactor 线程模型是一种事件驱动的设计模式，用于高效处理大量并发请求。其核心思想是将事件分发与事件处理分离，通过有限线程处理大量 I/O 操作。以下是详细介绍：

核心组件
- Reactor：负责监听和分发事件，如 I/O 事件。
- Handler：负责处理具体事件，如读写操作。
- Demultiplexer：多路复用器，用于监听多个事件源（如 select、poll、epoll）。

单 Reactor 单线程模型

结构：
- 一个 Reactor 线程负责监听和分发事件。
- 所有事件处理在同一线程中完成。
优点：简单，无线程切换开销。
缺点：无法充分利用多核 CPU，性能受限。
适用场景：低并发、低延迟场景。

+-------------------+
|     Reactor       |
| (Event Dispatcher)|
+--------+----------+
         |
         | 事件分发
         v
+--------+----------+
|     Handler       |
| (Event Handler)   |
+-------------------+

单 Reactor 多线程模型

结构：
- 一个 Reactor 线程负责监听和分发事件。
- 事件处理由线程池中的多个线程完成。
优点：充分利用多核 CPU，提升并发处理能力。
缺点：Reactor 线程可能成为瓶颈。
适用场景：高并发、计算密集型场景。

+-------------------+
|     Reactor       |
| (Event Dispatcher)|
+--------+----------+
         |
         | 事件分发
         v
+--------+----------+
|  Thread Pool      |
| (Event Handlers)  |
+-------------------+

多 Reactor 多线程模型

结构：
- 多个 Reactor 线程，每个负责监听和分发一部分事件。
- 事件处理由线程池中的多个线程完成。
优点：进一步提升并发处理能力，减少单 Reactor 的瓶颈。
缺点：实现复杂，线程间协调开销增加。
适用场景：极高并发、高吞吐量场景。

+-------------------+       +-------------------+
|  Reactor 1        |       |  Reactor N        |
| (Event Dispatcher)| ...   | (Event Dispatcher)|
+--------+----------+       +--------+----------+
         |                          |
         | 事件分发                  | 事件分发
         v                          v
+--------+----------+       +--------+----------+
|  Thread Pool      |       |  Thread Pool      |
| (Event Handlers)  |       | (Event Handlers)  |
+-------------------+       +-------------------+

Reactor 模型的优点
- 高并发：通过事件驱动和非阻塞 I/O 处理大量并发连接。
- 低延迟：减少线程切换和上下文切换，提升响应速度。
- 可扩展性：通过增加 Reactor 和线程池，提升系统处理能力。
Reactor 模型的缺点
- 复杂性：实现和调试复杂，需处理线程同步和事件分发。
- 调试困难：事件驱动和非阻塞 I/O 增加调试难度。

总结

Reactor 线程模型通过事件驱动和非阻塞 I/O 高效处理大量并发请求。常见的实现方式有单 Reactor 单线程、单 Reactor 多线程和多 Reactor 多线程模型，各有优缺点，适用于不同场景。

Java 线程池核心线程数在运行过程中能修改吗？如何修改？

在Java中，线程池的核心线程数在运行过程中是可以修改的，但是这取决于所使用的线程池实现。对于ThreadPoolExecutor类，它是可以修改核心线程数的。下面是如何修改核心线程数的方法：

修改核心线程数

ThreadPoolExecutor提供了setCorePoolSize(int corePoolSize)方法来修改核心线程数。这个方法允许你在运行时动态地改变核心线程数。

import java.util.concurrent.ThreadPoolExecutor;
// 假设你有一个ThreadPoolExecutor实例叫做executor
ThreadPoolExecutor executor = ...;
// 修改核心线程数为新的值，例如10
executor.setCorePoolSize(10);

注意事项

线程池状态：只有在线程池是运行状态时，修改核心线程数才是有效的。
增加核心线程数：如果增加核心线程数，线程池会尝试添加新的核心线程，直到达到新的核心线程数。
减少核心线程数：如果减少核心线程数，已经存在的核心线程不会立即被终止。它们会继续执行直到完成当前任务，然后根据线程池的空闲时间策略来决定是否终止。
核心线程超时：默认情况下，核心线程不会因为空闲而终止。但是，你可以通过allowCoreThreadTimeOut(boolean value)方法来允许核心线程在空闲时终止。

1 2	// 允许核心线程在空闲时终止 executor.allowCoreThreadTimeOut(true);

线程池类型：对于Executors工厂方法创建的某些线程池，如newFixedThreadPool、newSingleThreadExecutor等，它们的核心线程数是固定的，通常不需要修改。

示例

以下是一个简单的示例，展示如何创建一个ThreadPoolExecutor并修改其核心线程数：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建一个线程池
        int corePoolSize = 5;
        int maximumPoolSize = 10;
        long keepAliveTime = 5000;
        TimeUnit unit = TimeUnit.MILLISECONDS;
        BlockingQueue<Runnable> workQueue = new LinkedBlockingQueue<>();
        ThreadPoolExecutor executor = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                keepAliveTime,
                unit,
                workQueue);
        // 修改核心线程数为8
        executor.setCorePoolSize(8);
        // 提交一些任务到线程池
        for (int i = 0; i < 20; i++) {
            executor.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " is running");
            });
        }
        // 关闭线程池
        executor.shutdown();
    }
}

在这个示例中，我们创建了一个ThreadPoolExecutor，并在运行时将其核心线程数从5修改为8。然后，我们提交了一些任务到线程池，并最终关闭了线程池。

总之，ThreadPoolExecutor的核心线程数是可以在运行过程中修改的，但是需要谨慎操作，以避免对线程池的稳定性和性能产生不良影响。

TCP/IP 四层模型是什么？

TCP/IP四层模型，也称为TCP/IP协议栈，是一种用于计算机网络通信的分层模型。它将网络通信过程划分为四个不同的层次，每一层都负责特定的功能，并且每一层都为上一层提供服务。这四层从上到下分别是：

应用层（Application Layer）：
- 这是最高层，直接为用户应用提供网络服务。
- 包括各种网络应用协议，如HTTP（网页浏览）、FTP（文件传输）、SMTP（邮件发送）、DNS（域名解析）等。
- 应用层协议定义了数据交换的格式和规则。
传输层（Transport Layer）：
- 负责提供端到端的通信服务。
- 主要协议包括TCP（传输控制协议）和UDP（用户数据报协议）。
- TCP提供可靠的数据传输，具有错误检测、数据重传、流量控制等功能。
- UDP提供不可靠但快速的数据传输，适用于实时应用如音视频传输。
网络层（Internet Layer）：
- 负责数据包从源主机到目标主机的路由和转发。
- 主要协议是IP（互联网协议），包括IPv4和IPv6。
- IP协议负责为数据包分配地址（IP地址），并决定数据包的传输路径。
网络接口层（Network Interface Layer）：
- 也称为数据链路层或网络访问层。
- 负责在物理网络中传输数据帧。
- 包括各种网络接口卡（NIC）和物理介质，如以太网（Ethernet）、Wi-Fi、令牌环（Token Ring）等。
- 这一层处理数据的封装、解封、错误检测和纠正等。
  每一层在处理数据时，都会在数据上添加自己的头部信息（如源地址、目标地址、序列号等），这样接收方就可以根据这些信息正确地处理数据。这种分层结构使得网络通信更加有序和高效。
  TCP/IP四层模型与OSI七层模型有所不同，但它们的基本思想是相似的，都是为了实现网络通信的分层和模块化。TCP/IP模型更加简洁，适用于实际的互联网环境。

说说 MyBatis 的缓存机制？

MyBatis 是一个流行的 Java 持久层框架，它提供了强大的 SQL 映射和动态 SQL 功能。MyBatis 的缓存机制是其性能优化的重要组成部分，主要包括两级缓存：一级缓存和二级缓存。

一级缓存

一级缓存是 MyBatis 的默认缓存，也称为本地缓存或会话缓存。它存在于 SqlSession 的生命周期中，即同一个 SqlSession 中执行相同的查询语句时，第一次查询结果会被缓存，后续的查询会直接从缓存中获取结果，而不需要再次执行 SQL 语句。

一级缓存的特点：

默认开启，无法关闭。
生命周期与 SqlSession 相同。
缓存的数据只在当前会话中有效。
基于内存存储，速度快。
当执行更新操作（如 insert、update、delete）时，缓存会失效。

一级缓存的问题：

在不同的 SqlSession 中，缓存数据不共享。
在分布式环境下，缓存不一致。

二级缓存

二级缓存是 MyBatis 的全局缓存，它存在于 SqlSessionFactory 的生命周期中。二级缓存可以跨多个 SqlSession 共享数据，即不同的 SqlSession 可以访问相同的缓存数据。

二级缓存的特点：

需要手动开启和配置。
生命周期与 SqlSessionFactory 相同。
缓存的数据在所有会话中共享。
可以配置存储介质，如内存、磁盘等。
提供了更细粒度的缓存控制，如缓存分区、缓存失效策略等。

二级缓存的配置：

在 MyBatis 配置文件中开启二级缓存。
在映射文件中配置缓存策略。
在对应的 POJO 类上实现 Serializable 接口。

二级缓存的问题：

缓存数据的一致性问题，特别是在分布式环境下。
缓存的管理和监控相对复杂。

缓存的使用场景

一级缓存适用于单个会话内的频繁查询，可以减少数据库访问次数，提高性能。
二级缓存适用于多个会话间的数据共享，可以减少数据库的整体负载。

注意事项

使用缓存时，需要考虑数据的一致性和时效性。
缓存不适合用于实时性要求高的场景。
在分布式系统中，需要考虑缓存的同步和失效问题。

MyBatis 的缓存机制可以显著提高应用性能，但需要根据具体场景合理配置和使用。不当的缓存策略可能会导致数据不一致或其他问题。

什么是 Spring Boot？

Spring Boot 是一个基于 Spring 框架的开源项目，它旨在简化 Spring 应用的创建、配置和部署过程。Spring Boot 使得开发者能够更快速、更轻松地开发和交付基于 Spring 的应用。

主要特点：

快速启动：Spring Boot 提供了大量的启动器依赖（Starter Dependencies），这些依赖简化了项目构建和配置过程。
自动配置：Spring Boot 会根据项目中的依赖自动配置 Spring 应用，减少了手动配置的工作量。
独立运行：Spring Boot 应用可以打包成独立的 JAR 文件，包含所有必要的依赖，可以直接运行。
嵌入式服务器：Spring Boot 支持嵌入式服务器，如 Tomcat、Jetty 等，无需部署到外部应用服务器。
监控和管理：Spring Boot 提供了内置的监控和管理功能，如 Actuator，可以方便地监控应用的健康状况和性能。
易于测试：Spring Boot 提供了丰富的测试支持，包括单元测试和集成测试。
灵活配置：支持多种配置方式，包括属性文件、YAML 文件、环境变量等。
社区支持：Spring Boot 拥有庞大的社区和丰富的文档资源。

使用场景：

微服务架构：Spring Boot 是构建微服务的理想选择，可以轻松创建独立、轻量级的服务。
快速原型开发：适用于快速构建和测试应用原型。
传统应用现代化：可以将传统的 Spring 应用迁移到 Spring Boot，以简化配置和部署。
新项目开发：对于新项目，Spring Boot 提供了一个高效、简洁的开发起点。

核心组件：

Spring Boot Starter：一系列预定义的依赖，用于简化项目构建。
Spring Boot Autoconfigure：自动配置 Spring 应用的组件。
Spring Boot Actuator：提供应用监控和管理功能。
Spring Boot CLI：命令行工具，用于快速开发和测试 Spring Boot 应用。
Spring Boot Maven/Gradle Plugins：用于构建和打包 Spring Boot 应用的插件。

Spring Boot 的出现极大地改变了 Java 应用的开发方式，使得开发者可以更专注于业务逻辑而不是繁琐的配置。

Java 中如何创建多线程？

在Java中，创建多线程主要有两种方式：

1. 继承`Thread`类

public class MyThread extends Thread {
    @Override
    public void run() {
        // 在这里编写线程执行的代码
        System.out.println("线程运行中！");
    }
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}

注意：不要直接调用run()方法，这样不会启动新线程，而是直接在当前线程中执行。应该调用start()方法来启动新线程。

2. 实现`Runnable`接口

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 在这里编写线程执行的代码
        System.out.println("线程运行中！");
    }
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start(); // 启动线程
    }
}

优点：实现Runnable接口的方式更加灵活，因为Java不支持多继承，但可以多个接口。因此，这种方式更适合在已经继承了其他类的类中实现多线程。

3. 使用`Callable`和`Future`（Java 5+）

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        // 在这里编写线程执行的代码
        return "线程运行结果";
    }
    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);
    }
}

优点：Callable可以返回结果，并且可以抛出异常。Future可以用来获取Callable的返回结果。

4. 使用线程池（Java 5+）

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5); // 创建固定大小的线程池
        for (int i = 0; i < 10; i++) {
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    System.out.println("线程池中的线程运行中！");
                }
            };
            executorService.execute(runnable); // 提交任务到线程池
        }
        executorService.shutdown(); // 关闭线程池
    }
}

优点：线程池可以有效地管理线程资源，避免频繁地创建和销毁线程。适用于大量短生命周期的异步任务。

总结

继承Thread类和实现Runnable接口是基本的创建多线程的方式。
Callable和Future提供了更强大的功能，如返回结果和异常处理。
线程池适用于需要高效管理大量线程的场景。

选择哪种方式取决于具体的需求和场景。

Redis 中跳表的实现原理是什么？

Redis 中的跳表（Skip List）是一种用于实现有序集合（Sorted Set）的数据结构，它通过多层链表实现高效的查找、插入和删除操作。以下是跳表的实现原理：

基本结构

节点：每个节点包含多个指针，指向不同层的下一个节点。
层数：节点的层数是随机生成的，层数越高，概率越低。

节点结构：
+-------------------+
| 成员 (member)      |
| 分值 (score)       |
| 后退指针 (backward)|
| 层 (level)         |
| 前进指针 (forward) |
+-------------------+

跳表的层级
- 多层链表：跳表由多层链表组成，底层包含所有元素，每层链表都是前一层的子集。
- 随机层数：每个节点的层数是随机生成的，通常使用概率分布（如 1/2 的概率增加一层）。
1
2
3
4
5
跳表示例：
层 3: 1 --------------------------------> 9
层 2: 1 ------------> 5 ------------> 9
层 1: 1 ---> 3 ---> 5 ---> 7 ---> 9
层 0: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
查找操作
- 从高层开始：从最高层开始查找，找到小于目标值的最大节点。
- 逐层下降：在当前层找不到时，下降到下一层继续查找。
- 时间复杂度：O(log n)，n 为元素数量。
1
2
3
4
查找元素 7：
1. 层 3: 1 -> 9 (9 > 7，下降)
2. 层 2: 1 -> 5 -> 9 (5 < 7，继续)
3. 层 1: 5 -> 7 -> 9 (找到 7)

插入操作

查找插入位置：从最高层开始查找插入位置。
随机生成层数：为新节点随机生成层数。
更新指针：在各层链表中插入新节点，更新前后节点的指针。
时间复杂度：O(log n)。

插入元素 6：
1. 查找插入位置：1 -> 3 -> 5 -> 7 -> 9
2. 随机生成层数：假设为 2
3. 更新指针：
   层 2: 1 -> 5 -> 6 -> 9
   层 1: 1 -> 3 -> 5 -> 6 -> 7 -> 9
   层 0: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9

删除操作

查找目标节点：从最高层开始查找目标节点。
更新指针：在各层链表中删除目标节点，更新前后节点的指针。
时间复杂度：O(log n)。

删除元素 5：
1. 查找目标节点：1 -> 3 -> 5 -> 7 -> 9
2. 更新指针：
   层 2: 1 -> 6 -> 9
   层 1: 1 -> 3 -> 6 -> 7 -> 9
   层 0: 1 -> 2 -> 3 -> 4 -> 6 -> 7 -> 8 -> 9

跳表的优点
- 高效查找：平均时间复杂度为 O(log n)，接近平衡二叉树的性能。
- 简单实现：相比平衡二叉树，跳表实现更简单。
- 动态调整：插入和删除操作高效，适合动态数据集合。
跳表的缺点
- 空间开销：多层链表结构增加了空间开销。
- 随机性：层数的随机性可能导致性能波动。

总结

Redis 中的跳表通过多层链表实现高效的有序集合操作，具有 O(log n) 的查找、插入和删除时间复杂度。其简单实现和高效性能使其成为 Redis 有序集合的理想选择。

Redis 性能瓶颈时如何处理？

当面临Redis性能瓶颈时，可以采取多种策略来优化和提升其性能。以下是一些常见的处理方法：

优化数据结构和使用方式
- 选择合适的数据类型：根据应用场景选择合适的Redis数据类型，例如，使用Hash存储对象以减少内存使用。
- 避免大键和大值：大键和大值会增加内存使用和延迟，应尽量分解。
- 合理使用Redis命令：避免使用复杂度高或阻塞的命令，如KEYS、FLUSHDB等。
提升硬件性能
- 增加内存：Redis性能很大程度上受内存大小影响，增加内存可以存储更多数据，减少磁盘IO。
- 使用SSD：相比于HDD，SSD具有更快的读写速度，可以显著提升性能。
- 提升网络带宽：确保网络带宽足够，以支持高吞吐量的数据传输。
优化Redis配置
- 调整内存淘汰策略：根据需求设置合适的内存淘汰策略，如allkeys-lru、volatile-lru等。
- 调整最大连接数：根据客户端数量调整maxclients。
- 开启持久化：根据需求选择RDB或AOF持久化，并调整相关配置，如save间隔、appendfsync策略等。
- 调整线程数：Redis 6.0及以上版本支持多线程，可以调整io-threads和io-threads-do-reads来提升性能。
使用Redis集群
- 分片：通过Redis集群进行数据分片，将数据分布到多个节点上，提升整体性能和容量。
- 读写分离：在集群中使用主从复制，将读操作分散到多个从节点上，减轻主节点压力。
缓存优化
- 缓存预热：提前将热点数据加载到缓存中，避免冷启动问题。
- 缓存失效策略：合理设置缓存过期时间，避免缓存雪崩。
- 缓存穿透防护：使用布隆过滤器等机制防止缓存穿透。
监控和调优
- 使用监控工具：如Redis自带的INFO命令、Redis监控工具（如Redis Insight、Prometheus等）来监控Redis性能指标。
- 慢查询分析：通过SLOWLOG查看慢查询，分析并优化慢命令。
- 性能测试：使用工具如redis-benchmark进行性能测试，找出瓶颈并进行调优。
代码和架构优化
- 减少网络往返：批量操作、pipeline等技术可以减少网络往返次数，提升性能。
- 异步处理：使用异步编程模型来处理Redis操作，避免阻塞主线程。
- 架构优化：如使用缓存层、分布式缓存架构等来进一步提升性能和可靠性。
考虑使用Redis替代品
- 如果Redis无法满足性能需求，可以考虑使用其他高性能缓存系统，如Memcached、Rockset等。

在处理Redis性能瓶颈时，通常需要结合多种策略来进行综合优化。首先进行性能监控和分析，找出瓶颈所在，然后针对性地采取上述措施进行优化。

OSI 七层模型是什么？

OSI（Open Systems Interconnection）七层模型是一个由国际标准化组织（ISO）提出的网络通信模型，它定义了网络通信的七个不同层次，每一层都有特定的功能和协议。这个模型的主要目的是为了促进不同网络设备之间的互操作性，确保不同厂商的设备和软件能够在同一网络中协同工作。以下是OSI七层模型的详细描述：

物理层（Physical Layer）
- 功能：负责传输比特流，即0和1的电信号或光信号，以及物理介质的机械和电气特性。
- 设备：集线器、中继器、电缆、光纤等。
- 示例：以太网（Ethernet）、光纤分布式数据接口（FDDI）。
数据链路层（Data Link Layer）
- 功能：在相邻节点之间提供可靠的数据传输，将比特流组织成数据帧，并进行错误检测和纠正。
- 设备：交换机、网桥等。
- 协议：以太网（Ethernet）、点对点协议（PPP）、高级数据链路控制（HDLC）。
网络层（Network Layer）
- 功能：负责数据包从源到目的地的路由和转发，以及逻辑地址的分配。
- 设备：路由器等。
- 协议：互联网协议（IP）、互联网控制消息协议（ICMP）、地址解析协议（ARP）。
传输层（Transport Layer）
- 功能：提供端到端的通信服务，确保数据可靠、顺序、无错地从源传输到目的地。
- 协议：传输控制协议（TCP）、用户数据报协议（UDP）。
会话层（Session Layer）
- 功能：管理网络中的会话，包括建立、维护和终止会话。
- 示例：远程过程调用（RPC）、安全套接字层（SSL）。
表示层（Presentation Layer）
- 功能：确保数据在网络中传输前后的表示格式一致，包括数据加密、压缩、转换等。
- 示例：加密标准（如SSL/TLS）、图像和视频编码（如JPEG、MPEG）。
应用层（Application Layer）
- 功能：为应用程序提供网络服务，包括电子邮件、文件传输、网络管理等。
- 协议：超文本传输协议（HTTP）、简单邮件传输协议（SMTP）、文件传输协议（FTP）、域名系统（DNS）。

OSI七层模型是一个理论模型，实际上，许多网络协议和实现并没有严格遵循这个模型。例如，TCP/IP模型将OSI模型中的会话层、表示层和应用层合并为应用层，而数据链路层和物理层通常被合并为网络接口层。尽管如此，OSI模型仍然是一个重要的参考框架，用于理解网络通信的复杂性和不同层次的功能。

说说 AQS 吧？

AQS（AbstractQueuedSynchronizer） 是 Java 中用于构建锁和其他同步器的一个抽象类。它提供了一种高效的操作阻塞队列的方法，以实现多线程环境下的同步。
AQS 的核心思想 是，如果一个线程想要执行某个操作，但该操作所需的资源被其他线程持有，那么这个线程就必须进行等待。AQS 就是通过维护一个 FIFO（先进先出）的队列来管理这些等待的线程。

AQS 的主要组成部分：

同步队列（Sync Queue）：这是一个双向链表，用于存储等待获取资源的线程。当线程请求资源失败时，会被封装成节点（Node）加入到这个队列的尾部。
条件队列（Condition Queue）：与同步队列类似，也是一个双向链表。但它用于存储等待某个条件的线程。当线程等待某个条件时，会被加入到条件队列中。

AQS 的主要方法：

acquire(int arg)：独占式获取资源。如果获取成功，则直接返回；如果获取失败，则将当前线程加入到同步队列中等待。
release(int arg)：独占式释放资源。会唤醒同步队列中的第一个线程（如果存在）。
acquireShared(int arg)：共享式获取资源。与独占式获取类似，但允许多个线程同时获取资源。
releaseShared(int arg)：共享式释放资源。会唤醒同步队列中的所有等待线程。
await()：使当前线程等待某个条件。会释放当前线程持有的资源，并将线程加入到条件队列中。
signal()：唤醒条件队列中的第一个线程（如果存在）。
signalAll()：唤醒条件队列中的所有线程。

AQS 的应用：

ReentrantLock：基于 AQS 实现的可重入锁。
ReentrantReadWriteLock：基于 AQS 实现的可重入读写锁。
Semaphore：基于 AQS 实现的信号量。
CountDownLatch：基于 AQS 实现的倒计时门闩。
CyclicBarrier：基于 AQS 实现的循环屏障。

AQS 的优点：

提供了一种通用的框架，可以方便地实现各种同步器。
高效地管理了线程的阻塞和唤醒，减少了线程状态转换的开销。
提供了丰富的同步机制，可以满足各种复杂的同步需求。

总之，AQS 是 Java 中实现多线程同步的重要基础，理解 AQS 的原理和机制对于深入理解 Java 的并发编程至关重要。

Cookie、Session 和 Token 是用于管理用户状态和身份验证的常见机制，它们的主要区别如下：

Cookie
- 定义：Cookie 是服务器发送到用户浏览器并保存在本地的一小段数据，浏览器会在后续请求中自动将其发送回服务器。
- 存储位置：客户端（浏览器）。
- 用途：常用于会话管理、个性化设置、跟踪用户行为等。
- 特点：
  - 可以设置过期时间。
  - 每次请求都会自动发送，可能增加带宽消耗。
  - 安全性较低，容易被窃取或篡改。
Session
- 定义：Session 是服务器端存储的用户会话数据，通常通过唯一的 Session ID 来标识。
- 存储位置：服务器端。
- 用途：用于在服务器端保存用户的状态信息，如登录状态、购物车内容等。
- 特点：
  - Session ID 通常通过 Cookie 传递给客户端。
  - 数据存储在服务器，安全性较高。
  - 服务器需要维护 Session 数据，可能增加内存消耗。
Token
- 定义：Token 是一种用于身份验证的令牌，通常采用 JSON Web Token (JWT) 格式。
- 存储位置：客户端（如浏览器的 LocalStorage 或 Cookie）。
- 用途：用于无状态的身份验证和授权。
- 特点：
  - 自包含，包含用户信息和签名，服务器无需存储。
  - 适合分布式系统和 RESTful API。
  - 安全性较高，但需防止泄露。

主要区别

特性	Cookie	Session	Token
存储位置	客户端	服务器端	客户端
安全性	较低	较高	较高
状态管理	有状态	有状态	无状态
传输方式	自动通过 HTTP 头部发送	通过 Session ID	手动通过 HTTP 头部发送
适用场景	会话管理、个性化	会话管理、用户状态	无状态身份验证、API 授权

总结

Cookie 适合需要在客户端存储少量数据的场景。
Session 适合需要在服务器端管理用户状态的场景。
Token 适合无状态的身份验证和分布式系统。

根据具体需求选择合适的机制。

2025-02-08 该篇文章被 up 打上标签: Java 面试题

为什么 TCP 挥手需要有 TIME_WAIT 状态?

TIME_WAIT状态的影响

解决TIME_WAIT状态的问题

Spring Boot 的核心特性有哪些？

总结

为什么 HashMap 在 Java 中扩容时采用 2 的 n 次方倍？

注意事项

你在项目中使用的 Redis 客户端是什么？

总结

TCP 超时重传机制是为了解决什么问题？

简述 MyBatis 的插件运行原理，以及如何编写一个插件？

数组和链表在 Java 中的区别是什么？

总结

Redis 中常见的数据类型有哪些？

TCP 滑动窗口的作用是什么？

总结

介绍一下 Reactor 线程模型？

总结

Java 线程池核心线程数在运行过程中能修改吗？如何修改？

修改核心线程数

注意事项

示例

TCP/IP 四层模型是什么？

说说 MyBatis 的缓存机制？

一级缓存

二级缓存

缓存的使用场景

注意事项

什么是 Spring Boot？

主要特点：

使用场景：

核心组件：

Java 中如何创建多线程？

1. 继承Thread类

2. 实现Runnable接口

3. 使用Callable和Future（Java 5+）

4. 使用线程池（Java 5+）

总结

Redis 中跳表的实现原理是什么？

总结

Redis 性能瓶颈时如何处理？

OSI 七层模型是什么？

说说 AQS 吧？

Cookie、Session、Token 之间有什么区别？

主要区别

总结

1. 继承`Thread`类

2. 实现`Runnable`接口

3. 使用`Callable`和`Future`（Java 5+）