作为 Java 生态中最主流的开发框架，Spring Boot 3.2 的正式发布带来了诸多令人振奋的更新，其中对 JDK 21 虚拟线程（Virtual Threads）的原生支持 无疑是最值得关注的核心特性之一。虚拟线程彻底重构了 Java 应用的并发模型，让高并发场景下的开发和性能优化变得前所未有的简单。 一、先搞懂：什么是虚拟线程？ 在传统 Java 开发中，我们使用的是 “平台线程（Platform Thread）”—— 它与操作系统内核线程一一映射，创建和销毁成本高、上下文切换开销大，且受限于内核线程数量（通常单机几千个就到瓶颈）。 而虚拟线程是 JVM 层面实现的轻量级线程，由 JVM 管理而非操作系统：🌱 极致轻量：单个 JVM 可创建数百万个虚拟线程，内存占用仅几 KB🚀 超低开销：创建、切换、销毁几乎无性能损耗🎯 无感知迁移：完全兼容现有 Thread API，业务代码无需大幅改造⚡ 自动挂起：遇到 IO 阻塞（如数据库查询、网络请求）时，虚拟线程会自动挂起，释放底层平台线程，避免资源浪费二、Spring Boot 3.2 对虚拟线程的核心支持 Spring Boot 3.2 基于 Spring Framework 6.1 的能力，为虚拟线程提供了 “零侵入式” 集成，主要体现在这几个核心场景： 1. 配置层面：一键启用虚拟线程 无需复杂编码，仅需在application.properties/yaml中添加配置，即可让 Spring 容器的核心线程池切换为虚拟线程：# 全局启用虚拟线程 spring.threads.virtual.enabled=true # Web容器（Tomcat/Undertow）使用虚拟线程处理请求 server.tomcat.threads.virtual.enabled=true2. Web 请求处理：超高并发支撑 传统 Tomcat 容器默认使用平台线程池（默认 200 线程），高并发下易出现线程耗尽；启用虚拟线程后，Tomcat 会为每个 HTTP 请求分配独立的虚拟线程： 单实例可轻松支撑数万 QPS 的请求处理彻底解决 “线程池满导致请求排队 / 拒绝” 问题无需手动调整线程池参数，JVM 自动适配 3. 异步任务：@Async 无缝兼容 原有使用@Async注解的异步任务，只需指定虚拟线程池即可：@Configuration @EnableAsync public class AsyncConfig { // 定义虚拟线程池 @Bean public Executor virtualThreadExecutor() { // Spring提供的虚拟线程构建器 return Executors.newVirtualThreadPerTaskExecutor(); } } // 业务层使用 @Service public class OrderService { // 指定使用虚拟线程池执行异步任务 @Async("virtualThreadExecutor") public CompletableFuture<OrderVO> processOrder(Long orderId) { // 模拟IO密集型操作（数据库/远程调用） return CompletableFuture.supplyAsync(() -> { // 业务逻辑 return orderDao.queryById(orderId); }); } }4. 数据访问层：自动适配对于 JDBC、JPA、Redis 等 IO 密集型操作，Spring Data 会自动利用虚拟线程的特性： 数据库查询等待结果时，虚拟线程自动挂起连接池无需过度扩容，减少资源占用实测：相同数据库连接数下，QPS 提升 3-5 倍三、适用场景 & 性能对比 ✅ 最适合的场景 IO 密集型应用：微服务接口、电商订单系统、消息消费、数据同步高并发短任务：API 网关、秒杀接口、短信 / 邮件发送批量处理任务：数据导出、日志分析、批量入库 📊 性能实测（单机 8 核 16G）场景平台线程虚拟线程提升幅度HTTP 请求处理 QPS2000150007.5 倍异步任务处理耗时800ms120ms6.7 倍最大并发连接数20005000025 倍 四、避坑指南：这些情况不适合用虚拟线程🚫 CPU 密集型任务：虚拟线程无法提升 CPU 密集型任务性能（如大数据计算、加密解密），反而可能增加调度开销🚫 长时间阻塞的本地代码：如死循环、本地耗时计算，会占用平台线程导致无法释放🚫 依赖 ThreadLocal 的代码：虚拟线程切换时 ThreadLocal 会失效，需改用 InheritableThreadLocal🚫 旧版原生库：依赖 JNI 的本地库可能不兼容虚拟线程五、升级建议基础环境：升级 JDK 至 21（LTS 版本），Spring Boot 3.2 最低要求 JDK 17平滑迁移：先在非核心链路启用虚拟线程，观察监控指标（线程数、CPU、内存）监控适配：使用 Spring Boot Actuator 监控虚拟线程状态，需升级 Micrometer 至 1.12+代码改造：移除手动创建的线程池，优先使用 Spring 提供的Executors.newVirtualThreadPerTaskExecutor() 

在大模型席卷全球的技术浪潮下，Java 开发者们迫切需要一款贴合自身生态、低门槛接入 AI 能力的框架。Spring AI 的出现，恰好填补了这一空白 —— 它并非简单移植 Python 生态的现有方案，而是深度遵循 Spring 设计哲学，为 Java 和 Spring 开发者打造了原生的 AI 开发框架。本文将从 Spring AI 的核心概念、核心特性出发，结合实际环境搭建与首个对话案例，带大家快速上手这款框架，解锁 Java 生态与 AI 融合的全新可能。一、什么是 Spring AI？Spring AI 是面向 Java 和 Spring 生态的原生人工智能框架，其核心设计理念完全传承自 Spring：依赖注入、POJO 编程、模块化架构与可配置性。它重构了 AI 应用的全开发流程，让开发者无需关注底层模型的适配细节，就能像调用数据库、Web API 一样轻松集成聊天、文本嵌入、图像生成、语音处理等 AI 能力。更重要的是，Spring AI 完美解决了多 AI 供应商适配的痛点 —— 通过 “一套接口，多种实现” 的统一抽象，开发者可以无缝切换 OpenAI、Anthropic、Bedrock、Hugging Face、Vertex AI、Ollama 等主流 AI 服务，无需修改核心业务代码。同时，它还支持企业内部数据与 AI 模型的快速关联，这正是检索增强生成（RAG）等高级场景的核心需求。官网地址官网地址：https://spring.io/projects/spring-ai官方文档：https://docs.spring.io/spring-ai/reference/index.html中文文档：https://spring-ai.spring-doc.cn/docs/1.0.0/index.html二、Spring AI 核心特性：为什么值得选？Spring AI 覆盖了 AI 应用开发的全流程，其核心特性可以总结为以下 7 点，每一点都精准命中开发者的实际需求：1. 全栈多供应商模型适配，覆盖主流 AI 能力深度对接Anthropic、OpenAI等主流服务商，覆盖聊天交互、文本嵌入、多模态生成、语音交互、内容安全等核心能力。聊天交互（文本对话、多轮上下文对话）文本嵌入（语义向量转换，支撑语义搜索）多模态生成（文生图、图生文）语音交互（音频转录/语音转文字、文本转语音）内容安全（敏感信息检测与审核）所有模型统一接口封装，切换模型无需修改业务代码，提升项目灵活性与可扩展性。2. 标准化抽象 API，统一调用体验Spring AI 提供了 ChatClient、EmbeddingModel、ImageModel 等标准化接口，开发者无需关心底层模型的差异。支持同步/流式调用及模型高级功能（如OpenAI Function Calling），聚焦业务逻辑，提升开发效率。3. 原生集成 Spring Boot，开箱即用遵循Spring Boot设计理念，通过Starter依赖与自动装配实现AI组件一键集成，Spring Initializr可快速生成项目骨架，开箱即用，贴合Java开发者习惯。4. 结构化输出与类型安全，降低维护成本支持将AI非结构化响应自动解析映射到Java POJO，保障类型安全，避免繁琐的字符串解析与类型转换，降低维护成本。5. 内置向量存储与 RAG 支持，激活私有知识库Spring AI 集成了 PostgreSQL/pgvector、Pinecone、Qdrant、Redis、Weaviate 等主流向量数据库，提供元数据过滤、相似度检索能力；同时内置ETL流程，可快速搭建RAG系统，解决大模型“知识过期”“不懂私有数据”痛点。6. 工具调用能力，打通业务系统闭环原生支持模型驱动的工具调用，可将Spring Bean注册为AI可调用工具，实现AI自动调用业务接口、查询数据库等操作，例如：调用天气 API 获取实时气象数据查询企业 CRM 系统获取客户详情执行业务数据统计与分析操作实现AI与业务流程深度融合，让AI从“对话工具”升级为“业务智能入口”，打通需求到执行的全闭环。三、快速上手：环境准备与 Deepseek 对话案例理论再多不如实际动手，下面我们将通过一个完整的案例，教大家搭建 Spring AI 环境，并实现与 Deepseek 模型的对话交互。3.1 环境要求Spring AI 构建在 Spring Boot 3.x 之上，对环境有明确要求：JDK：必须为 17 及以上版本（不支持 Java 8/11/16）Maven：3.6 及以上版本Spring Boot：3.x 系列（本文使用 3.5.0 版本）JDK 17 安装步骤下载地址：https://www.oracle.com/cn/java/technologies/downloads/#java17安装路径建议：D:\Program Files\Java\jdk17\jdk（可自定义）安装成功后，配置环境变量，也可以在 Spring Boot 项目中指定 JDK 版本。3.2 创建 Spring Boot 项目Step 1：访问 Spring Initializr：https://start.spring.io/，或在 IDEA 中直接创建 New Module。项目配置如下：Name：Weiz-SpringAI-QuickStartGroup：com.exampleArtifact：Weiz-SpringAI-QuickStartPackage name：com.example.weizspringaiLanguage：JavaJDK：17Spring Boot：3.5.3Packaging：JarStep 2：Spring Boot版本选择3.5.x，依赖选择：仅需添加「Spring Web」依赖（后续通过 Maven 引入 Spring AI 相关依赖）。创建完成后的项目结构如下：Weiz-SpringAI-QuickStart/ ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ └── com/ │ │ │ └── example/ │ │ │ └── weizspringai/ │ │ │ └── WeizSpringAiQuickStartApplication.java │ │ └── resources/ │ │ └── application.properties │ └── test/ └── pom.xmlStep 3：配置 pom.xml 依赖在 pom.xml 中添加 Spring AI 相关依赖，核心是导入 Spring AI BOM 统一管理版本，并引入 Deepseek 模型 starter：<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.example</groupId> <artifactId>Weiz-SpringAI</artifactId> <version>0.0.1-SNAPSHOT</version> </parent> <artifactId>Weiz-SpringAI-QuickStart</artifactId> <name>Weiz-SpringAI-QuickStart</name> <description>Weiz-SpringAI-QuickStart</description> <properties> <java.version>17</java.version> <maven.compiler.source>17</maven.compiler.source> <maven.compiler.target>17</maven.compiler.target> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-starter-model-deepseek</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>Step 4：配置 application.properties在 src/main/resources/application.properties 中配置 Deepseek 模型的基础信息：spring.application.name=Weiz-SpringAI-QuickStart server.port=8080 # Deepseek URL spring.ai.deepseek.base-url=https://api.deepseek.com spring.ai.deepseek.api-key=你的Deepseek appkey spring.ai.deepseek.chat.options.model=deepseek-chat 注意：Deepseek API 密钥需要在 Deepseek 官网注册获取，替换配置中的占位符。Step 5：编写 ChatController创建 com.example.weizspringai.controller 包，并编写 ChatController 类，实现与 Deepseek 模型的交互：import org.springframework.ai.deepseek.DeepSeekChatModel; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController; @RestController @RequestMapping("/ai") public class ChatController { @Autowired private DeepSeekChatModel chatModel; @PostMapping("/chat") public ChatResponse chat(@RequestBody ChatRequest chatRequest){ String resp = chatModel.call(chatRequest.getMessage()); return new ChatResponse(resp); } }Step 6：启动并测试运行 WeizSpringAiEmbeddingApplication.java 启动项目。浏览器访问：http://localhost:8080/ai/chat?message=你是谁，即可看到模型响应：你好！我是DeepSeek，由深度求索公司创造的AI助手！😊 我是一个纯文本模型，虽然不支持多模态识别功能，但我有文件上传功能，可以帮你处理图像、txt、pdf、ppt、word、excel等文件，并从中读取文字信息进行分析处理。我完全免费使用，拥有128K的上下文长度，还支持联网搜索（需要你在Web/App中手动点开联网搜索按键）。 你可以通过官方应用商店下载我的App来使用。我很乐意帮助你解答问题、处理文档、进行对话交流等等！ 有什么我可以帮你的吗？无论是学习、工作还是日常生活中的问题，我都很愿意协助你！✨四、实战进阶：流式响应与可视化界面优化前面使用SpringAI 快速整合DeepSeek，实现了与大模型对话的功能，但是，这个项目存在两个不足：1. 无可视化交互界面；2. AI 响应为一次性返回，缺乏实时感。下面对项目进行优化升级。Step 1：实现流式返回接口在ChatController 中，创建新接口/ai/chatStream接口。@PostMapping("/chatStream") public SseEmitter chatStream(@RequestBody ChatRequest chatRequest) { SseEmitter emitter = new SseEmitter(Long.MAX_VALUE); Flux<String> stream = chatModel.stream(chatRequest.getMessage()); stream.subscribe( chunk -> { try { ChatResponse chatResponse = new ChatResponse(); chatResponse.setResponse(chunk); chatResponse.setCode(200); chatResponse.setMessage("streaming"); String json = objectMapper.writeValueAsString(chatResponse); emitter.send(SseEmitter.event() .data(json) .build()); } catch (IOException e) { emitter.completeWithError(e); } }, error -> { emitter.completeWithError(error); }, () -> { emitter.complete(); } ); return emitter; }Step 2：创建可视化聊天界面为了更直观地与模型交互，我们可以在 src/main/resources/static 目录下创建 index.html，实现简单的聊天界面：<!DOCTYPE html> <html lang="zh-CN"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>AI 聊天助手（流式响应）</title> <style> * { margin: 0; padding: 0; box-sizing: border-box; } body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); height: 100vh; display: flex; justify-content: center; align-items: center; } .chat-container { width: 800px; height: 600px; background: white; border-radius: 16px; box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3); display: flex; flex-direction: column; overflow: hidden; } .chat-header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); padding: 20px; color: white; } .chat-header h1 { font-size: 24px; font-weight: 600; } .chat-header p { font-size: 14px; opacity: 0.9; margin-top: 5px; } .chat-messages { flex: 1; padding: 20px; overflow-y: auto; background: #f5f5f5; } .message { margin-bottom: 16px; display: flex; align-items: flex-start; } .message.user { justify-content: flex-end; } .message.assistant { justify-content: flex-start; } .message-content { max-width: 70%; padding: 12px 16px; border-radius: 12px; line-height: 1.5; word-wrap: break-word; } .message.user .message-content { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border-bottom-right-radius: 4px; } .message.assistant .message-content { background: white; color: #333; border-bottom-left-radius: 4px; box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1); } .chat-input-container { padding: 20px; background: white; border-top: 1px solid #e0e0e0; } .chat-input-form { display: flex; gap: 12px; } #messageInput { flex: 1; padding: 12px 16px; border: 2px solid #e0e0e0; border-radius: 24px; font-size: 16px; outline: none; transition: border-color 0.3s; } #messageInput:focus { border-color: #667eea; } #sendButton { padding: 12px 32px; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; border: none; border-radius: 24px; font-size: 16px; font-weight: 600; cursor: pointer; transition: transform 0.2s, box-shadow 0.2s; } #sendButton:hover { transform: translateY(-2px); box-shadow: 0 4px 12px rgba(102, 126, 234, 0.4); } #sendButton:active { transform: translateY(0); } #sendButton:disabled { background: #ccc; cursor: not-allowed; transform: none; } .typing { display: inline-block; padding: 8px 12px; } .typing::after { content: '...'; animation: typing 1.5s steps(4, end) infinite; } @keyframes typing { 0%, 100% { content: ''; } 25% { content: '.'; } 50% { content: '..'; } 75% { content: '...'; } } .welcome-message { text-align: center; color: #666; padding: 40px 20px; } .welcome-message h2 { font-size: 20px; margin-bottom: 10px; color: #333; } .welcome-message p { font-size: 14px; } </style> </head> <body> <div class="chat-container"> <div class="chat-header"> <h1>AI 聊天助手</h1> <p>基于 Spring AI 和 DeepSeek 的智能对话系统（流式响应）</p> </div> <div class="chat-messages" id="chatMessages"> <div class="welcome-message"> <h2>欢迎使用 AI 聊天助手！</h2> <p>请在下方输入您的问题，我会尽力为您解答。</p> </div> </div> <div class="chat-input-container"> <form class="chat-input-form" id="chatForm"> <input type="text" id="messageInput" placeholder="输入您的问题..." autocomplete="off" required> <button type="submit" id="sendButton">发送</button> </form> </div> </div> <script> const chatMessages = document.getElementById('chatMessages'); const chatForm = document.getElementById('chatForm'); const messageInput = document.getElementById('messageInput'); const sendButton = document.getElementById('sendButton'); const welcomeMessage = document.querySelector('.welcome-message'); // 移除欢迎消息 function removeWelcomeMessage() { if (welcomeMessage) { welcomeMessage.remove(); } } // 添加消息到聊天界面 function addMessage(content, isUser = false) { removeWelcomeMessage(); const messageDiv = document.createElement('div'); messageDiv.className = `message ${isUser ? 'user' : 'assistant'}`; const messageContent = document.createElement('div'); messageContent.className = 'message-content'; messageContent.textContent = content; messageDiv.appendChild(messageContent); chatMessages.appendChild(messageDiv); // 滚动到底部 chatMessages.scrollTop = chatMessages.scrollHeight; } // 添加加载消息 function addLoadingMessage() { removeWelcomeMessage(); const messageDiv = document.createElement('div'); messageDiv.className = 'message assistant'; messageDiv.id = 'loadingMessage'; const messageContent = document.createElement('div'); messageContent.className = 'message-content typing'; messageContent.textContent = 'AI 正在思考'; messageDiv.appendChild(messageContent); chatMessages.appendChild(messageDiv); chatMessages.scrollTop = chatMessages.scrollHeight; } // 移除加载消息 function removeLoadingMessage() { const loadingMessage = document.getElementById('loadingMessage'); if (loadingMessage) { loadingMessage.remove(); } } // 发送消息（流式响应） async function sendMessage(message) { addMessage(message, true); addLoadingMessage(); sendButton.disabled = true; messageInput.disabled = true; try { const response = await fetch('/ai/chatStream', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ message: message }) }); if (!response.ok) { throw new Error('网络请求失败'); } removeLoadingMessage(); // 创建一个新的消息容器用于显示流式响应 const messageDiv = document.createElement('div'); messageDiv.className = 'message assistant'; messageDiv.id = 'currentStreamMessage'; const messageContent = document.createElement('div'); messageContent.className = 'message-content'; messageContent.textContent = ''; messageDiv.appendChild(messageContent); chatMessages.appendChild(messageDiv); chatMessages.scrollTop = chatMessages.scrollHeight; // 处理流式响应 const reader = response.body.getReader(); const decoder = new TextDecoder(); let fullText = ''; while (true) { const { done, value } = await reader.read(); if (done) break; // 解码并解析数据 const chunk = decoder.decode(value, { stream: true }); // 尝试解析 JSON 行 const lines = chunk.split('\n').filter(line => line.trim()); for (const line of lines) { try { // 移除可能的数据前缀（如 "data:"） const cleanLine = line.replace(/^data:\s*/, '').trim(); if (!cleanLine) continue; const jsonStr = cleanLine.replace(/,$/, '').trim(); const data = JSON.parse(jsonStr); if (data.response) { fullText += data.response; messageContent.textContent = fullText; chatMessages.scrollTop = chatMessages.scrollHeight; } else if (data.reply) { fullText += data.reply; messageContent.textContent = fullText; chatMessages.scrollTop = chatMessages.scrollHeight; } } catch (e) { console.warn('解析 JSON 失败:', e, line); // 如果解析失败，尝试直接显示文本 if (chunk.trim()) { fullText += chunk; messageContent.textContent = fullText; chatMessages.scrollTop = chatMessages.scrollHeight; } } } } // 移除当前消息的 ID 标记 if (messageDiv) { messageDiv.removeAttribute('id'); } } catch (error) { removeLoadingMessage(); addMessage('抱歉，发生了错误：' + error.message, false); } finally { sendButton.disabled = false; messageInput.disabled = false; messageInput.focus(); } } // 表单提交 chatForm.addEventListener('submit', async (e) => { e.preventDefault(); const message = messageInput.value.trim(); if (!message) return; messageInput.value = ''; await sendMessage(message); }); // 页面加载时聚焦输入框 messageInput.focus(); </script> </body> </html>Step 3：启动并测试重启项目后，访问 http://localhost:8080，即可通过可视化界面与 AI 聊天，例如输入 “你好”，模型会流式返回。总结本文我们从 Spring AI 的核心概念出发，详细介绍了它的 7 大核心特性，并通过一个完整的 Deepseek 对话案例，带大家完成了环境搭建、依赖配置、代码编写与测试的全流程。Spring AI 的核心优势在于 “原生集成 Spring 生态” 与 “统一抽象接口”，让 Java 开发者无需跨生态就能快速接入 AI 能力，极大降低了 AI 应用的开发门槛。版权声明：本文为CSDN博主「小马不敲代码」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/weixin_46619605/article/details/157511534

1. 按照任务类型对线程池进行分类在讨论线程数之前，首先需要明确一点：线程数的配置和任务类型是强相关的。 使用标准构造器 ThreadPoolExecutor 创建线程池时，会涉及线程数的配置，而线程数的配置与异步任务类型是分不开的。这里将线程池的异步任务大致分为以下三类：IO 密集型任务此类任务主要是执行 IO 操作。由于执行 IO 操作的时间较长，导致 CPU 的利用率不高，这类任务 CPU 常处于空闲状态。Netty 的 IO 读写操作为此类任务的典型例子。CPU 密集型任务此类任务主要是执行计算任务。由于响应时间很快，CPU 一直在运行，这种任务 CPU 的利用率很高。混合型任务此类任务既要执行逻辑计算，又要进行 IO 操作（如 RPC 调用、数据库访问）。相对来说，由于执行 IO 操作的耗时较长（一次网络往返往往在数百毫秒级别），这类任务的 CPU 利用率也不是太高。Web 服务器的 HTTP 请求处理操作为此类任务的典型例子。一般情况下，针对以上不同类型的异步任务需要创建不同类型的线程池，并进行针对性的参数配置。2. 为 IO 密集型任务确定线程数由于 IO 密集型任务的 CPU 使用率较低，导致线程空余时间很多，因此通常需要开 CPU 核心数两倍的线程。当 IO 线程空闲时，可以启用其他线程继续使用 CPU，以提高 CPU 的使用率。接下来为 IO 密集型任务创建了一个简单的参考线程池，具体代码如下：12345678910111213141516171819202122232425import java.util.concurrent.LinkedBlockingQueue;import java.util.concurrent.ThreadPoolExecutor;import java.util.concurrent.TimeUnit; public class ThreadUtil {     private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();     private static final int THREAD_COUNT = Math.max(2, CPU_COUNT);         private static final int QUEUE_COUNT = 128;         private static final int KEEP_ALIVE_SECONDS = 30;         private static class ThreadPoolExecutorDemo{        private static final ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(                THREAD_COUNT,                THREAD_COUNT,                KEEP_ALIVE_SECONDS,                TimeUnit.SECONDS,                new LinkedBlockingQueue<>(QUEUE_COUNT),                new ThreadPoolExecutor.AbortPolicy()        );    }}3. 为 CPU 密集型任务确定线程数CPU 密集型任务也叫计算密集型任务，其特点是要进行大量计算而需要消耗 CPU 资源，比如计算圆周率、对视频进行高清解码等。CPU 密集型任务虽然也可以并行完成，但是并行的任务越多，花在任务切换的时间就越多 CPU 执行任务的效率就越低，所以要最高效地利用 CPU，CPU 密集型任务并行执行的数量应当等于 CPU 的核心数。比如说 4 个核心的 CPU，通过 4 个线程并行执行 4 个 CPU 密集型任务，此时的效率是最高的。但是如果线程数远远超出 CPU 核心数量，就需要频繁地切换线程，线程上下文切换时需要消耗时间，反而会使得任务效率下降。因此，对于 CPU 密集型的任务来说，线程数等于 CPU 数就行。接下来为 CPU 密集型任务创建了一个简单的参考线程池，具体代码如下：1234567891011121314151617181920212223import java.util.concurrent.*; public class ThreadUtil {     private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();     private static final int THREAD_COUNT = CPU_COUNT;     private static final int QUEUE_COUNT = 128;     private static final int KEEP_ALIVE_SECONDS = 30;     private static class ThreadPoolExecutorDemo{        private static final ThreadPoolExecutor EXECUTOR = new ThreadPoolExecutor(                THREAD_COUNT,                THREAD_COUNT,                KEEP_ALIVE_SECONDS,                TimeUnit.SECONDS,                new LinkedBlockingQueue<>(QUEUE_COUNT),                new ThreadPoolExecutor.AbortPolicy()        );    }}4. 为混合型任务确定线程数混合型任务既要执行逻辑计算，又要进行大量非CPU 耗时操作（如 RPC 调用、数据库访问、网络通信等），所以混合型任务 CPU 利用率不是太高，非 CPU 耗时往往是 CPU 耗时的数倍。比如在 Web 应用处理 HTTP 请求处理时，一次请求处理会包括 DB 操作、RPC 操作、缓存操作等多种耗时操作。一般来说，一次 Web 请求的 CPU 计算耗时往往较少，大致在 100 - 500 毫秒，而其他耗时操作会占用 500 - 1000 毫秒，甚至更多的时间。在为混合型任务创建线程池时，如何确定线程数呢？在工程实践中，通常会通过 线程等待时间和 CPU 计算时间的比例 来估算线程数，常见的计算思路如下：最佳线程数 = （（线程等待时间+线程CPU时间）/线程CPU时间 ）* CPU核数经过简单的换算，以上公式可进一步转换为：最佳线程数目 =（线程等待时间与线程CPU时间之比 + 1）* CPU核数通过公式可以看出：等待时间所占比例越高，需要的线程就越多；CPU 耗时所占比例越高，需要的线程就越少。下面举一个例子：比如在 Web 服务器处理 HTTP 请求时，假设平均线程 CPU 运行时间为 100 毫秒，而线程等待时间（比如包括 DB 操作、RPC操作、缓存操作等）为 900 毫秒，如果 CPU 核数为 8，那么根据上面这个公式，估算如下：（900ms+100ms）/100ms8= 108 = 8经过计算，以上案例中需要的线程数为 80。很多人认为，线程数越高越好。那么，使用很多线程是否就一定比单线程高效呢？答案是否定的，比如大名鼎鼎的 Redis 就是单线程的，但它却非常高效，基本操作都能达到十万量级/秒。由于 Redis 基本都是内存操作，在这种情况下单线程可以高效地利用 CPU，多线程反而不是太适用。多线程适用场景一般是：存在相当比例非 CPU 耗时操作，如 IO、网络操作，需要尽量提高并行化比率以提升 CPU 的利用率。总体来说，线程池线程数并不存在一个放之四海而皆准的固定值。不同类型的任务，其 CPU 使用情况和等待时间差异很大，直接决定了线程数配置的侧重点。对于 IO 密集型、CPU 密集型以及混合型任务，本文给出的配置思路和估算公式可以作为一个起点，但在真实的生产环境中，仍然需要结合具体的业务特性、硬件条件以及压测结果进行不断调整。实际上，线程池真正“难”的地方，往往不止是线程数本身，还包括队列大小、拒绝策略以及运行时的监控和调优。这些问题在复杂系统中同样容易被忽视，后续也值得单独展开讨论。

最近使用分布式锁比较多，发现大家使用分布式锁，都各有各的用法，想着用搞一个加锁模板，方便大家使用，就选择声明一个函数式接口，去实现加锁的模板函数式接口是一种特殊的接口，只包含一个抽象方法。函数式接口的目的是为了支持函数式编程，使开发者能够以更简洁的方式定义单一抽象方法的接口，从而可以使用Lambda表达式来实现这个接口的抽象方法。可以通过lambda表达式进行传递，简单理解就是java8对函数式编程的一种支持实战我们一般加锁是这样，尝试获取锁，失败则抛异常，成功则执行业务代码，每次都要写一大段逻辑1234567891011121314151617181920RLock lock = redissonClient.getLock(lockKey);       try {           if (!lock.tryLock(waitTime, leaseTime, unit)) {               throw new CommonException(ErrorCodeEnum.TRY_LOCK_ERROR).detailMessage("操作频繁,请稍后再试!");           }           。。。。业务代码       }catch (CommonException commonException) {       } catch (Exception e) {           log.error("LockTemplate >>  获取锁异常",e);       } finally {           try {               // 锁不为空  是否还是锁定状态  当前执行线程的锁               if (lock != null && lock.isLocked() && lock.isHeldByCurrentThread()) {                   lock.unlock();               }           } catch (Exception e) {               log.error("LockTemplate >>  获取锁异常",e);           }       }   }所以可以采用函数是接口，定义一套加锁模板，开发者就可以只关注业务代码，而不用去写一大段加锁逻辑，123456789101112131415161718192021222324252627282930313233343536373839404142434445package com.dept.common.template; import cn.hutool.core.util.StrUtil;import com.dept.common.enums.ErrorCodeEnum;import com.dept.common.exception.CommonException;import lombok.AllArgsConstructor;import lombok.extern.slf4j.Slf4j;import org.redisson.api.RLock;import org.redisson.api.RedissonClient;import org.springframework.stereotype.Service; import java.util.concurrent.TimeUnit; @Service@AllArgsConstructor@Slf4jpublic class LockTemplate {     private RedissonClient redissonClient;    public void templateLock(String prefix,String key,Runnable target,long waitTime, long leaseTime, TimeUnit unit) {        String lockKey = StrUtil.format(prefix,key);        // 判断是否正在使用        RLock lock = redissonClient.getLock(lockKey);        try {            if (!lock.tryLock(waitTime, leaseTime, unit)) {                throw new CommonException(ErrorCodeEnum.TRY_LOCK_ERROR).detailMessage("操作频繁,请稍后再试!");            }            // 执行业务代码            target.run();        }catch (CommonException e){            throw e;        } catch (Exception e) {            log.error("LockTemplate >>  获取锁异常",e);        } finally {            try {                // 锁不为空  是否还是锁定状态  当前执行线程的锁                if (lock != null && lock.isLocked() && lock.isHeldByCurrentThread()) {                    lock.unlock();                }            } catch (Exception e) {                log.error("LockTemplate >>  获取锁异常",e);            }        }    }}重点就是将Runnable做为入参，Runnable是一个函数式接口，所以我们可以直接传入业务实现，当然我们也可以自己定义一个函数式接口123lockTemplate.templateLock(SystemConstants.STAR_TASK_MINA_ORDER_LOCK, order.getOrderSn(), () -> {         。。。业务实现      }, RedisConstants.ONE_SECOND, RedisConstants.TEN_SECOND, TimeUnit.MINUTES);这样我们就可以不用去关注加锁逻辑，只需要写自己的业务代码接口总结通过函数式接口，我们可以定义很多模板代码，让开发者只需要传入对应的业务实现即可，TransactionTemplate的execute的方法也是类似的实现

Java判断时间间隔是否超限的方法？

Redis是一款高性能的内存数据库，支持字符串、哈希、列表、集合等多种数据结构，广泛应用于缓存、分布式锁、消息队列等场景。本文基于Spring Boot框架，集成Redis，实现缓存管理（查询缓存、缓存更新、缓存失效）和分布式锁两大核心功能，结合实际业务场景编写完整代码，详解Redis在Java项目中的落地应用。一、环境准备与依赖配置1. 开发环境JDK 1.8、Spring Boot 2.7.x、Redis 6.2.x、Spring Data Redis 2.7.x、Maven 3.6.x、IDEA2. Maven依赖配置在pom.xml中引入Spring Boot Redis依赖、Spring Boot Web依赖等： &lt;dependencies&gt; <!-- Spring Boot Web --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web&lt;/artifactId&gt; &lt;/dependency&gt; <!-- Spring Data Redis（Spring Boot集成Redis的核心依赖） --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis&lt;/artifactId&gt; &lt;/dependency&gt; <!-- Redis客户端（默认使用Lettuce，可替换为Jedis） --> <dependency> <groupId>io.lettuce</groupId> <artifactId>lettuce-core</artifactId&gt; &lt;/dependency&gt; <!-- Lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency><!-- Spring Boot Test --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> 3. 配置文件设置在application.yml中配置Redis连接信息（主机、端口、密码、数据库索引）、缓存配置、Lettuce客户端配置等： spring: # Redis配置 redis: host: localhost # Redis服务器地址 port: 6379 # Redis端口 password: 123456 # Redis密码（若未设置则省略） database: 0 # 连接的数据库索引（默认0） timeout: 3000ms # 连接超时时间 # Lettuce客户端配置（连接池） lettuce: pool: max-active: 8 # 连接池最大活跃连接数 max-idle: 8 # 连接池最大空闲连接数 min-idle: 2 # 连接池最小空闲连接数 max-wait: -1ms # 连接池最大阻塞等待时间（-1表示无限制） # 缓存配置（使用Redis作为缓存管理器） cache: type: redis # 缓存类型为Redis redis: time-to-live: 3600000ms # 缓存默认过期时间（1小时） cache-null-values: false # 是否缓存null值（避免缓存穿透，根据业务需求设置） key-prefix: "cache:" # 缓存key前缀 4. Redis配置类创建RedisConfig类，配置RedisTemplate（自定义序列化方式，避免key和value序列化乱码）、缓存管理器等： import org.springframework.cache.annotation.EnableCaching; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.cache.RedisCacheConfiguration; import org.springframework.data.redis.cache.RedisCacheManager; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer; import org.springframework.data.redis.serializer.RedisSerializationContext; import org.springframework.data.redis.serializer.StringRedisSerializer; import java.time.Duration; @Configuration @EnableCaching // 开启缓存注解支持 public class RedisConfig { // 配置RedisTemplate，自定义序列化方式 @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>(); redisTemplate.setConnectionFactory(redisConnectionFactory); // 设置key序列化器（String序列化，避免key乱码） StringRedisSerializer stringRedisSerializer = new StringRedisSerializer(); redisTemplate.setKeySerializer(stringRedisSerializer); redisTemplate.setHashKeySerializer(stringRedisSerializer); // 设置value序列化器（JSON序列化，支持对象序列化） GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer(); redisTemplate.setValueSerializer(jsonRedisSerializer); redisTemplate.setHashValueSerializer(jsonRedisSerializer); // 初始化RedisTemplate redisTemplate.afterPropertiesSet(); return redisTemplate; } // 配置缓存管理器，自定义缓存配置 @Bean public RedisCacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) { // 基础缓存配置（默认过期时间1小时） RedisCacheConfiguration defaultCacheConfig = RedisCacheConfiguration.defaultCacheConfig() .entryTtl(Duration.ofHours(1)) // 缓存过期时间 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer())) .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer())) .disableCachingNullValues(); // 不缓存null值 // 创建缓存管理器 RedisCacheManager cacheManager = RedisCacheManager.builder(redisConnectionFactory) .cacheDefaults(defaultCacheConfig) // 可为不同缓存设置不同过期时间（如user缓存过期时间30分钟） .withCacheConfiguration("user", RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.of 

IO流是Java核心基础知识点，用于处理文件、网络数据等输入输出操作，在实际开发中应用广泛（如文件上传下载、日志读写、数据导入导出等）。本文将围绕文件上传、文件下载、批量读取文件内容三个核心场景，结合Spring Boot框架，实现完整的IO流实战案例，包含详细代码与场景说明，帮助开发者快速掌握IO流的实际应用。一、IO流核心概念梳理Java IO流按操作方向分为输入流（InputStream/Reader）和输出流（OutputStream/Writer），按操作数据类型分为字节流（InputStream/OutputStream）和字符流（Reader/Writer）：1. 字节流：以字节为单位处理数据，适用于所有文件类型（如图片、视频、文档等），核心类包括FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream；2. 字符流：以字符为单位处理数据，适用于文本文件（如txt、java文件等），核心类包括FileReader、FileWriter、BufferedReader、BufferedWriter；3. 缓冲流：基于基础流封装，增加缓冲区功能，减少IO操作次数，提升读写效率（如BufferedInputStream比FileInputStream读写速度更快）。实际开发中，推荐使用缓冲流结合try-with-resources语法（自动关闭流资源，避免资源泄漏），简化代码并提升安全性。二、实战场景一：文件上传（单文件+多文件）文件上传是Web开发常见场景，本文基于Spring Boot+IO流实现单文件和多文件上传功能，限制文件大小和类型，将上传文件保存到本地指定目录。1. 配置文件设置在application.yml中配置文件上传相关参数（上传文件保存路径、最大文件大小、请求大小）： spring: servlet: multipart: max-file-size: 10MB # 单个文件最大大小 max-request-size: 50MB # 单次请求最大文件大小 # 自定义文件上传路径（Windows系统可改为D:/upload/files） file: upload: path: /Users/xxx/upload/files/ 2. 工具类：文件上传工具创建FileUploadUtils类，封装文件上传核心逻辑（校验文件类型、生成唯一文件名、写入文件到本地）： import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; import org.springframework.web.multipart.MultipartFile; import java.io.*; import java.util.UUID; @Component public class FileUploadUtils { // 注入文件上传保存路径 @Value("${file.upload.path}") private String uploadPath; // 允许上传的文件类型（后缀名） private static final String[] ALLOWED_EXTENSIONS = {"jpg", "jpeg", "png", "gif", "txt", "doc", "docx", "pdf"}; // 校验文件类型是否合法 private boolean isAllowedExtension(String originalFilename) { if (originalFilename == null || originalFilename.isEmpty()) { return false; } // 获取文件后缀名 String extension = getFileExtension(originalFilename); for (String allowedExtension : ALLOWED_EXTENSIONS) { if (allowedExtension.equalsIgnoreCase(extension)) { return true; } } return false; } // 获取文件后缀名 private String getFileExtension(String originalFilename) { int lastIndexOfDot = originalFilename.lastIndexOf("."); if (lastIndexOfDot == -1) { return ""; } return originalFilename.substring(lastIndexOfDot + 1); } // 生成唯一文件名（避免文件名重复覆盖） private String generateUniqueFilename(String originalFilename) { String extension = getFileExtension(originalFilename); return UUID.randomUUID().toString() + "." + extension; } // 单文件上传 public String uploadFile(MultipartFile file) throws IOException { // 校验文件是否为空 if (file.isEmpty()) { throw new IOException("上传文件不能为空"); } // 校验文件类型 String originalFilename = file.getOriginalFilename(); if (!isAllowedExtension(originalFilename)) { throw new IOException("不允许上传该类型文件，允许的类型：" + String.join(",", ALLOWED_EXTENSIONS)); } // 生成唯一文件名 String uniqueFilename = generateUniqueFilename(originalFilename); // 创建上传目录（若目录不存在则创建） File uploadDir = new File(uploadPath); if (!uploadDir.exists()) { boolean mkdirs = uploadDir.mkdirs(); if (!mkdirs) { throw new IOException("创建上传目录失败"); } } // 拼接文件完整路径 String filePath = uploadPath + File.separator + uniqueFilename; // 使用IO流将文件写入本地（try-with-resources自动关闭流） try (InputStream inputStream = file.getInputStream(); OutputStream outputStream = new FileOutputStream(filePath); BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream); BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream)) { byte[] buffer = new byte[1024 * 8]; // 8KB缓冲区 int len; while ((len = bufferedInputStream.read(buffer)) != -1) { bufferedOutputStream.write(buffer, 0, len); } // 刷新缓冲区，确保数据全部写入 bufferedOutputStream.flush(); } // 返回文件保存路径（可存储到数据库，用于后续下载） return filePath; } // 多文件上传（批量上传） public String[] uploadFiles(MultipartFile[] files) throws IOException { if (files == null || files.length == 0) { throw new IOException("上传文件不能为空"); } String[] filePaths = new String[files.length]; for (int i = 0; i < files.length; i++) { MultipartFile file = files[i]; // 调用单文件上传方法 String filePath = uploadFile(file); filePaths[i] = filePath; } return filePaths; } } 3. 控制器：文件上传接口创建FileUploadController，提供单文件和多文件上传接口： import com.example.iodemo.utils.FileUploadUtils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.PostMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.multipart.MultipartFile; import java.io.IOException; @RestController @RequestMapping("/api/file") public class FileUploadController { @Autowired private FileUploadUtils fileUploadUtils; // 单文件上传 @PostMapping("/upload/single") public String uploadSingleFile(@RequestParam("file") MultipartFile file) { try { String filePath = fileUploadUtils.uploadFile(file); return "单文件上传成功，文件保存路径：" + filePath; } catch (IOException e) { return "单文件上传失败：" + e.getMessage(); } } // 多文件上传 @PostMapping("/upload/multiple") public String uploadMultipleFiles(@RequestParam("files") MultipartFile[] files) { try { String[] filePaths = fileUploadUtils.uploadFiles(files); return "多文件上传成功，文件保存路径：" + String.join(";", filePaths); } catch (IOException e) { return "多文件上传失败：" + e.getMessage(); } } } 三、实战场景二：文件下载文件下载功能通过IO流读取本地文件，将文件数据写入响应流，返回给前端。本文实现根据文件路径下载文件，并支持设置下载文件名。1. 工具类：文件下载工具创建FileDownloadUtils类，封装文件下载核心逻辑（校验文件是否存在、读取文件数据、写入响应流）： import javax.servlet.http.HttpServletResponse; import java.io.*; import java.net.URLEncoder; import java.nio.charset.StandardCharsets; public class FileDownloadUtils { // 文件下载核心方法 public static void downloadFile(String filePath, String downloadFilename, HttpServletResponse response) throws IOException { // 校验文件路径 File file = new File(filePath); if (!file.exists()) { throw new FileNotFoundException("文件不存在，路径：" + filePath); } if (!file.isFile()) { throw new IOException("路径对应的不是文件：" + filePath); } // 设置响应头，告知浏览器以附件形式下载 response.setContentType("application/octet-stream"); response.setContentLength((int) file.length()); // 编码文件名，避免中文乱码 String encodedFilename = URLEncoder.encode(downloadFilename, StandardCharsets.UTF_8.name()); response.setHeader("Content-Disposition", "attachment; filename=\"" + encodedFilename + "\""); // 使用IO流读取文件并写入响应流（try-with-resources自动关闭流） try (InputStream inputStream = new FileInputStream(file); BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream); OutputStream outputStream = response.getOutputStream(); BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream)) { byte[] buffer = new byte[1024 * 8]; int len; while ((len = bufferedInputStream.read(buffer)) != -1) { bufferedOutputStream.write(buffer, 0, len); } bufferedOutputStream.flush(); } } } 2. 控制器：文件下载接口创建FileDownloadController，提供文件下载接口，接收文件路径和下载文件名参数： import com.example.iodemo.utils.FileDownloadUtils; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController; import javax.servlet.http.HttpServletResponse; import java.io.IOException; @RestController @RequestMapping("/api/file") public class FileDownloadController { @GetMapping("/download") public void downloadFile( @RequestParam("filePath") String filePath, @RequestParam("filename") String filename, HttpServletResponse response) { try { // 调用文件下载工具类 FileDownloadUtils.downloadFile(filePath, filename, response); } catch (IOException e) { // 处理异常，设置响应状态 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR); try { response.getWriter().write("文件下载失败：" + e.getMessage()); } catch (IOException ex) { ex.printStackTrace(); } } } } 四、实战场景三：批量读取文本文件内容批量读取文本文件内容是数据处理常见场景（如读取日志文件、导入CSV数据等），本文实现批量读取指定目录下所有txt文件的内容，并统计文件总数量和总字符数。1. 工具类：文件读取工具创建FileReadUtils类，封装批量读取文本文件核心逻辑（遍历目录下文件、读取文件内容、统计数据）： import java.io.*; import java.util.ArrayList; import java.util.List; public class FileReadUtils { // 批量读取指定目录下所有txt文件内容 public static FileReadResult batchReadTxtFiles(String dirPath) throws IOException { File dir = new File(dirPath); if (!dir.exists()) { throw new FileNotFoundException("目录不存在：" + dirPath); } if (!dir.isDirectory()) { throw new IOException("路径对应的不是目录：" + dirPath); } // 存储所有文件内容 List<String> allFileContents = new ArrayList<>(); // 统计文件总数量和总字符数 int fileCount = 0; long totalCharCount = 0; // 遍历目录下所有文件 File[] files = dir.listFiles(); if (files == null) { throw new IOException("读取目录文件失败：" + dirPath); } for (File file : files) { // 只处理txt文件 if (file.isFile() && file.getName().endsWith(".txt")) { fileCount++; // 读取单个txt文件内容 String fileContent = readSingleTxtFile(file); allFileContents.add(fileContent); // 统计字符数（去除空格和换行符） totalCharCount += fileContent.replaceAll("\\s+", "").length(); } } // 返回读取结果 return new FileReadResult(fileCount, totalCharCount, allFileContents); } // 读取单个txt文件内容（字符流，避免中文乱码） private static String readSingleTxtFile(File file) throws IOException { StringBuilder contentBuilder = new StringBuilder(); // 使用BufferedReader读取文本文件，指定编码为UTF-8 try (Reader reader = new FileReader(file, java.nio.charset.StandardCharsets.UTF_8); BufferedReader bufferedReader = new BufferedReader(reader)) { String line; while ((line = bufferedReader.readLine()) != null) { contentBuilder.append(line).append("\n"); } } return contentBuilder.toString(); } // 定义文件读取结果实体类 public static class FileReadResult { private int fileCount; // 文件总数量 private long totalCharCount; // 总字符数（去除空格和换行） private List<String> allFileContents; // 所有文件内容 public FileReadResult(int fileCount, long totalCharCount, List<String> allFileContents) { this.fileCount = fileCount; this.totalCharCount = totalCharCount; this.allFileContents = allFileContents; } // getter和setter方法 public int getFileCount() { return fileCount; } public void setFileCount(int fileCount) { this.fileCount = fileCount; } public long getTotalCharCount() { return totalCharCount; } public void setTotalCharCount(long totalCharCount) { this.totalCharCount = totalCharCount; } public List<String> getAllFileContents() { return allFileContents; } public void setAllFileContents(List<String> allFileContents) { this.allFileContents = allFileContents; } } } 2. 控制器：文件读取接口创建FileReadController，提供批量读取文本文件接口： import com.example.iodemo.utils.FileReadUtils; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController; import java.io.IOException; @RestController @RequestMapping("/api/file") public class FileReadController { @GetMapping("/read/batch") public FileReadUtils.FileReadResult batchReadTxtFiles(@RequestParam("dirPath") String dirPath) { try { return FileReadUtils.batchReadTxtFiles(dirPath); } catch (IOException e) { throw new RuntimeException("批量读取文件失败：" + e.getMessage()); } } } 五、核心注意事项1. 资源关闭：IO流属于稀缺资源，必须确保关闭，推荐使用try-with-resources语法（JDK7+），自动关闭实现AutoCloseable接口的资源；2. 编码问题：读取文本文件时需指定编码（如UTF-8），避免中文乱码；文件下载时需对文件名进行URLEncoder编码，适配不同浏览器；3. 缓冲区优化：使用缓冲流（BufferedInputStream/BufferedOutputStream等），设置合适的缓冲区大小（一般8KB或16KB），减少IO操作次数，提升性能；4. 异常处理：IO操作易出现异常（如文件不存在、权限不足等），需捕获异常并友好提示，避免程序崩溃；5. 文件大小限制：文件上传时需限制文件大小，避免超大文件占用过多服务器资源，可通过Spring Boot配置或手动校验实现。本文通过三个核心场景实现了IO流的实际应用，代码可直接落地到文件管理、数据导入导出等业务场景，帮助开发者快速掌握IO流的使用技巧与优化方法。

MyBatis-Plus是MyBatis的增强工具，在MyBatis基础上简化了CRUD操作，提供了分页插件、条件构造器、代码生成器等强大功能，能够大幅减少开发工作量。本文将基于Spring Boot框架，集成MyBatis-Plus，实现一个用户管理系统，覆盖实体类映射、CRUD操作、分页查询、条件查询等核心功能，包含完整代码与详细说明。一、环境准备与依赖配置1. 开发环境JDK 1.8、Spring Boot 2.7.x、MyBatis-Plus 3.5.x、MySQL 8.0、Maven 3.6.x、IDEA2. Maven依赖配置在pom.xml中引入Spring Boot Web、MyBatis-Plus、MySQL驱动等依赖： &lt;dependencies&gt; <!-- Spring Boot Web --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency><!-- MyBatis-Plus --> <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>3.5.3.1</version> </dependency> <!-- MySQL驱动 --> <dependency> <groupId>com.mysql</groupId> <artifactId>mysql-connector-j</artifactId> <scope>runtime&lt;/scope&gt; &lt;/dependency&gt; <!-- Lombok（简化实体类编写） --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional&gt; &lt;/dependency&gt; <!-- Spring Boot Test --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> </dependencies> 3. 配置文件设置在application.yml中配置数据库连接信息、MyBatis-Plus相关配置（如Mapper扫描路径、日志打印）： spring: datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/mybatis_plus_demo?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8&useSSL=false username: root password: root # MyBatis-Plus配置 mybatis-plus: # Mapper接口扫描路径 mapper-locations: classpath:mapper/**/*.xml # 实体类扫描路径（可选，若使用@TableName注解可省略） type-aliases-package: com.example.mybatisplusdemo.entity # 日志打印（开发环境开启，方便调试） configuration: log-impl: org.apache.ibatis.logging.stdout.StdOutImpl # 数据库表下划线转驼峰（默认开启，可省略） map-underscore-to-camel-case: true 二、数据库表设计创建用户表（sys_user），包含id、username、password、nickname、age、email、create_time、update_time等字段，SQL语句如下： CREATE TABLE `sys_user` ( `id` bigint NOT NULL AUTO_INCREMENT COMMENT '主键ID', `username` varchar(50) NOT NULL COMMENT '用户名', `password` varchar(100) NOT NULL COMMENT '密码（加密存储）', `nickname` varchar(50) DEFAULT NULL COMMENT '昵称', `age` int DEFAULT NULL COMMENT '年龄', `email` varchar(100) DEFAULT NULL COMMENT '邮箱', `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间', `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间', PRIMARY KEY (`id`), UNIQUE KEY `uk_username` (`username`) ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COMMENT='系统用户表'; 三、核心代码实现1. 实体类（Entity）创建SysUser实体类，使用Lombok的@Data注解简化getter/setter方法，使用MyBatis-Plus的@TableName、@TableId、@TableField等注解实现实体类与数据库表的映射： import com.baomidou.mybatisplus.annotation.*; import lombok.Data; import java.time.LocalDateTime; @Data @TableName("sys_user") // 关联数据库表名 public class SysUser { // 主键ID，使用雪花算法自动生成（MyBatis-Plus默认策略） @TableId(type = IdType.AUTO) private Long id; // 用户名，对应表中username字段（若字段名与属性名一致，可省略@TableField） @TableField("username") private String username; // 密码 private String password; // 昵称 private String nickname; // 年龄 private Integer age; // 邮箱 private String email; // 创建时间，自动填充（新增时触发） @TableField(fill = FieldFill.INSERT) private LocalDateTime createTime; // 更新时间，自动填充（新增和修改时触发） @TableField(fill = FieldFill.INSERT_UPDATE) private LocalDateTime updateTime; } 2. 自动填充处理器针对createTime和updateTime字段，实现MyBatis-Plus的元对象处理器，实现字段自动填充（无需手动设置时间）： import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler; import org.apache.ibatis.reflection.MetaObject; import org.springframework.stereotype.Component; import java.time.LocalDateTime; @Component public class MyMetaObjectHandler implements MetaObjectHandler { // 新增时自动填充 @Override public void insertFill(MetaObject metaObject) { // 填充createTime字段 this.strictInsertFill(metaObject, "createTime", LocalDateTime.class, LocalDateTime.now()); // 填充updateTime字段 this.strictInsertFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); } // 修改时自动填充 @Override public void updateFill(MetaObject metaObject) { // 填充updateTime字段 this.strictUpdateFill(metaObject, "updateTime", LocalDateTime.class, LocalDateTime.now()); } } 3. Mapper接口创建SysUserMapper接口，继承MyBatis-Plus的BaseMapper接口，BaseMapper已封装了CRUD核心方法，无需编写XML即可实现基础操作： import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.example.mybatisplusdemo.entity.SysUser; import org.apache.ibatis.annotations.Mapper; // @Mapper注解：标识该接口为MyBatis Mapper接口，Spring Boot会自动扫描 @Mapper public interface SysUserMapper extends BaseMapper<SysUser> { // 基础CRUD方法已由BaseMapper提供，如需自定义SQL可在此添加方法 } 4. 服务层（Service）创建SysUserService接口及其实现类，继承MyBatis-Plus的IService和ServiceImpl，ServiceImpl已实现IService接口的核心方法，可直接使用或重写。 // 服务接口 import com.baomidou.mybatisplus.extension.service.IService; import com.example.mybatisplusdemo.entity.SysUser; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; public interface SysUserService extends IService<SysUser> { // 分页查询用户 IPage<SysUser> pageQuery(IPage<SysUser> page, QueryWrapper<SysUser> queryWrapper); // 根据用户名查询用户（自定义方法） SysUser getByUsername(String username); } // 服务实现类 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.example.mybatisplusdemo.entity.SysUser; import com.example.mybatisplusdemo.mapper.SysUserMapper; import org.springframework.stereotype.Service; @Service public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements SysUserService { @Override public IPage<SysUser> pageQuery(IPage<SysUser> page, QueryWrapper<SysUser> queryWrapper) { // 调用BaseMapper的selectPage方法实现分页查询 return baseMapper.selectPage(page, queryWrapper); } @Override public SysUser getByUsername(String username) { // 使用QueryWrapper构建查询条件 QueryWrapper<SysUser> queryWrapper = new QueryWrapper<>(); queryWrapper.eq("username", username); // 调用BaseMapper的selectOne方法查询单个结果 return baseMapper.selectOne(queryWrapper); } } 5. 控制器（Controller）创建SysUserController，提供RESTful接口，实现用户的新增、修改、删除、查询、分页查询等功能： import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.core.toolkit.Wrappers; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.example.mybatisplusdemo.entity.SysUser; import com.example.mybatisplusdemo.service.SysUserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.*; import java.util.List; @RestController @RequestMapping("/api/user") public class SysUserController { @Autowired private SysUserService sysUserService; // 新增用户 @PostMapping public String addUser(@RequestBody SysUser sysUser) { boolean save = sysUserService.save(sysUser); return save ? "新增用户成功" : "新增用户失败"; } // 修改用户 @PutMapping("/{id}") public String updateUser(@PathVariable Long id, @RequestBody SysUser sysUser) { sysUser.setId(id); boolean update = sysUserService.updateById(sysUser); return update ? "修改用户成功" : "修改用户失败"; } // 删除用户（逻辑删除可配置，本文为物理删除） @DeleteMapping("/{id}") public String deleteUser(@PathVariable Long id) { boolean remove = sysUserService.removeById(id); return remove ? "删除用户成功" : "删除用户失败"; } // 根据ID查询用户 @GetMapping("/{id}") public SysUser getUserById(@PathVariable Long id) { return sysUserService.getById(id); } // 查询所有用户 @GetMapping("/list") public List<SysUser> getAllUser() { return sysUserService.list(); } // 分页查询用户（支持条件查询，如按昵称、年龄筛选） @GetMapping("/page") public IPage<SysUser> pageUser( @RequestParam(defaultValue = "1") Integer pageNum, @RequestParam(defaultValue = "10") Integer pageSize, @RequestParam(required = false) String nickname, @RequestParam(required = false) Integer age) { // 构建分页对象 IPage<SysUser> page = new Page<>(pageNum, pageSize); // 构建查询条件 QueryWrapper<SysUser> queryWrapper = Wrappers.query(); if (nickname != null && !nickname.isEmpty()) { queryWrapper.like("nickname", nickname); // 模糊查询 } if (age != null) { queryWrapper.eq("age", age); // 精确查询 } // 调用分页查询方法 return sysUserService.pageQuery(page, queryWrapper); } // 根据用户名查询用户 @GetMapping("/username/{username}") public SysUser getUserByUsername(@PathVariable String username) { return sysUserService.getByUsername(username); } } 6. 分页插件配置MyBatis-Plus的分页功能需要配置分页插件，创建MyBatisPlusConfig类： import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor; import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class MyBatisPlusConfig { @Bean public MybatisPlusInterceptor mybatisPlusInterceptor() { MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); // 添加分页插件 interceptor.addInnerInterceptor(new PaginationInnerInterceptor()); return interceptor; } } 四、接口测试与效果验证启动Spring Boot应用，使用Postman或浏览器调用接口进行测试：1. 新增用户：POST /api/user，请求体为JSON格式用户数据，返回“新增用户成功”即表示成功；2. 分页查询：GET /api/user/page?pageNum=1&pageSize=5&nickname=张，返回包含总条数、总页数、当前页数据的分页结果；3. 修改用户：PUT /api/user/1，请求体为修改后的用户数据，返回“修改用户成功”；4. 删除用户：DELETE /api/user/1，返回“删除用户成功”；5. 根据用户名查询：GET /api/user/username/admin，返回对应用户名的用户信息。五、核心功能总结本文基于Spring Boot+MyBatis-Plus实现了用户管理系统，核心优势的在于：1. 简化CRUD操作：通过继承BaseMapper和IService，无需编写大量XML和SQL语句，即可实现基础增删改查；2. 强大的条件构造器：QueryWrapper支持多条件组合查询（精确、模糊、范围等），无需手动拼接SQL；3. 便捷的分页功能：配置分页插件后，只需传入分页参数即可实现分页查询，无需手动处理分页逻辑；4. 自动填充功能：通过元对象处理器，实现创建时间、更新时间等字段的自动填充，减少重复代码。MyBatis-Plus还提供了代码生成器、逻辑删除、乐观锁等功能，可根据业务需求进一步拓展，大幅提升Java项目的开发效率。

在Java开发中，并发场景无处不在，线程池作为管理线程的核心组件，能够有效避免频繁创建和销毁线程带来的性能损耗，提升系统并发处理能力。本文将从线程池核心原理出发，结合实际业务场景，实现一个基于线程池的异步任务处理系统，并详解核心代码与优化要点。一、线程池核心原理梳理Java线程池核心类为ThreadPoolExecutor，其构造方法包含7个核心参数，决定了线程池的运行机制： public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { // 构造逻辑省略 } 各参数核心作用：corePoolSize：核心线程数，线程池长期保留的线程数量，即使处于空闲状态也不会销毁（除非设置allowCoreThreadTimeOut为true）；maximumPoolSize：最大线程数，线程池允许创建的最大线程数量，当任务队列满且核心线程都在工作时，会创建临时线程直至达到该数量；keepAliveTime：临时线程空闲存活时间，超过该时间未处理任务则销毁临时线程；workQueue：任务阻塞队列，用于存储等待执行的任务，常见实现有ArrayBlockingQueue、LinkedBlockingQueue等；threadFactory：线程创建工厂，用于自定义线程名称、优先级等属性；handler：拒绝策略，当线程池与任务队列都满时，对新提交任务的处理方式，常见策略有AbortPolicy（直接抛异常）、CallerRunsPolicy（调用者线程执行）等。线程池核心运行流程：提交任务时，先判断核心线程是否空闲，若空闲则直接执行；若核心线程已满，将任务加入阻塞队列；若队列已满，创建临时线程执行任务；若临时线程达到最大线程数，触发拒绝策略。二、实际业务场景：异步任务处理系统假设业务需求：电商平台订单支付成功后，需要异步执行一系列后续任务（发送支付成功短信、更新订单状态、同步库存、生成交易日志），要求这些任务并行执行，且不影响支付接口的响应速度。此时使用线程池实现异步处理，既能提升接口性能，又能保证任务有序可控。三、完整代码实现1. 线程池配置类通过@Configuration注解创建线程池实例，自定义线程工厂和拒绝策略，适配业务场景需求（核心线程数8，最大线程数16，队列容量100，临时线程空闲时间30秒）。 import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; @Configuration public class ThreadPoolConfig { // 核心线程数 private static final int CORE_POOL_SIZE = 8; // 最大线程数 private static final int MAX_POOL_SIZE = 16; // 队列容量 private static final int QUEUE_CAPACITY = 100; // 临时线程空闲时间（秒） private static final long KEEP_ALIVE_TIME = 30; @Bean("orderThreadPool") public ThreadPoolExecutor orderThreadPool() { // 自定义线程工厂，设置线程名称前缀 ThreadFactory threadFactory = new ThreadFactory() { private final AtomicInteger threadNum = new AtomicInteger(1); @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r); thread.setName("order-handle-thread-" + threadNum.getAndIncrement()); thread.setPriority(Thread.NORM_PRIORITY); return thread; } }; // 拒绝策略：当线程池和队列都满时，由调用者线程执行任务，避免任务丢失 RejectedExecutionHandler rejectedHandler = new ThreadPoolExecutor.CallerRunsPolicy(); // 创建线程池实例 return new ThreadPoolExecutor( CORE_POOL_SIZE, MAX_POOL_SIZE, KEEP_ALIVE_TIME, TimeUnit.SECONDS, new LinkedBlockingQueue<>(QUEUE_CAPACITY), threadFactory, rejectedHandler ); } } 2. 任务接口与实现类定义任务接口OrderTask，包含各异步任务的执行方法，分别实现短信发送、订单状态更新、库存同步、日志生成功能。 import org.springframework.stereotype.Component; // 任务接口 public interface OrderTask { // 发送支付成功短信 void sendPaySms(Long orderId, String phone); // 更新订单状态为已支付 void updateOrderStatus(Long orderId); // 同步库存（减少对应商品库存） void syncStock(Long orderId); // 生成交易日志 void generateTradeLog(Long orderId, BigDecimal amount); } // 任务实现类 @Component public class OrderTaskImpl implements OrderTask { @Override public void sendPaySms(Long orderId, String phone) { // 模拟短信发送耗时操作 try { Thread.sleep(200); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("订单" + orderId + "：向手机号" + phone + "发送支付成功短信"); } @Override public void updateOrderStatus(Long orderId) { // 模拟数据库操作耗时 try { Thread.sleep(150); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("订单" + orderId + "：状态更新为已支付"); } @Override public void syncStock(Long orderId) { // 模拟库存同步耗时 try { Thread.sleep(300); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("订单" + orderId + "：库存同步完成"); } @Override public void generateTradeLog(Long orderId, BigDecimal amount) { // 模拟日志生成耗时 try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } System.out.println("订单" + orderId + "：交易日志生成完成，金额：" + amount); } } 3. 业务服务类创建OrderService类，在支付成功方法中，通过线程池提交异步任务，实现多任务并行执行。 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.stereotype.Service; import java.math.BigDecimal; import java.util.concurrent.ThreadPoolExecutor; @Service public class OrderService { @Autowired private OrderTask orderTask; @Autowired @Qualifier("orderThreadPool") private ThreadPoolExecutor threadPoolExecutor; // 支付成功处理方法 public void paySuccess(Long orderId, String phone, BigDecimal amount) { // 提交异步任务：发送短信 threadPoolExecutor.submit(() -> orderTask.sendPaySms(orderId, phone)); // 提交异步任务：更新订单状态 threadPoolExecutor.submit(() -> orderTask.updateOrderStatus(orderId)); // 提交异步任务：同步库存 threadPoolExecutor.submit(() -> orderTask.syncStock(orderId)); // 提交异步任务：生成交易日志 threadPoolExecutor.submit(() -> orderTask.generateTradeLog(orderId, amount)); // 支付接口直接返回成功，无需等待异步任务完成 System.out.println("订单" + orderId + "：支付成功，异步任务已提交"); } } 4. 测试类编写测试类，模拟订单支付成功场景，验证线程池异步任务执行效果。 import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner; import java.math.BigDecimal; @SpringBootTest @RunWith(SpringRunner.class) public class OrderServiceTest { @Autowired private OrderService orderService; @Test public void testPaySuccess() { // 模拟订单数据 Long orderId = 10001L; String phone = "13800138000"; BigDecimal amount = new BigDecimal("999.00"); // 调用支付成功方法 orderService.paySuccess(orderId, phone, amount); // 等待异步任务执行完成（测试用，实际业务无需此操作） try { Thread.sleep(2000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } 四、核心优化与注意事项1. 线程池参数优化：核心线程数和最大线程数需根据CPU核心数和业务并发量调整，一般核心线程数=CPU核心数+1，最大线程数=2*CPU核心数+1；队列容量需避免过大（导致任务堆积）或过小（频繁触发拒绝策略）。2. 任务异常处理：异步任务中若发生异常，线程池会直接销毁该线程且不抛出异常，需在任务中捕获异常并处理（如记录日志、重试机制），避免线程泄漏。3. 线程池监控：可通过ThreadPoolExecutor的getActiveCount()、getQueue().size()等方法监控线程池运行状态，及时发现任务堆积、线程泄漏等问题。4. 避免使用Executors默认线程池：Executors创建的线程池（如FixedThreadPool、CachedThreadPool）存在队列无界、线程数无上限等问题，易导致OOM，推荐自定义ThreadPoolExecutor。本文通过线程池实现了异步任务处理系统，核心代码可直接落地到电商、支付等并发场景，有效提升系统性能和稳定性。

题⽬描述在⼀个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表 1->2->3->3->4->4->5 处理后为 1->2->5示例1输⼊：{1,2,3,3,4,4,5}返回值：{1,2,5}思路及解答hash统计第一次遍历统计频率，第二次遍历删除重复节点javaimport java.util.HashMap;public class Solution { public ListNode deleteDuplication(ListNode head) { if (head == null || head.next == null) { return head; } // 第一次遍历：统计每个节点值出现的次数 HashMap<Integer, Integer> countMap = new HashMap<>(); ListNode current = head; while (current != null) { countMap.put(current.val, countMap.getOrDefault(current.val, 0) + 1); current = current.next; } // 第二次遍历：删除重复节点 ListNode dummy = new ListNode(-1); // 哑节点简化边界处理 dummy.next = head; ListNode prev = dummy; current = head; while (current != null) { if (countMap.get(current.val) > 1) { // 当前节点重复，跳过 prev.next = current.next; } else { // 当前节点不重复，移动prev指针 prev = prev.next; } current = current.next; } return dummy.next; }}时间复杂度：O(n)空间复杂度：O(n)直接遍历（推荐）注意，题目已经提到是排序的节点，那么就可以直接原地删除对⽐前后两个元素，如果相同的情况下，接着遍历后⾯的元素，直到元素不相等的时候，将前⾯的指针指向最后⼀个相同的元素的后⾯，相当于跳过了相同的元素。javapublic class Solution { public ListNode deleteDuplication(ListNode pHead) { //遍历链表，直接删除 if(pHead == null || pHead.next == null) return pHead; ListNode head = new ListNode(0); head.next = pHead; ListNode cur = head.next; ListNode pre = head; while(cur != null){ //将重复的结点都遍历过，然后将后面节点复制给pre结点后面 if(cur.next != null && cur.val == cur.next.val){ while(cur.next != null && cur.val == cur.next.val){ cur = cur.next; } pre.next = cur.next; cur = cur.next; }else{ pre = pre.next; cur = cur.next; } } return head.next; }}空间复杂度为 O(1) ，没有借助额外的空间时间复杂度为 O(n) ，只遍历了⼀次链表递归将大问题分解为当前节点+剩余链表的子问题java/** * 递归法：分治思想解决子问题 * 思路：将大问题分解为当前节点+剩余链表的子问题 * */public class Solution { public ListNode deleteDuplication(ListNode head) { // 递归终止条件：空链表或单节点链表 if (head == null || head.next == null) { return head; } // 情况1：当前节点与下一节点重复 if (head.val == head.next.val) { // 跳过所有重复节点，找到第一个不重复的节点 ListNode node = head.next; while (node != null && head.val == node.val) { node = node.next; } // 递归处理剩余部分 return deleteDuplication(node); } // 情况2：当前节点不重复 else { head.next = deleteDuplication(head.next); return head; } }}时间复杂度：O(n)空间复杂度：O(n) ，递归栈空间三指针法使用pre、cur、next三个指针精确控制删除范围javapublic class Solution { public ListNode deleteDuplication(ListNode head) { if (head == null || head.next == null) { return head; } ListNode dummy = new ListNode(-1); dummy.next = head; ListNode pre = dummy; // 前驱指针 ListNode cur = head; // 当前指针 ListNode next = null; // 后继指针 while (cur != null && cur.next != null) { next = cur.next; // 发现重复节点 if (cur.val == next.val) { // 移动next直到找到不重复的节点 while (next != null && cur.val == next.val) { next = next.next; } // 跳过所有重复节点 pre.next = next; cur = next; } // 没有重复，正常移动指针 else { pre = cur; cur = cur.next; } } return dummy.next; }}时间复杂度：O(n)空间复杂度：O(1)转载自https://www.cnblogs.com/sevencoding/p/19411014

题⽬描述给定⼀棵⼆叉搜索树，请找出其中的第 k ⼩的 TreeNode 结点。示例1输⼊：{5,3,7,2,4,6,8},3返回值：{4}思路及解答二叉搜索树的关键性质二叉搜索树具有一个重要特性：中序遍历（左-根-右）BST会得到一个升序排列的节点值序列。因此，寻找第k小的节点本质上就是获取中序遍历序列中的第k个元素。理解这一点是掌握所有解法的基石。递归中序遍历（直观版）算法思路：进行递归中序遍历将遍历到的节点值依次加入一个列表。遍历完成后，列表中的元素就是升序排列的。从列表中取出第k-1个元素（索引从0开始）即为答案。javaclass TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; }}public class Solution { public int kthSmallest(TreeNode root, int k) { // 用于存储中序遍历结果的列表 List<Integer> inorderList = new ArrayList<>(); // 执行中序遍历 inorderTraversal(root, inorderList); // 返回第k小的元素（列表索引从0开始，所以是k-1） return inorderList.get(k - 1); } /** * 递归中序遍历二叉树 * @param node 当前遍历的节点 * @param list 存储遍历结果的列表 */ private void inorderTraversal(TreeNode node, List<Integer> list) { if (node == null) { return; // 递归终止条件：遇到空节点则返回 } inorderTraversal(node.left, list); // 递归遍历左子树 list.add(node.val); // 访问当前节点，将值加入列表 inorderTraversal(node.right, list); // 递归遍历右子树 }}时间复杂度：O(n)。需要遍历树中的所有n个节点。空间复杂度：O(n)。主要取决于递归调用栈的深度（最坏情况为O(n)，树退化成链表）和存储遍历结果的列表（O(n)）。迭代中序遍历（提前终止）方法一需要遍历完整棵树，即使答案在很早就已确定。我们可以利用迭代中序遍历实现提前终止，找到第k小的节点后立即返回，提升效率。算法思路：使用一个栈来模拟递归过程。从根节点开始，将所有左子节点压入栈，直到最左边的节点。弹出栈顶元素，这将是当前最小的节点。每弹出一个节点，计数器k减1。当k减到0时，当前节点就是第k小的节点，直接返回。如果k不为0，则转向当前节点的右子树，重复步骤2-4。javapublic class Solution { public int kthSmallest(TreeNode root, int k) { Deque<TreeNode> stack = new LinkedList<>(); TreeNode current = root; while (current != null || !stack.isEmpty()) { // 将当前节点及其所有左子节点压入栈 while (current != null) { stack.push(current); current = current.left; } // 弹出栈顶节点，即当前最小的节点 current = stack.pop(); k--; // 计数器减1 // 如果k减到0，说明找到了第k小的节点 if (k == 0) { return current.val; } // 转向右子树 current = current.right; } // 如果k超出节点总数，返回-1（根据题目保证k有效，此情况可不处理） return -1; }}时间复杂度：最坏情况O(n)（当k=n时仍需遍历大部分节点），平均情况优于O(n)，因为可能提前返回。空间复杂度：O(h)，其中h是树的高度。栈的深度最大为树高，在平衡BST中为O(log n)。记录子节点数的递归（进阶优化）如果BST结构频繁变动（插入、删除），但需要频繁查询第k小的值，前两种方法每次查询都可能需要O(n)时间。我们可以通过扩展树节点结构，记录以每个节点为根的子树中的节点个数，来优化查询效率。算法思路：修改树节点结构，增加一个字段（如size）表示以该节点为根的子树的总节点数。在插入、删除节点时，维护每个节点的size信息。查询第k小的节点时：从根节点开始。计算左子树的节点数leftSize。如果k <= leftSize，说明目标节点在左子树，递归地在左子树中寻找第k小的节点。如果k == leftSize + 1，说明当前根节点就是目标节点。如果k > leftSize + 1，说明目标节点在右子树，递归地在右子树中寻找第k - (leftSize + 1)小的节点。javaclass TreeNodeWithSize { int val; TreeNodeWithSize left; TreeNodeWithSize right; int size; // 以该节点为根的子树包含的节点总数 TreeNodeWithSize(int x) { val = x; size = 1; // 初始时只有自身 } // 假设插入操作会更新size，这里省略具体的树结构维护代码}public class Solution { public int kthSmallest(TreeNodeWithSize root, int k) { if (root == null) { return -1; } // 计算左子树的节点数（如果左子树为空，则节点数为0） int leftSize = (root.left != null) ? root.left.size : 0; if (k <= leftSize) { // 第k小的节点在左子树 return kthSmallest(root.left, k); } else if (k == leftSize + 1) { // 当前节点就是第k小的节点 return root.val; } else { // 第k小的节点在右子树，在右子树中寻找第 (k - (leftSize + 1)) 小的节点 return kthSmallest(root.right, k - (leftSize + 1)); } }}转载自https://www.cnblogs.com/sevencoding/p/19468628

InheritableThreadLocal相比ThreadLocal多一个能力：在创建子线程Thread时，子线程Thread会自动继承父线程的InheritableThreadLocal信息到子线程中，进而实现在在子线程获取父线程的InheritableThreadLocal值的目的。关于ThreadLocal详细内容，可以看这篇文章：史上最全ThreadLocal 详解和 ThreadLocal 的区别举个简单的栗子对比下InheritableThreadLocal和ThreadLocal：javapublic class InheritableThreadLocalTest {     private static final ThreadLocal<String> threadLocal = new ThreadLocal<>();     private static final InheritableThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();     public static void main(String[] args) {        testThreadLocal();        testInheritableThreadLocal();    }     /**     * threadLocal测试     */     public static void testThreadLocal() {         // 在主线程中设置值到threadLocal         threadLocal.set("我是父线程threadLocal的值");          // 创建一个新线程并启动          new Thread(() -> {              // 在子线程里面无法获取到父线程设置的threadLocal，结果为null             System.out.println("从子线程获取到threadLocal的值: " + threadLocal.get());        }  ).start();     }       /**     * inheritableThreadLocal测试     */  public static void testInheritableThreadLocal() {         // 在主线程中设置一个值到inheritableThreadLocal        inheritableThreadLocal.set("我是父线程inheritableThreadLocal的值");         // 创建一个新线程并启动         new Thread(() -> {             // 在子线程里面可以自动获取到父线程设置的inheritableThreadLocal    System.out.println("从子线程获取到inheritableThreadLocal的值: " + inheritableThreadLocal.get());        }).start();    } }执行结果：text从子线程获取到threadLocal的值:null从子线程获取到inheritableThreadLocal的值:我是父线程inheritableThreadLocal的值可以看到子线程中可以获取到父线程设置的inheritableThreadLocal值，但不能获取到父线程设置的threadLocal值实现原理InheritableThreadLocal 的实现原理相当精妙，它通过在创建子线程的瞬间，“复制”父线程的线程局部变量，从而实现了数据从父线程到子线程的一次性、创建时的传递 。其核心工作原理可以清晰地通过以下序列图展示，它描绘了当父线程创建一个子线程时，数据是如何被传递的：子线程ThreadLocalMapInheritableThreadLocalThread构造方法父线程子线程ThreadLocalMapInheritableThreadLocalThread构造方法父线程关键步骤：初始化检查父线程的 inheritableThreadLocalsloop[遍历父线程Map中的每个Entry]子线程拥有父线程变量的副本创建 new Thread()调用 init() 方法createInheritedMap(parent.inheritableThreadLocals)新建一个ThreadLocalMap调用 key.childValue(parentValue)返回子线程初始值(默认返回父值，可重写)将 (key, value) 放入新Map返回新的ThreadLocalMap对象将新Map赋给子线程的inheritableThreadLocals属性下面我们来详细拆解图中的关键环节。核心实现机制**数据结构基础：Thread类内部维护了两个 ThreadLocalMap类型的变量 ：threadLocals：用于存储普通 ThreadLocal设置的变量副本。inheritableThreadLocals：专门用于存储 InheritableThreadLocal设置的变量副本 。InheritableThreadLocal通过重写 getMap和 createMap方法，使其所有操作都针对 inheritableThreadLocals字段，从而与普通 ThreadLocal分离开 。继承触发时刻：子线程的创建。继承行为发生在子线程被创建（即执行 new Thread()）时。在 Thread类的 init方法中，如果判断需要继承（inheritThreadLocals参数为 true）且父线程（当前线程）的 inheritableThreadLocals不为 null，则会执行复制逻辑 。复制过程的核心：createInheritedMap。这是实现复制的核心方法 。它会创建一个新的 ThreadLocalMap，并将父线程 inheritableThreadLocals中的所有条目遍历拷贝到新 Map 中。Key的复制：Key（即 InheritableThreadLocal对象本身）是直接复制的引用。Value的生成：Value 并非直接复制引用，而是通过调用 InheritableThreadLocal的 childValue(T parentValue)方法来生成子线程中的初始值。默认实现是直接返回父值（return parentValue;），这意味着对于对象类型，父子线程将共享同一个对象引用 。关键特性与注意事项创建时复制，后续独立：继承只发生一次，即在子线程对象创建的瞬间。此后，父线程和子线程对各自 InheritableThreadLocal变量的修改互不影响 。在线程池中的局限性：这是 InheritableThreadLocal最需要警惕的问题。线程池中的线程是复用的，这些线程在首次创建时可能已经从某个父线程继承了值。但当它们被用于执行新的任务时，新的任务提交线程（逻辑上的“父线程”）与工作线程已无直接的创建关系，因此之前继承的值不会更新，这会导致数据错乱（如用户A的任务拿到了用户B的信息）或内存泄漏​ 。对于线程池场景，应考虑使用阿里开源的 TransmittableThreadLocal (TTL)​ 。浅拷贝与对象共享：由于 childValue方法默认是浅拷贝，如果存入的是可变对象（如 Map、List），父子线程实际持有的是同一个对象的引用。在一个线程中修改该对象的内部状态，会直接影响另一个线程 。若需隔离，可以重写 childValue方法实现深拷贝 。内存泄漏风险：与 ThreadLocal类似，如果线程长时间运行（如线程池中的核心线程），并且未及时调用 remove方法清理，那么该线程的 inheritableThreadLocals会一直持有值的强引用，导致无法被GC回收。良好的实践是在任务执行完毕后主动调用 remove()线程池中局限性一般来说，在真实的业务场景下，没人会直接 new Thread，而都是使用线程池的，因此InheritableThreadLocal在线程池中的使用局限性要额外注意首先，我们先理解 InheritableThreadLocal的继承前提InheritableThreadLocal的继承只发生在 新线程被创建时（即 new Thread()并启动时）。在创建过程中，子线程会复制父线程的 InheritableThreadLocal值。在线程池中，线程是预先创建或按需创建的，并且会被复用。因此，继承只会在线程池创建新线程时发生，而不会在复用现有线程时发生。再看线程池创建新线程的条件，对于标准的 ThreadPoolExecutor，新线程的创建遵循以下规则：当前线程数 < 核心线程数：当提交新任务时，如果当前运行的线程数小于核心线程数，即使有空闲线程，线程池也会创建新线程来处理任务。此时，新线程会继承父线程（提交任务的线程）的 InheritableThreadLocal。当前线程数 >= 核心线程数 && 队列已满 && 线程数 < 最大线程数：当任务队列已满，且当前线程数小于最大线程数时，线程池会创建新线程来处理任务。同样，新线程会继承父线程的 InheritableThreadLocal。不会继承的场景线程复用：当线程池中有空闲线程时（例如，当前线程数 >= 核心线程数，但队列未满），任务会被分配给现有线程执行。此时，没有新线程创建，因此不会发生继承。现有线程的 InheritableThreadLocal值保持不变（可能是之前任务设置的值），这可能导致数据错乱（如用户A的任务看到用户B的数据）。线程数已达最大值：如果线程数已达最大线程数，且队列已满，新任务会被拒绝（根据拒绝策略），也不会创建新线程，因此不会继承。不只是线程池污染，线程池使用 InheritableThreadLocal 还可能存在获取不到值的情况。例如，在执行异步任务的时候，复用了某个已有的线程A，并且当时创建该线程A的时候，没有继承InheritableThreadLocal，进而导致后面复用该线程的时候，从InheritableThreadLocal获取到的值为null：javapublic class InheritableThreadLocalWithThreadPoolTest {     private static final InheritableThreadLocal<String> inheritableThreadLocal = new InheritableThreadLocal<>();     // 这里线程池core/max数量都只有2     private static final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(             2,             2,             0L,            TimeUnit.MILLISECONDS,             new LinkedBlockingQueue<Runnable>(3000),             new ThreadPoolExecutor.CallerRunsPolicy()    );     public static void main(String[] args) {         // 先执行了不涉及InheritableThreadLocal的子任务初始化线程池线程        testAnotherFunction();              testAnotherFunction();               // 后执行了涉及InheritableThreadLocal       testInheritableThreadLocalWithThreadPool("张三");              testInheritableThreadLocalWithThreadPool("李四");              threadPoolExecutor.shutdown();    }     /**     * inheritableThreadLocal+线程池测试     */         public static void testInheritableThreadLocalWithThreadPool(String param) {             // 1. 在主线程中设置一个值到inheritableThreadLocal                inheritableThreadLocal.set(param);                // 2. 提交异步任务到线程池               threadPoolExecutor.execute(() -> {                    // 3. 在线程池-子线程里面可以获取到父线程设置的inheritableThreadLocal吗？                   System.out.println("线程名: " + Thread.currentThread().getName() + ", 父线程设置的inheritableThreadLocal值: " + param + ", 子线程获取到inheritableThreadLocal的值: " + inheritableThreadLocal.get());               });                // 4. 清除inheritableThreadLocal               inheritableThreadLocal.remove();      }                     /**     * 模拟另一个独立的功能     */      public static void testAnotherFunction() {           // 提交异步任务到线程池              threadPoolExecutor.execute(() -> {                   // 在线程池-子线程里面可以获取到父线程设置的inheritableThreadLocal吗？                  System.out.println("线程名: " + Thread.currentThread().getName() + ", 线程池-子线程摸个鱼");              });      }}执行结果：text线程名:pool-1-thread-2,线程池-子线程摸个鱼线程名:pool-1-thread-1,线程池-子线程摸个鱼线程名:pool-1-thread-1,父线程设置的inheritableThreadLocal值:李四，子线程获取到inheritableThreadLocal的值:null线程名:pool-1-thread-2,父线程设置的inheritableThreadLocal值:张三，子线程获取到inheritableThreadLocal的值:null当然了，解决这个问题可以考虑使用阿里开源的 TransmittableThreadLocal (TTL)，​或者在提交异步任务前，先获取线程数据，再传入。例如：java// 1. 在主线程中先获取inheritableThreadLocal的值String name = inheritableThreadLocal.get();        // 2. 提交异步任务到线程池        threadPoolExecutor.execute(() -> {            // 3. 在线程池-子线程里面直接传入数据  System.out.println("线程名: " + Thread.currentThread().getName() + ", 父线程设置的inheritableThreadLocal值: " + param + ", 子线程获取到inheritableThreadLocal的值: " + name);               });        与 ThreadLocal 的对比特性ThreadLocalInheritableThreadLocal数据隔离​线程绝对隔离线程绝对隔离子线程继承​不支持​支持（创建时）底层存储字段​Thread.threadLocalsThread.inheritableThreadLocals适用场景​线程内全局变量，避免传参父子线程间需要传递上下文数据转载自

前言Vector无论是add方法还是get方法都加上了synchronized修饰，当多线程读写List必须排队执行，很显然这样效率比较是低下的，CopyOnWriteArrayList是读写分离的，好处是提高线程访问效率。CopyOnWrite容器即写时复制的容器。通俗的理解是当往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器里的值Copy到新的容器，然后再往新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读 要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。底层原理CopyOnWriteArrayList的动态数组机制 -- 它内部有个volatile数组(array)来保持数据。在“添加/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给volatile数组。这就是它叫做CopyOnWriteArrayList的原因！每一个CopyOnWriteArrayList都和一个监视器锁lock绑定，通过lock，实现了对CopyOnWriteArrayList的互斥添加/删除。类的继承关系CopyOnWriteArrayList实现了List接口，List接口定义了对列表的基本操作；同时实现了RandomAccess接口，表示可以随机访问(数组具有随机访问的特性)；同时实现了Cloneable接口，表示可克隆；同时也实现了Serializable接口，表示可被序列化。javapublic class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}类的内部类COWIterator类COWIterator表示迭代器，其也有一个Object类型的数组作为CopyOnWriteArrayList数组的快照，这种快照风格的迭代器方法在创建迭代器时使用了对当时数组状态的引用。此数组在迭代器的生存期内不会更改，因此不可能发生冲突，并且迭代器保证不会抛出 ConcurrentModificationException。创建迭代器以后，迭代器就不会反映列表的添加、移除或者更改。在迭代器上进行的元素更改操作(remove、set 和 add)不受支持。这些方法将抛出 UnsupportedOperationException。javastatic final class COWIterator<E> implements ListIterator<E> { /** Snapshot of the array */ // 快照 private final Object[] snapshot; /** Index of element to be returned by subsequent call to next. */ // 游标 private int cursor; // 构造函数 private COWIterator(Object[] elements, int initialCursor) { cursor = initialCursor; snapshot = elements; } // 是否还有下一项 public boolean hasNext() { return cursor < snapshot.length; } // 是否有上一项 public boolean hasPrevious() { return cursor > 0; } // next项 @SuppressWarnings("unchecked") public E next() { if (! hasNext()) // 不存在下一项，抛出异常 throw new NoSuchElementException(); // 返回下一项 return (E) snapshot[cursor++]; } @SuppressWarnings("unchecked") public E previous() { if (! hasPrevious()) throw new NoSuchElementException(); return (E) snapshot[--cursor]; } // 下一项索引 public int nextIndex() { return cursor; } // 上一项索引 public int previousIndex() { return cursor-1; } /** * Not supported. Always throws UnsupportedOperationException. * @throws UnsupportedOperationException always; {@code remove} * is not supported by this iterator. */ // 不支持remove操作 public void remove() { throw new UnsupportedOperationException(); } /** * Not supported. Always throws UnsupportedOperationException. * @throws UnsupportedOperationException always; {@code set} * is not supported by this iterator. */ // 不支持set操作 public void set(E e) { throw new UnsupportedOperationException(); } /** * Not supported. Always throws UnsupportedOperationException. * @throws UnsupportedOperationException always; {@code add} * is not supported by this iterator. */ // 不支持add操作 public void add(E e) { throw new UnsupportedOperationException(); } @Override public void forEachRemaining(Consumer<? super E> action) { Objects.requireNonNull(action); Object[] elements = snapshot; final int size = elements.length; for (int i = cursor; i < size; i++) { @SuppressWarnings("unchecked") E e = (E) elements[i]; action.accept(e); } cursor = size; }}类的属性属性中有一个可重入锁，用来保证线程安全访问，还有一个Object类型的数组，用来存放具体的元素。当然，也使用到了反射机制和CAS来保证原子性的修改lock域。javapublic class CopyOnWriteArrayList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable { // 版本序列号 private static final long serialVersionUID = 8673264195747942595L; // 可重入锁 final transient ReentrantLock lock = new ReentrantLock(); // 对象数组，用于存放元素 private transient volatile Object[] array; // 反射机制 private static final sun.misc.Unsafe UNSAFE; // lock域的内存偏移量 private static final long lockOffset; static { try { UNSAFE = sun.misc.Unsafe.getUnsafe(); Class<?> k = CopyOnWriteArrayList.class; lockOffset = UNSAFE.objectFieldOffset (k.getDeclaredField("lock")); } catch (Exception e) { throw new Error(e); } }}类的构造函数默认构造函数javapublic CopyOnWriteArrayList() { // 设置数组 setArray(new Object[0]);}CopyOnWriteArrayList(Collection<? extends E>)javapublic CopyOnWriteArrayList(Collection<? extends E> c) { Object[] elements; if (c.getClass() == CopyOnWriteArrayList.class) // 类型相同 // 获取c集合的数组 elements = ((CopyOnWriteArrayList<?>)c).getArray(); else { // 类型不相同 // 将c集合转化为数组并赋值给elements elements = c.toArray(); // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elements.getClass() != Object[].class) // elements类型不为Object[]类型 // 将elements数组转化为Object[]类型的数组 elements = Arrays.copyOf(elements, elements.length, Object[].class); } // 设置数组 setArray(elements);}该构造函数的处理流程如下判断传入的集合c的类型是否为CopyOnWriteArrayList类型，若是，则获取该集合类型的底层数组(Object[])，并且设置当前CopyOnWriteArrayList的数组(Object[]数组)，进入步骤③；否则，进入步骤②将传入的集合转化为数组elements，判断elements的类型是否为Object[]类型(toArray方法可能不会返回Object类型的数组)，若不是，则将elements转化为Object类型的数组。进入步骤③设置当前CopyOnWriteArrayList的Object[]为elements。CopyOnWriteArrayList(E[])：该构造函数用于创建一个保存给定数组的副本的列表。javapublic CopyOnWriteArrayList(E[] toCopyIn) { // 将toCopyIn转化为Object[]类型数组，然后设置当前数组 setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));}核心函数分析对于CopyOnWriteArrayList的函数分析，主要明白Arrays.copyOf方法即可理解CopyOnWriteArrayList其他函数的意义。copyOf函数该函数用于复制指定的数组，截取或用 null 填充(如有必要)，以使副本具有指定的长度。javapublic static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) { @SuppressWarnings("unchecked") // 确定copy的类型(将newType转化为Object类型，将Object[].class转化为Object类型； // 判断两者是否相等，若相等，则生成指定长度的Object数组 // 否则,生成指定长度的新类型的数组) T[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength] : (T[]) Array.newInstance(newType.getComponentType(), newLength); // 将original数组从下标0开始，复制长度为(original.length和newLength的较小者),复制到copy数组中(也从下标0开始) System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy;}add函数javapublic boolean add(E e) { // 可重入锁 final ReentrantLock lock = this.lock; // 获取锁 lock.lock(); try { // 元素数组 Object[] elements = getArray(); // 数组长度 int len = elements.length; // 复制数组 Object[] newElements = Arrays.copyOf(elements, len + 1); // 存放元素e newElements[len] = e; // 设置数组 setArray(newElements); return true; } finally { // 释放锁 lock.unlock(); }}此函数用于将指定元素添加到此列表的尾部，处理流程如下获取锁(保证多线程的安全访问)，获取当前的Object数组，获取Object数组的长度为length，进入步骤②。根据Object数组复制一个长度为length+1的Object数组为newElements(此时，newElements[length]为null)，进入下一步骤。将下标为length的数组元素newElements[length]设置为元素e，再设置当前Object[]为newElements，释放锁，返回。这样就完成了元素的添加。addIfAbsent方法该函数用于添加元素(如果数组中不存在，则添加；否则，不添加，直接返回)，可以保证多线程环境下不会重复添加元素。javaprivate boolean addIfAbsent(E e, Object[] snapshot) { // 重入锁 final ReentrantLock lock = this.lock; // 获取锁 lock.lock(); try { // 获取数组 Object[] current = getArray(); // 数组长度 int len = current.length; if (snapshot != current) { // 快照不等于当前数组，对数组进行了修改 // Optimize for lost race to another addXXX operation // 取较小者 int common = Math.min(snapshot.length, len); for (int i = 0; i < common; i++) // 遍历 if (current[i] != snapshot[i] && eq(e, current[i])) // 当前数组的元素与快照的元素不相等并且e与当前元素相等 // 表示在snapshot与current之间修改了数组，并且设置了数组某一元素为e，已经存在 // 返回 return false; if (indexOf(e, current, common, len) >= 0) // 在当前数组中找到e元素 // 返回 return false; } // 复制数组 Object[] newElements = Arrays.copyOf(current, len + 1); // 对数组len索引的元素赋值为e newElements[len] = e; // 设置数组 setArray(newElements); return true; } finally { // 释放锁 lock.unlock(); }}该函数的流程如下:获取锁，获取当前数组为current，current长度为len，判断数组之前的快照snapshot是否等于当前数组current，若不相等，则进入步骤2；否则，进入步骤4不相等，表示在snapshot与current之间，对数组进行了修改(如进行了add、set、remove等操作)，获取长度(snapshot与current之间的较小者)，对current进行遍历操作，若遍历过程发现snapshot与current的元素不相等并且current的元素与指定元素相等(可能进行了set操作)，进入步骤5，否则，进入步骤3在当前数组中索引指定元素，若能够找到，进入步骤5，否则，进入步骤4复制当前数组current为newElements，长度为len+1，此时newElements[len]为null。再设置newElements[len]为指定元素e，再设置数组，进入步骤5释放锁，返回。set函数此函数用于用指定的元素替代此列表指定位置上的元素，也是基于数组的复制来实现的。javapublic E set(int index, E element) { // 可重入锁 final ReentrantLock lock = this.lock; // 获取锁 lock.lock(); try { // 获取数组 Object[] elements = getArray(); // 获取index索引的元素 E oldValue = get(elements, index); if (oldValue != element) { // 旧值等于element // 数组长度 int len = elements.length; // 复制数组 Object[] newElements = Arrays.copyOf(elements, len); // 重新赋值index索引的值 newElements[index] = element; // 设置数组 setArray(newElements); } else { // Not quite a no-op; ensures volatile write semantics // 设置数组 setArray(elements); } // 返回旧值 return oldValue; } finally { // 释放锁 lock.unlock(); }}remove函数此函数用于移除此列表指定位置上的元素。javapublic E remove(int index) { // 可重入锁 final ReentrantLock lock = this.lock; // 获取锁 lock.lock(); try { // 获取数组 Object[] elements = getArray(); // 数组长度 int len = elements.length; // 获取旧值 E oldValue = get(elements, index); // 需要移动的元素个数 int numMoved = len - index - 1; if (numMoved == 0) // 移动个数为0 // 复制后设置数组 setArray(Arrays.copyOf(elements, len - 1)); else { // 移动个数不为0 // 新生数组 Object[] newElements = new Object[len - 1]; // 复制index索引之前的元素 System.arraycopy(elements, 0, newElements, 0, index); // 复制index索引之后的元素 System.arraycopy(elements, index + 1, newElements, index, numMoved); // 设置索引 setArray(newElements); } // 返回旧值 return oldValue; } finally { // 释放锁 lock.unlock(); }}处理流程如下获取锁，获取数组elements，数组长度为length，获取索引的值elements[index]，计算需要移动的元素个数(length - index - 1),若个数为0，则表示移除的是数组的最后一个元素，复制elements数组，复制长度为length-1，然后设置数组，进入步骤③；否则，进入步骤②先复制index索引前的元素，再复制index索引后的元素，然后设置数组。释放锁，返回旧值 CopyOnWriteArrayList是Fail Safe的采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。原理：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发Concurrent Modification Exception。缺点：基于拷贝内容的优点是避免了Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。Vector无论是add方法还是get方法都加上了synchronized修饰，当多线程读写List必须排队执行，很显然这样效率比较是低下的，CopyOnWriteArrayList是读写分离的，好处是提高线程访问效率。缺陷和使用场景CopyOnWriteArrayList的写效率比Vector慢。当CopyOnWriteArrayList写元素时是通过备份数组的方式实现的，当多线程同步激烈，数据量较大时会不停的复制数组，内存浪费严重。如果原数组的内容比较多的情况下，可能导致young gc或者full gc弱一致性：不能用于实时读的场景，像拷贝数组、新增元素都需要时间，所以调用一个set操作后，读取到数据可能还是旧的，虽然CopyOnWriteArrayList 能做到最终一致性，但是还是没法满足实时性要求；小结： CopyOnWriteArrayList合适读多写少的场景，例如黑名单白名单等转载自https://www.cnblogs.com/sevencoding/p/19525347

如何得到⼀个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使⽤ Insert() ⽅法读取数据流，使⽤ GetMedian() ⽅法获取当前读取数据的中位数。思路及解答排序列表法维护一个列表，每次获取中位数前进行排序javaimport java.util.ArrayList;import java.util.Collections;import java.util.List;public class MedianFinder1 { private List<Integer> data; public MedianFinder1() { data = new ArrayList<>(); } // 插入数字到数据流 public void Insert(Integer num) { data.add(num); // 每次插入后排序，保持列表有序 Collections.sort(data); } // 获取当前数据流的中位数 public Double GetMedian() { int size = data.size(); if (size == 0) return 0.0; if (size % 2 == 1) { // 奇数个元素，返回中间值 return (double) data.get(size / 2); } else { // 偶数个元素，返回中间两个数的平均值 int mid = size / 2; return (data.get(mid - 1) + data.get(mid)) / 2.0; } }}插入操作：每次插入需要排序，时间复杂度O(n log n)获取中位数：直接通过索引访问，时间复杂度O(1)空间复杂度：O(n)，需要存储所有数据插入排序法在方法一基础上优化，在插入时就找到正确位置，避免每次都完整排序。同时利用二分查找找到插入位置，减少排序开销javaimport java.util.ArrayList;import java.util.List;public class MedianFinder2 { private List<Integer> data; public MedianFinder2() { data = new ArrayList<>(); } public void Insert(Integer num) { // 使用二分查找找到合适的插入位置 int left = 0, right = data.size() - 1; while (left <= right) { int mid = left + (right - left) / 2; if (data.get(mid) < num) { left = mid + 1; } else { right = mid - 1; } } // 在找到的位置插入元素 data.add(left, num); } public Double GetMedian() { int size = data.size(); if (size == 0) return 0.0; if (size % 2 == 1) { return (double) data.get(size / 2); } else { int mid = size / 2; return (data.get(mid - 1) + data.get(mid)) / 2.0; } }}插入操作：二分查找O(log n) + 插入操作O(n) = O(n)获取中位数：O(1)，通过索引直接访问优化效果：比方法一有明显提升，特别适合部分有序的数据双堆法是最高效的解法，利用大顶堆和小顶堆的特性来动态维护中位数，使用大顶堆存较小一半，小顶堆存较大一半⽤⼀个数字来不断统计数据流中的个数，并且创建⼀个最⼤堆，⼀个最⼩堆如果插⼊的数字的个数是奇数的时候，让最⼩堆⾥⾯的元素个数⽐最⼤堆的个数多 1 ，这样⼀来中位数就是⼩顶堆的堆顶如果插⼊的数字的个数是偶数的时候，两个堆的元素保持⼀样多，中位数就是两个堆的堆顶的元素相加除以2 。javapublic class Solution { private int count = 0; private PriorityQueue<Integer> min = new PriorityQueue<Integer>(); private PriorityQueue<Integer> max = new PriorityQueue<Integer>(new Comparator<Integer>() { public int compare(Integer o1, Integer o2) { return o2 - o1; } }); public void Insert(Integer num) { count++; if (count % 2 == 1) { // 奇数的时候，需要最⼩堆的元素⽐最⼤堆的元素多⼀个。 // 先放到最⼤堆⾥⾯，然后弹出最⼤的 max.offer(num); // 把最⼤的放进最⼩堆 min.offer(max.poll()); } else { // 放进最⼩堆 min.offer(num); // 把最⼩的放进最⼤堆 max.offer(min.poll()); } } public Double GetMedian() { if (count % 2 == 0) { return (min.peek() + max.peek()) / 2.0; } else { return (double) min.peek(); } }}插入操作：堆的插入操作O(log n)，平衡操作O(log n)，总体O(log n)获取中位数：直接访问堆顶元素，O(1)时间复杂度空间复杂度：O(n)，需要存储所有数据为什么这种方法有效？大顶堆（maxHeap）：存储数据流中较小的一半数字，堆顶是这一半中的最大值小顶堆（minHeap）：存储数据流中较大的一半数字，堆顶是这一半中的最小值平衡维护：确保两个堆的大小相差不超过1，这样中位数就只与两个堆顶有关转载自https://www.cnblogs.com/sevencoding/p/19468596

1、 使用Git实现revert的完整操作步骤【转载】cid:link_02、C++中new关键字用法示例详解【转载】cid:link_13、在C# WinForm项目中跨.cs文件传值的六种常用方案【转载】cid:link_24、 一文带你搞懂Java中Error和Exception的区别【转载】cid:link_35、 Java中实现Word和TXT之间互相转换的实用教程【转载】cid:link_46、MyBatis-Plus 默认不更新null的4种方法【转载】cid:link_57、SpringBoot接口防抖的5种高效方案【转载】cid:link_68、 Java中锁分类及在什么场景下使用【转载】cid:link_79、 Java中锁的全面解析之类型、使用场景、优缺点及实现方式(示例代码【转载】cid:link_810、 Caffeine结合Redis空值缓存实现多级缓存【转载】cid:link_911、在PostgreSQL中优雅高效地进行全文检索的完整过程【转载】cid:link_1012、MySQL CDC原理解析及实现方案【转载】cid:link_1113、 PostgreSQL优雅的进行递归查询的实战指南【转载】cid:link_1214、Redis 常用命令之基础、进阶与场景化实战案例【转载】https://bbs.huaweicloud.com/forum/thread-0212720487861500817-1-1.html15、Git中忽略文件机制的.gitignore与.git/info/exclude两种方式详解【转载】https://bbs.huaweicloud.com/forum/thread-0212720487688092711-1-1.html