"如果你一直拖着过去不放，就无法向前进步。"这正是我在代码审查时对团队说的话。然而，每次我打开一个拉取请求时，我仍然看到过时的Java特性、坏习惯和应该在几年前就被淘汰的编码习惯。所以，如果你今天在使用Java，无论你是初级、中级还是高级开发者，这篇文章都适合你 🫵 。其中一些观点可能会让你感到不舒服。有些可能与你所学的相违背。但这正是你应该读到最后的原因。

1. 错误使用 Optional.get()

Optional是一个很棒的特性，但我看到许多开发者误用了它：

这是错误的！

如果你在使用**Optional**，就要拥抱它的API：

2. 硬编码值而不是使用常量

这是我在代码中看到的最大罪过之一：

一个新的初级开发者加入团队，他不知道 3 是什么意思。然后他错误地修改了逻辑。砰。生产环境出现了bug。

正确的方式：

为什么？ 因为这样你的代码变得自文档化且安全。

3. 有缺陷的单例模式的双重检查锁定

经典错误：

除非使用volatile完美地完成，否则这在Java中是有缺陷的。在并发环境中可能出现微妙的错误。

这里是修复方法：

更好的方式：

这些方式安全、简单，并且避免了并发错误。

4. Vector 和 Hashtable

现在是2025年。然而，有时我仍然看到这样的代码：

Vector和Hashtable都是Java早期的遗留类。它们是同步的，因此比现代替代方案慢得多。

应该使用什么替代：

如果你需要线程安全，使用：

为什么要停止使用Vector和Hashtable？

• 在现代应用中性能差
• 存在更好的替代方案，对同步有更精细的控制

5. 原始类型

我仍然审查到这样的PR：

这是危险的💀。

原始类型移除了类型安全性，导致在运行时爆发的微妙错误。

正确的方式：

提示： 总是使用泛型。你的IDE会帮你早期发现错误。

6. StringBuffer（当你不需要同步时）

许多开发者使用这个：

但除非你在做多线程工作，否则StringBuffer是不必要的慢。

应该使用什么替代：

StringBuilder更快，对于单线程操作来说已经足够了，这是你大部分代码的情况。

7. 直接使用 SimpleDateFormat

这是连高级开发者都会犯的经典错误：

问题在哪里？🤔 SimpleDateFormat是不线程安全的。如果这段代码在Web应用或多线程环境中运行，它可能抛出奇怪的日期格式化错误。

应该使用什么替代：

新的java.time包（从Java 8开始）是线程安全的，并且远远优越。

8. 使用 System.out.println 进行日志记录

我实际上见过企业应用程序中有数百个**System.out.println()**语句。
当你调试生产问题时，你会后悔的。

正确的方式：

使用日志框架，如SLF4J with Logback或Log4j2：

• 你可以获得日志级别（info、debug、error）
• 你可以将日志重定向到文件
• 你可以控制日志格式和保留期

🙅‍♂️永远不要在生产代码中部署System.out.println

9. 过度使用同步而不是使用现代并发

许多开发者仍然这样做：

但Java已经发展了🪴。java.util.concurrent提供了强大、更安全、性能更好的工具：

• 使用ReentrantLock进行显式锁定
• 使用ConcurrentHashMap而不是同步映射
• 使用AtomicInteger、AtomicBoolean等
• 使用ExecutorService而不是手动管理线程

**除非绝对必要，否则避免使用synchronized。**并发很难——让现代库来帮助你。

10. 过时的集合API方法

我有时仍然看到这样的代码：

❌ 当你可以使用现代for-each循环时，停止使用Enumeration和Iterator：

这些更清洁、现代、更可读。

前言

Java 24 是平台演进过程中一个大胆而深思熟虑的重要里程碑。经验丰富的 Java 开发者不仅会欣赏这次发布的变化数量，更会被其深度和发展方向所震撼。本次发布包含 24 个 JEP，显而易见，OpenJDK 社区正在性能、可扩展性和现代开发需求方面全力投入。在这篇文章中，我将为大家详细介绍我认为对资深工程师最具影响力的五个特性：分代 Shenandoah（实验性）、紧凑对象头（实验性）、Stream Gatherers、提前类加载与链接，以及虚拟线程同步无钉扎。这些特性绝不仅仅是渐进式改进——它们体现了真正的架构思维和对 Java 未来发展方向的深远愿景。我们将深入了解它们的工作原理、核心优势，以及在实际应用中的重要意义——并在关键之处提供详细示例。实验性特性的加入也传达了一个更重要的信息：Java 不仅仅是在跟上时代步伐——它正在引领技术潮流，特别是在内存管理和并发处理领域。如果你正在构建现代高性能 Java 应用程序，这些变化绝对值得你深入理解。

让我们开始探索吧！

1. 分代 Shenandoah（实验性）

这是对 Shenandoah GC 的革命性增强，引入了全新的实验性分代模式（JEP 404）。如果你曾经因为 Shenandoah 在低延迟高响应应用中令人印象深刻的低暂停时间而青睐它，那么你一定会为它的最新进展感到兴奋——它现在将堆内存分为年轻代和老年代，将垃圾收集工作重点聚焦在最关键的地方——那些在应用程序中占主导地位的短生命周期对象。

启用此特性非常简单：

令人振奋的是，这项增强功能在保持我们期望的超低暂停时间的同时，还能显著减少内存占用和 CPU 开销。收集器会根据应用程序的行为模式智能调整分代大小，使其对具有大量短生命周期对象的工作负载特别有效。

这一发展使 Shenandoah 与 G1 和 ZGC 等其他现代收集器保持同步，同时保持其在最小化延迟方面的独特优势。虽然仍处于实验阶段，在生产环境部署前需要进行充分测试，但分代 Shenandoah 代表了 Java 垃圾收集领域的重要演进。它标志着一个更广泛的趋势，即高性能收集器越来越多地利用弱分代假设来优化内存管理效率。

2. 紧凑对象头（实验性）

Java 24 通过 JEP 450 的紧凑对象头为我们带来了令人兴奋的特性，这是 Project Lilliput 的核心组成部分。简单来说，这个实验性特性将 64 位系统上的对象头从 96-128 位大幅缩减到仅 64 位，这意味着堆内存中每个对象的内存开销都会显著减少。

想要体验吗？只需在 JVM 参数中添加以下配置：

该特性与压缩类指针协同工作（在大多数现代系统上默认启用），虽然你不会看到直接的代码变化，但内存分析工具会清晰地显示出差异。带来的好处非常显著——更小的堆内存占用、更高的部署密度（在相同硬件上运行更多实例），以及改进的数据局部性，从而获得更好的 CPU 缓存利用率和整体性能。

这对于内存密集型应用程序和注重内存占用的微服务架构特别有价值。亚马逊的测试甚至显示启用此特性后 CPU 使用率有所降低。在底层实现上，它将 64 位标记字和 32/64 位类字合并为单个 64 位字，并巧妙地为未来的 Project Valhalla 增强预留了一些位空间。需要注意的是，作为实验性特性，它确实存在一些限制——比如 22 位压缩类指针将你限制在大约 400 万个不同的类。对大多数开发者来说，这个限制已经足够，但如果你正在处理大型系统或涉及大量动态代码生成的场景，这个限制值得仔细考虑。这种对内存效率的专注体现了 Java 对云原生环境优化的坚定承诺，在云环境中每个字节都至关重要！

3. Stream Gatherers：增强流处理能力

Java 24 正式确定了 Stream Gatherers API（JEP 485），对于任何热爱使用流式编程的开发者来说，这都是一个颠覆性的改变。可以把它看作是我们一直在等待的缺失拼图——为你的流处理管道提供自定义中间操作的能力！

核心是全新的 Gatherer 接口，它允许你直接在流中定义复杂的转换逻辑。现在你可以调用新的 gather(Gatherer) 方法来整合这些自定义操作。每个 Gatherer 实现包含四个关键方法：初始化器、集成器、组合器和终结器——让你完全掌控元素的处理方式。

更令人惊喜的是什么？Java 在 java.util.stream.Gatherers 类中提供了现成可用的收集器。看看这个简洁的例子：

这个 API 极大地扩展了流式编程的能力边界——支持有状态转换、通过可重用的收集器提升代码可读性，甚至支持并行执行以获得性能提升。它为中间操作填补了 Collectors 长期以来为终端操作填补的相同角色。

经过几个预览版本的迭代，Stream Gatherers 已经成熟为一个稳定的、经过社区充分测试的 API，大大简化了以前需要复杂解决方案的数据处理任务。对于专业的 Java 开发者来说，这个特性意味着更简洁的代码、更少的外部依赖，以及表达数据转换逻辑的强大新方式。

4. AOT 类加载与链接：启动时间大幅提升

Java 24 引入了一个你绝对想要了解的激动人心的特性：提前（AOT）类加载与链接（JEP 483）。作为 Project Leyden 的重要组成部分，这项优化彻底解决了 Java 长期以来的痛点之一——启动性能问题。利用 AOT 类加载和链接无需对应用程序代码进行任何直接修改，性能优势在 JVM 的初始启动阶段就能立即体现出来。

简单来说，这个特性将类加载和链接过程（通常在运行时完成）提前到预执行阶段，将结果存储在缓存中以实现闪电般的启动速度。实现过程很简单，采用三阶段方法：

1. 使用 -XX:AOTMode=record -XX:AOTConfiguration=<path> 运行训练会话以识别要缓存的类
2. 使用 -XX:AOTMode=create -XX:AOTConfiguration=<path> -XX:AOTCache=<path> 创建 AOT 缓存
3. 在后续运行中仅使用 -XX:AOTCache=<path>

性能提升令人震撼——基准测试显示启动时间最多可提升 42%！"HelloStream" 测试从 0.031 秒优化到 0.018 秒，而 Spring 的 PetClinic 从 4.486 秒大幅提升到 2.604 秒。

这个特性建立在 AppCDS（JDK 11）的基础之上，但走得更远，不仅缓存解析后的字节码，还缓存类的完整加载和链接状态。虽然不像 GraalVM Native Image 那样激进，但它提供了实质性的改进，同时避免了相同的约束和构建复杂性。

对于快速启动至关重要的云原生和无服务器环境，这是一个巨大的突破。Spring Boot 和 Quarkus 等主流框架已经在积极进行集成工作。只需记住，你的训练运行应该准确反映应用程序的正常启动行为，以最大化性能收益。这一进步标志着解决 Java 历史性启动延迟问题的重要里程碑，同时为未来启动和预热性能的进一步增强奠定了坚实基础。

5. 虚拟线程同步无需固定

还记得在JDK 21–23中，当你的虚拟线程在同步块内遇到阻塞操作时，它会被固定到其承载平台线程上吗？

这基本上抵消了虚拟线程承诺的许多可扩展性优势。好消息是，在Java 24中，这个限制已经消失！

这就是它的精妙之处：你的代码无需任何修改。你现有的同步块现在可以与虚拟线程完美协作：

性能改进是革命性的。在 10,000 个并发请求的基准测试中，应用程序从 JDK 21 上的每秒 800.9 个请求飙升到 JDK 24 上惊人的每秒 4,264.4 个请求——完成任务的时间从 12.486 秒大幅缩短到 2.345 秒！参考

这项增强使虚拟线程适用于更广泛的应用场景，包括大量使用同步机制的遗留代码。你现在可以放心地采用虚拟线程，而无需大规模重构来用 ReentrantLock 替换 synchronized。

虽然少数边缘情况（本地代码交互、类初始化）仍可能导致钉扎，但对大多数应用程序的影响微乎其微。这项改进代表了 Java 并发演进的重要里程碑，可能会让许多开发者从复杂的响应式编程模型回归到更简单的每请求一线程方法。

1. 概述

机器学习（ML）和人工智能（AI）正在推动软件开发的变革，使系统能够通过数据学习并做出智能预测。

作为一名Java开发者，如果要训练自己的预测模型，是不是第一想到的还是把Python拿起来？其实不一定非要拿起Python，在Java领域也有自己的生产级机器学习工具，它支持分类、回归、聚类等常见任务，还能无缝对接 TensorFlow 等框架，用 Java 就能直接训模型、做预测！

它就是：Tribuo，是 Oracle 推出的面向生产环境的开源机器学习库，极大简化了健壮 ML 模型的构建与部署。与 Weka 和 Deeplearning4j 类似，Tribuo 支持多种机器学习任务，并能轻松集成到 Java 应用中。

接下来本文我们将了解 Tribuo 支持的多种机器学习算法，并以 UCI 红葡萄酒质量数据集为例，构建一个用于预测葡萄酒质量的回归模型。

2. 什么是 Tribuo？

Tribuo 是一个以 Java 为核心的机器学习库，支持：

• 监督学习：如回归、分类等
• 无监督学习：如聚类

此外，Tribuo 拥有强类型特性，能够强制输入输出类型一致，有效防止运行时错误，确保模型开发过程的规范性。

它支持以 ONNX（开放神经网络交换）格式导入和导出模型，便于与 TensorFlow、PyTorch 等主流 ML 框架集成。

另一个亮点是 provenance（溯源）追踪功能，可记录数据集、模型参数和训练配置等元数据，提升透明度和可复现性。

随着 AI 在企业级 Java 应用中的普及，Tribuo 为在 Java 系统中直接嵌入智能行为提供了实用工具包。

3. 支持的机器学习算法

Tribuo 支持多种机器学习任务，包括：

• 分类：预测离散类别或标签。例如，预测一支足球队是否会获胜，或根据质量阈值将葡萄酒分为好或坏。
• 回归：预测连续值，如葡萄酒质量分数或患者胆固醇水平。
• 聚类：在无标签数据中识别分组。例如，可以根据酸度、酒精含量等化学属性对葡萄酒进行分组，而无需知道其质量分数。

4. 搭建 Tribuo 项目

我们将通过构建一个葡萄酒质量回归预测模型，体验 Tribuo 的实际应用。

首先，在 pom.xml 中添加 Tribuo 依赖：

tribuo-all 依赖提供了加载和训练数据集所需的相关类。

然后，下载 UCI 红葡萄酒质量数据集，并放置到 src/main/resources/dataset 目录下。该数据集包含 11 个理化特征，如酸度和酒精含量：

quality 列是一个适合回归任务的连续数值。

最后，创建一个名为 WineQualityRegression 的类：

后续章节将在该类中实现训练和保存模型的相关逻辑。

5. 类级变量

接下来，定义如下类级变量：

上述代码中，我们定义了数据集路径和训练模型保存/加载路径。

随后，定义了四个变量，分别代表：

• Model —— 存储预测模型的类
• Trainer —— 可训练预测模型的接口
• Dataset —— 用于训练的数据集类

此外，我们显式指定了模型输出类型为 Regressor。

6. 加载与划分数据集

定义一个方法用于加载并划分数据集：

这里，我们用 CSVLoader 解析分号分隔的 CSV 文件并为回归任务做准备。RegressionFactory 用于创建回归输出，指定目标变量 quality 为连续变量。DataSource<Regressor> 保存解析后的数据。

随后，为了评估模型的泛化能力和表现，使用 TrainTestSplitter 将数据集按 7:3 划分为训练集和测试集。

7. 训练回归模型

由于葡萄酒质量分数为数值型，我们采用分类与回归树（CART）作为基学习器进行训练：

上述方法中，CARTRegressionTrainer 配置了无最大深度、每次分裂最少 6 个样本、以均方误差为分裂标准。随后，RandomForestTrainer 结合 10 棵 CART 决策树，并用 AveragingCombiner 平均预测结果。

train() 方法在 trainSet 数据集上训练模型，生成用于预测葡萄酒质量分数的 Model<Regressor>。

8. 评估

接下来，使用 RegressionEvaluator 评估模型在数据集上的表现，计算相关指标：

RegressionEvaluator 用于评估模型在数据集上的表现。我们将 MAE（平均绝对误差）、RMSE（均方根误差）和 R^2（决定系数）输出到控制台。

随后，调用 evaluate() 方法评估模型和数据集：

执行程序后，训练集和测试集的评估结果如下：

MAE 表示预测值与实际值的绝对差异，RMSE 表示预测值与实际值的平方差均值的平方根，R^2 表示模型对训练和测试数据方差的解释能力。

更低的 MAE 和 RMSE，以及更高的 R^2，意味着模型预测性能更优。

9. 保存模型

最后，将模型保存为文件以便后续复用：

上述代码通过 ObjectOutputStream 类将训练好的模型序列化保存到文件。这样，我们可以在后续预测中直接复用模型，无需重新训练。

10. 方法调用

现在，在 main() 方法中调用前面创建的方法：

编译代码后，模型会被保存到指定目录。

11. 使用模型

新建一个 WinePredictor 类，在 main() 方法中加载已保存的模型：

如前所述，Tribuo 对类型敏感，因此我们指定模型类型为 Regressor。

通过创建 ObjectInputStream 并传入模型路径来加载模型。

然后，创建一个 ArrayExample 对象，表示单个葡萄酒样本：

最后，使用 Prediction 类进行预测：

预测结果如下：

12. 总结

在本文中，我们学习了 Tribuo 及其特性，了解了其支持的部分机器学习算法，并通过回归算法训练了葡萄酒质量预测模型。

Java 8 引入的 Lambda 表达式曾被誉为编写简洁、函数式代码的革命性工具。但说实话，它们并不是万能钥匙。它有不少问题，比如它没有宣传的那么易读，在某些场景下还带来性能开销。

作为一名多年与 Java 冗长语法搏斗的开发者，我找到了更注重清晰、可维护性和性能的替代方案。本文将剖析 Lambda 的不足，分享真实的基准测试，并展示我实际采用的方案：包括代码、图示和一些经验之谈。

Lambda 的热潮

当 Lambda 在 Java 8 中出现时，社区一片沸腾。可以编写内联函数、用流式操作链式处理、拥抱函数式编程令人兴奋。我们可以这样写代码：

看起来优雅、简洁、现代。但在生产中用多了，问题逐渐显现。它们并不总比传统循环更易读，调试流很痛苦，某些情况下性能损耗也不能忽视。让我们深入看看这些问题。

Lambda 的不足

1. 可读性受损

Lambda 主张让代码更简洁，但简洁不等于清晰。嵌套的 Lambda 或复杂的流操作很容易变成谜题。

比如下面这个例子：

乍一看，对比传统循环很难理解：

传统循环虽然啰嗦，但一目了然。每一步都很明确，新手或未来的你都能轻松理解和维护。

2. 调试噩梦

你试过调试流操作吗？

Lambda 的堆栈跟踪一团糟，经常指向 Java 内部类而不是你的代码。复杂链路中异常冒泡时，定位问题尤其困难。

3. 性能开销

Lambda 和流在某些场景下会因对象创建、装箱/拆箱带来额外开销。

我用 JMH（Java 微基准测试工具）做了对比，测试了用流和传统循环对一百万整数进行过滤和求和。

基准测试设置

测试代码如下：

结果

在 Intel i7–12700H + JDK 17 下，循环始终更快：

• Stream ：12.5 毫秒/次（±0.3 毫秒）
• Loop ：8.2 毫秒/次（±0.2 毫秒）

流式写法因 Lambda 实例化和流管道搭建带来额外开销，尤其在大数据集下更明显。虽然流在并行处理时有优势，但大多数实际场景并不需要，顺序处理时性能损失很明显。

性能对比结论：在顺序任务中，流落后于循环。

我的替代方案

经历了 Lambda 的种种问题后，我更倾向于混合方案： 简单操作用显式循环 ， 需要函数式时用方法引用 ， 复杂逻辑用自定义工具类 。以下是我的实践经验。

1. 简单任务用显式循环

对于简单任务，没有什么比循环更好。它们可读、易调试、性能好。比如最近一个项目中处理用户数据：

这种写法自解释，调试也方便。

2. 可复用性用方法引用

需要函数式风格时，我更喜欢方法引用而不是 Lambda。它更明确、可复用。

例如，与其写：

不如这样写：

这样简洁又清晰，还能复用已有方法，减少样板代码。

3. 复杂逻辑用自定义工具类

复杂操作时，我会写工具类和静态方法，逻辑封装好，测试也方便。比如过滤和转换订单：

用法：

这种方式模块化、易测试，避免了流操作的混乱。

架构图

为了直观展示无 Lambda 的代码结构，这里有一张手绘风格的架构图：

这种结构让业务逻辑清晰可维护，工具类作为应用层和数据层的桥梁。

何时用 Lambda

我不是说 Lambda 毫无用处。在下面这些场景，它们还是非常好用的：

• 并行流 ，用于大数据集的 CPU 密集型任务；
• 简单、一次性的转换 ，且不会影响可读性时；
• 函数式接口 ，如 Comparator 或 Runnable。

但日常开发中，显式循环和工具类通常更具可读性、易调试、性能更好。毕竟开发者写代码不仅是给机器看，更是给人看。下一个读你代码的人（也可能是半年后的你）会感谢你选择了清晰而不是跟风。我见过团队为解读 Lambda 密集代码浪费数小时，也体会过调试流异常的痛苦。选择显式、模块化代码，让维护更轻松，团队士气更高。

总结

Java Lambda 曾被吹捧为革命，但其实利弊参半。它们简洁，却可能牺牲可读性、可调试性和性能。我更倾向于用显式循环、方法引用和自定义工具类，让代码更清晰、可维护、性能更优。基准测试不会说谎，易读的代码带来的轻松感也不会骗人。你觉得呢？欢迎评论区一起聊聊。

1. 简介

在本文中，我们将介绍 SootUp 库。SootUp 是一个用于对 JVM 代码进行静态分析的库，可以分析原始源代码或已编译的 JVM 字节码。它是对 Soot 库的彻底重构，目标是更加模块化、可测试、可维护和易用。

2. 依赖

在使用 SootUp 之前，我们需要在构建中引入最新版本（截至撰写时为 1.3.0）。

我们这里有几个不同的依赖，它们的作用如下：

• org.soot-uss:sootup.core 是核心库。
• org.soot-uss:sootup.java.core 是用于 Java 的核心模块。
• org.soot-uss:sootup.java.sourcecode 是用于分析 Java 源代码的模块。
• org.soot-uss:sootup.java.bytecode 是用于分析已编译 Java 字节码的模块。
• org.soot-uss:sootup.jimple.parser 是用于解析 Jimple（SootUp 用于表示 Java 的中间表示）的模块。

很遗憾，目前没有 BOM 依赖可用，因此我们需要单独管理这些依赖的版本。

3. 什么是 Jimple

SootUp 能够分析多种格式的代码，包括 Java 源代码、已编译的字节码，甚至 JVM 内部的类。

为此，它会将各种输入转换为一种名为 Jimple 的中间表示。

Jimple 的存在是为了以更易分析的方式，表达 Java 源代码或字节码能实现的所有功能。这意味着它在某些方面有意与原始输入不同。

JVM 字节码在访问某些值时采用基于栈的方式，这种方式对运行时非常高效，但对分析来说却很困难。Jimple 则将其转换为完全基于变量的方式，这样既能实现相同的功能，又更易于理解。

相反，Java 源代码虽然也是基于变量的，但其嵌套结构也让分析变得复杂。Jimple 会将其转换为扁平结构，便于工具分析。

Jimple 也可以作为一种我们可以直接读写的语言。例如，下面的 Java 源代码：

可以被写成如下 Jimple 代码：

虽然更为冗长，但功能完全一致。SootUp 提供了解析和生成 Jimple 代码的能力，便于我们在需要时以这种格式存储和转换代码。

无论原始代码来源如何，分析时都会被转换为这种结构。此时我们将操作如 SootClass、SootField、SootMethod 等类型，它们都直接对应这种中间表示。

4. 代码分析

在使用 SootUp 做任何事情之前，首先需要分析一些代码。这需要创建合适的 AnalysisInputLocation 实例，并基于它构建一个 JavaView。

具体创建哪种 AnalysisInputLocation，取决于我们要分析的代码来源。

最简单但实际用处较少的方式，是分析 JVM 自身的类。可以通过 JrtFileSystemAnalysisInputLocation 类实现：

更常用的是分析源码文件，可以用 OTFCompileAnalysisInputLocation：

它还支持一次分析多个源码文件：

也可以分析内存中的源码字符串：

最后，还可以分析已编译的字节码。通过 JavaClassPathAnalysisInputLocation，可指向任何 classpath（包括 JAR 包或 class 文件目录）：

此外还有其他标准方式，如直接解析 Jimple 表示、读取 Android APK 文件等。

拿到 AnalysisInputLocation 实例后，可以基于它创建 JavaView：

这样就能访问输入中的所有类型信息。

5. 访问类

在我们分析完代码并基于它构建了一个 JavaView 实例后，就可以开始访问代码的详细信息了，这首先从访问类开始。

如果我们已经知道要查找的具体类，可以直接通过全限定类名访问。SootUp 使用多种 Signature 类来描述我们想要访问的元素。在这里，我们需要一个 ClassType 实例。幸运的是，可以通过 SootUp 提供的 IdentifierFactory，利用全限定类名轻松生成：

构建好 ClassType 实例后，就可以用它来访问该类的详细信息：

也可以直接获取类，不存在时抛出异常：

拿到 SootClass 实例后，可以用它来检查类的各种属性，例如可见性、是否为具体类或抽象类等：

还可以遍历已解析的代码，比如访问父类或接口：

注意，这些方法返回的是 ClassType 而不是 SootClass 实例，因为无法保证这些类的定义一定在当前视图中，仅能获取它们的名称。

6. 访问字段和方法

除了类本身，还可以访问类的内容，比如字段和方法。

如果已经有了 SootClass 实例，可以直接查询其字段和方法：

与类之间的导航不同，这里可以安全地返回字段或方法的完整表示，因为它们一定在当前视图中。

如果已知具体字段名，可以直接访问字段：

访问方法稍微复杂一些，需要方法名和参数类型：

如果方法有参数，需要通过 IdentifierFactory 提供参数类型的 Type 实例：

这样可以在有重载方法时获取正确的实例。还可以列出所有同名重载方法：

同样，拿到 SootMethod 或 SootField 实例后，可以进一步检查其属性：

7. 分析方法体

拿到 SootMethod 实例后，可以分析方法体本身，包括方法签名、局部变量和调用图。

首先需要获取方法体：

有了方法体后，就可以访问方法体的所有细节。

7.1 访问局部变量

首先可以访问方法内所有可用的局部变量：

这会返回方法内所有可访问的变量。需要注意，这实际上是 Jimple 表示中的变量列表，因此会包含一些解析过程中生成的额外变量，且变量名可能与原始代码不同。

例如，下面的方法有 5 个局部变量：

这些变量包括：

• this
• I1 —— 方法参数
• I2 —— 变量“capitals”
• $stack3 —— 指向 System.out 的局部变量
• $stack4 —— 表示“Hello, ” + capitals 的局部变量

其中 $stack3 和 $stack4 是 Jimple 生成的，并不直接出现在原始代码中。

7.2 访问方法语句图

除了局部变量，还可以分析整个方法的语句图，即方法将执行的每条语句的详细信息：

这样可以获得方法将要执行的所有语句，顺序与实际执行一致。每个语句都实现了 Stmt 接口，代表方法可以执行的操作。

例如，前面的方法会生成如下结构：

看起来比我们实际写的代码多很多——实际上只有两行。这是因为这里展示的是 Jimple 的表示。我们可以逐步拆解其含义：

首先有两个 JIdentityStmt，分别代表传入方法的 this 和 I1（即第一个参数）。

接下来有三个 JAssignStmt，分别表示对变量的赋值：将 I1.toUpperCase() 的结果赋给 I2，将 System.out 赋给 $stack3，将“Hello, ” + I2 的结果赋给 $stack4。

之后是一个 JInvokeStmt，表示在 $stack3 上调用 println() 方法，并传入 $stack4。

最后是一个 JReturnVoidStmt，代表方法末尾的隐式返回。

这是一个没有分支和控制语句的简单方法，但可以清楚看到方法执行的每一步。对于 Java 应用中的任何操作，Jimple 都能完整表示。

8. 总结

本文简要介绍了 SootUp。这个库还有很多强大的功能等待探索。下次需要分析 Java 代码时，不妨试试 SootUp 吧！

感谢阅读！如果您学习过程中如遇困难？可以加入我们超高质量的技术交流群，参与交流与讨论，更好的学习与进步！

1. 简介

ActiveJ 是一个轻量级的 Java 框架，适用于高性能应用。我们可以用它来创建启动速度快、内存占用小的极简和模块化应用。它提供了异步 I/O、依赖注入、高效序列化和响应式编程支持等特性。

在本教程中，我们将讨论 ActiveJ 的主要特性，包括其 Inspect 模块、强大的事件循环和高级网络功能。

2. 注入

我们从 ActiveJ Inject 开始。它是一个轻量且性能优化的依赖注入库，可用于设置 bean 之间的依赖关系。让我们看看如何使用它。

2.1. 依赖

让我们将 Active Inject 依赖 添加到项目中：

2.2. 使用模块进行依赖注入

让我们创建一个仓库 bean：

在我们的 PersonRepository 中，只指定了对 DataSource 实例的依赖。现在让我们创建一个服务类：

在 PersonService 类中，我们指定了对 PersonRepository 的依赖。

接下来，让我们创建一个 PersonModule 类，在其中配置所有 bean 之间的关系：

我们继承了 AbstractModule 类。此外，我们提供了 PersonService、PersonRepository 和 DataSource 的 bean，并配置了它们之间的关系。

让我们测试依赖注入行为：

我们创建了PersonModule类的实例。然后，使用Injector获取了PersonService实例。可以看到，所有依赖都已被注入。

3. 异步 I/O

**ActiveJ Async I/O 提供了高效编写异步流程的组件。**我们将通过 Promises 和 Event Loop 等关键元素来理解这一特性。

3.1. 依赖

让我们添加activej-promise依赖：

3.2. Promise

让我们创建要用到的模型：

现在，给PersonRepository类添加一些逻辑：

我们添加了findPerson()方法，用于模拟按名称查找的过程。我们使用Promises.delay()延迟生成Person实例，结果被包装为Promise实例。

接下来，创建服务层要生成的另一个模型：

VerifiedPerson包含了人员信息和验证结果。

在PersonService类中添加业务逻辑：

在findPersonNotes()方法中，我们模拟获取人员备注的过程。结果同样用Promise.of()包装。

接下来，添加验证方法：

这里我们模拟了验证流程，根据人员描述添加验证结果。

最后，整合所有操作，完成流程：

在最终方法中，我们通过Promise类的combine()方法，将仓库的findPerson()和服务的findPersonNotes()两个 promise 合并。然后对模型进行验证，返回最终结果的`Promise_。

3.3. 事件循环

**ActiveJ 的 Eventloop 在事件循环和线程中异步执行代码。**让我们看看如何用它来运行基于Promise的流程：

我们从PersonModule获取了PersonService_。然后用Eventloop.create()创建事件循环实例，并用run()方法启动。接着调用findAndVerifyPerson()方法。如果漏掉run()_，此时会遇到如下异常：

4. HTTP 服务器

ActiveJ 的另一个强大特性是高性能异步 HTTP 服务器。

4.1. 依赖

首先添加 ActiveJ HTTP 依赖：

再添加 Jackson Databind 依赖：

4.2. REST 接口示例

现在，让我们通过 HTTP 接口暴露VerifiedPerson流程。首先是PersonController类：

这里我们实现了AsyncServlet接口并重写了serve()方法。在方法内部，获取PersonService的findAndVerifyPerson()结果。然后将其转为 JSON 并作为 HTTP 响应体返回，状态码为 200。异常情况单独映射，默认返回 500 状态码。

将该控制器加入依赖注入上下文：

我们将PersonController加入PersonModule并配置了其依赖。

最后，引入 HTTP 服务器代码：

我们完成了HttpServer实例的搭建。然后用 RoutingServlet 添加了 HTTP 路由映射。最后用listen()方法启动服务器，并准备了异步 HTTP 客户端。

现在调用接口并检查结果：

我们调用了接口并异步获取了预期结果。为了在测试后停止服务器，调用了Eventloop的breakEventloop()方法终止执行。

5. 总结

本文介绍了 ActiveJ 框架的关键特性。借助这些特性，我们已经可以构建高效轻量的 Web 应用。当然，该框架还远不止于此。

我们还可以用它进行数据处理、分布式系统等多种场景。其模块化特性帮助我们避免项目臃肿，只引入必要组件。

感谢阅读！如果您学习过程中如遇困难？可以加入我们超高质量的技术交流群，参与交流与讨论，更好的学习与进步！

Lombok作为一个广受欢迎的Java开发工具，通过注解的方式帮助我们消除样板代码，提升开发效率。但随着项目的发展，它也带来了一些令人困扰的问题：

🧙‍♂️ Lombok的问题

• 代码可读性差 - 大量使用@Data、@Builder等注解后，实际生成的代码变得不可见，增加了代码审查和维护的难度
• IDE支持不稳定 - 与IDE的集成经常出现问题，导致代码提示失效、编辑器卡顿等问题
• 运行时行为不可控 - 注解自动生成的方法（如equals、hashCode）可能产生意外的运行时行为
• 调试困难 - 由于代码是在编译时生成的，调试过程中难以追踪具体实现

这些问题导致团队在开发过程中经常遇到困惑："这个getter是从哪里来的？"、"为什么equals方法会这样实现？"。虽然表面上代码看起来简洁，但实际上增加了项目的维护成本。

🚪 是时候和 Lombok 分手了

有一天，我们决定移除Lombok! 然后，我们做了一个实验：

1. 用Java Records替换 @Data。
2. 用真正的构造函数替换 @Builder。
3. 用 MapStruct 替换那些笨重的 ModelMapper/Lombok DTO 组合。

结果怎样？一切都变好了！

🧾 为什么 Java Records > Lombok @Data

Lombok:

对比

Java Records:

哪一个更具可读性？更类型安全？更适合不变性？

Records:

• 默认是 final 且不可变的。
• 生成构造函数、equals、hashCode 和 toString——所有这些都是可见的。
• 与 IDE 和序列化工具配合良好。

额外好处：你不需要仅仅为了写一个有两个字段的类就引入一个外部依赖。

🎯 MapStruct：真正的映射，而非猜测

现在介绍另一位英雄：MapStruct。

我们曾经有这样的类：

然后是：

优雅，对吧？直到它不再优雅。

• 字段无声无息地停止了映射。
• 调试变成了一场猜谜游戏。
• 嵌套映射变成了噩梦。

使用 MapStruct，我们这样做：

编译时检查。清晰。明确。快速。

没有反射，没有运行时意外。只有可预测、可读、真正的映射。

🎁 我们获得了什么？

• 减少了 80% 的样板代码。 真的。
• 零 IDE 问题。 再也没有奇怪的自动补全 bug。
• 更好的入职体验。 新来的开发者不需要 Lombok 解码器。
• 编译时安全。 在映射错误在生产环境中造成麻烦之前就捕捉到它们。

🧠 最后的思考

Lombok 在它那个时代是很出色的，但是 Java 在不断进化了，是时候抛弃它了！

• 用 Records 替换 @Data。
• 放弃 @Builder 并使用构造函数（如果需要，可以使用 MapStruct 的构建器）。
• 用 MapStruct 替换 ModelMapper

你将会编写更少的注解，调试更少的 Bug，并最终真正地 掌控你自己的代码，然后睡个好觉，获得更多的头发！

在Java中，ThreadGroup.activeCount()方法用于返回线程组及其子组中活动线程的估计数量。本指南将介绍该方法的用法，解释其工作原理，并通过示例展示其功能。

目录

• 引言
• activeCount()方法语法
• 理解activeCount()
• 示例
  • 基本用法
  • 结合子组使用activeCount()
  • 实际应用案例
• 结论

引言

ThreadGroup.activeCount()方法可提供线程组及其任何子组中活动线程数量的估计值。这对于监控和管理应用程序中的线程活动很有用。

activeCount()方法语法

activeCount()方法的语法如下：

• 参数：此方法不接受任何参数。
• 返回值：线程组及其子组中活动线程的估计数量。

理解activeCount()

activeCount()方法返回的是估计值而非确切数量，因为线程数量会随着线程的启动和结束动态变化。该方法统计的线程包括当前线程组中的活动线程以及其任何子组中的线程。

示例

基本用法

为展示activeCount()的基本用法，我们创建一个简单示例，在一个线程组中添加多个线程，并获取活动线程的数量。

输出：

结合子组使用activeCount()

你也可以使用activeCount()方法统计包括子组中的线程。

输出：

实际应用案例：监控线程活动

在一个包含多个线程组的大型应用程序中，你可以使用ThreadGroup.activeCount()方法来监控和管理线程活动，确保资源得到有效利用，并识别线程使用中可能存在的问题。

输出：

结论

Java中的ThreadGroup.activeCount()方法提供了线程组及其子组中活动线程数量的估计值。通过使用此方法，你可以监控线程活动、有效管理资源，并识别线程使用中可能存在的问题。无论你处理的是简单的线程组还是复杂的线程层次结构，ThreadGroup.activeCount()方法都为管理和监控线程特定数据提供了可靠的工具。

在Java中，ThreadGroup.activeGroupCount()方法用于返回线程组中活动子组的估计数量。本指南将介绍该方法的用法，解释其工作原理，并通过示例展示其功能。

目录

• 引言
• activeGroupCount()方法语法
• 理解activeGroupCount()
• 示例
  • 基本用法
  • 结合嵌套组使用activeGroupCount()
  • 实际应用案例
• 结论

引言

ThreadGroup.activeGroupCount()方法可提供线程组内活动子组数量的估计值。这对于监控和管理应用程序中的线程组层次结构很有用。

activeGroupCount()方法语法

activeGroupCount()方法的语法如下：

• 参数：此方法不接受任何参数。
• 返回值：线程组中活动子组的估计数量。

理解activeGroupCount()

activeGroupCount()方法返回的是估计值而非确切数量，因为线程组的数量会随着线程组的创建和销毁动态变化。该方法统计的子组包括当前线程组中的活动子组以及这些子组内的任何子组。

示例

基本用法

为展示activeGroupCount()的基本用法，我们创建一个简单示例，在一个线程组中添加多个子组，并获取活动子组的数量。

输出：

结合嵌套组使用activeGroupCount()

你也可以使用activeGroupCount()方法统计包括嵌套组在内的子组数量。

输出：

实际应用案例：监控线程组层次结构

在一个包含多个线程组层次结构的大型应用程序中，你可以使用ThreadGroup.activeGroupCount()方法来监控和管理活动子组的数量，确保资源得到有效利用，并识别线程组管理中可能存在的问题。

输出：

结论

Java中的ThreadGroup.activeGroupCount()方法提供了线程组中活动子组数量的估计值。通过使用此方法，你可以监控线程组层次结构、有效管理资源，并识别线程组管理中可能存在的问题。

无论你处理的是简单的线程组还是复杂的嵌套线程组结构，ThreadGroup.activeGroupCount()方法都为管理和监控线程组数据提供了可靠的工具。

在Java中，ThreadGroup.enumerate()方法用于将线程组及其子组中的每个活动线程复制到指定的数组中。本指南将介绍该方法的用法，解释其工作原理，并通过示例展示其功能。

目录

• 引言
• enumerate(Thread[] list)方法语法
• 理解enumerate(Thread[] list)
• 示例
  • 基本用法
  • 结合子组使用enumerate(Thread[] list)
  • 实际应用案例
• 结论

引言

ThreadGroup.enumerate(Thread[] list)方法将线程组及其子组中每个活动线程的引用复制到指定的数组中。该方法对于监控和管理应用程序中的线程很有用。

enumerate(Thread[] list)方法语法

enumerate(Thread[] list)方法的语法如下：

• 参数： list：要将活动线程复制到的数组。
• 返回值： 放入数组中的线程数量。

理解enumerate(Thread[] list)

enumerate(Thread[] list)方法将线程组及其子组中每个活动线程的引用复制到指定的数组中。如果数组太小，无法容纳所有线程，多余的线程将被默默忽略。该方法提供了线程组在特定时间点的快照。

示例

基本用法

为展示enumerate(Thread[] list)的基本用法，我们创建一个简单示例，在一个线程组中添加多个线程，并将活动线程枚举到一个数组中。

输出：

结合子组使用enumerate(Thread[] list)

你也可以使用enumerate(Thread[] list)方法包含子组中的线程。

输出：

实际应用案例：监控和管理线程

在一个包含多个线程组的大型应用程序中，你可以使用ThreadGroup.enumerate(Thread[] list)方法来监控和管理活动线程，确保资源得到有效利用，并识别线程使用中可能存在的问题。

输出：

结论

Java中的ThreadGroup.enumerate(Thread[] list)方法提供了一种将线程组及其子组中每个活动线程的引用复制到指定数组的方式。通过使用此方法，你可以监控线程活动、有效管理资源，并识别线程使用中可能存在的问题。无论你处理的是简单的线程组还是复杂的线程层次结构，ThreadGroup.enumerate(Thread[] list)方法都为管理和监控线程特定数据提供了可靠的工具。

在Java中，ThreadGroup.getMaxPriority()方法用于返回线程组的最大优先级。本指南将介绍该方法的用法，解释其工作原理，并通过示例展示其功能。

目录

• 引言
• getMaxPriority()方法语法
• 理解getMaxPriority()
• 示例
  • 基本用法
  • 结合子组使用getMaxPriority()
  • 实际应用案例
• 结论

引言

ThreadGroup.getMaxPriority()方法用于获取线程组中线程能够拥有的最大优先级。该方法在管理和控制应用程序内的线程优先级方面非常有用。

getMaxPriority()方法语法

getMaxPriority()方法的语法如下：

• 参数：此方法不接受任何参数。
• 返回值：线程组的最大优先级。

理解getMaxPriority()

getMaxPriority()方法返回线程组中线程可以拥有的最大优先级。这个值在创建线程组时被设定，并且可以使用setMaxPriority()方法进行更改。线程组的最大优先级限制了该组内线程可以被分配的优先级。

示例

基本用法

为展示getMaxPriority()的基本用法，我们创建一个简单示例，获取线程组的最大优先级。

输出：

结合子组使用getMaxPriority()

你也可以使用getMaxPriority()方法来获取子组的最大优先级。

输出：

更改并获取最大优先级

你可以更改线程组的最大优先级，然后使用getMaxPriority()方法获取它。

输出：

实际应用案例：在多线程应用程序中控制线程优先级

在一个包含多个线程的大型应用程序中，你可以使用ThreadGroup.getMaxPriority()来控制和管理不同线程组内线程的优先级，确保关键线程获得更高优先级，不太重要的线程获得较低优先级。

输出：

结论

Java中的ThreadGroup.getMaxPriority()方法提供了一种获取线程组中线程最大优先级的方式。通过使用此方法，你可以在应用程序中管理和控制线程优先级，确保根据线程的重要性为其分配适当的优先级。

无论你处理的是简单的线程组还是复杂的线程层次结构，ThreadGroup.getMaxPriority()方法都为管理和监控线程优先级提供了可靠的工具。

在Java中，ThreadGroup.getName()方法用于返回线程组的名称。本指南将介绍该方法的用法，解释其工作原理，并通过示例展示其功能。

目录

1. 引言
2. getName()方法语法
3. 理解getName()
4. 示例
   • 基本用法
   • 结合子组使用getName()
   • 实际应用案例
5. 结论

引言

ThreadGroup.getName()方法会返回线程组的名称。这在识别和管理应用程序中的线程组时非常有用。

getName()方法语法

getName()方法的语法如下：

• 参数：该方法不接受任何参数。
• 返回值：线程组的名称。

理解getName()

getName()方法返回创建线程组时赋予它的名称。这个名称可用于识别线程组，尤其是在调试或监控线程活动时。

示例

基本用法

为展示getName()的基本用法，我们创建一个简单示例，获取线程组的名称。

输出：

结合子组使用getName()

你也可以使用getName()方法来获取子组的名称。

输出：

实际应用案例：在多线程应用程序中识别线程组

在一个包含多个线程和线程组的大型应用程序中，你可以使用ThreadGroup.getName()来识别和管理线程组，这会让监控和控制线程活动变得更加容易。

输出：

结论

Java中的ThreadGroup.getName()方法提供了一种获取线程组名称的方式。通过使用该方法，你可以在应用程序中识别和管理线程组，从而更轻松地监控和控制线程活动。

无论你处理的是简单的线程组还是复杂的线程层次结构，ThreadGroup.getName()方法都为管理和识别线程组提供了可靠的工具。

在Java中，ThreadGroup.getParent()方法用于返回当前线程组的父线程组。本指南将介绍该方法的用法，解释其工作原理，并通过示例展示其功能。

目录

• 引言
• getParent()方法语法
• 理解getParent()
• 示例
  • 基本用法
  • 结合嵌套组使用getParent()
  • 实际应用案例
• 结论

引言

ThreadGroup.getParent()方法返回当前线程组的父线程组。这有助于理解应用程序中线程组的层次结构和组织方式。

getParent()方法语法

getParent()方法的语法如下：

• 参数：此方法不接受任何参数。
• 返回值：该线程组的父线程组；如果该线程组没有父线程组，则返回null。

理解getParent()

getParent()方法返回当前线程组的父线程组。线程组可以组织成一个层次结构，除了根线程组外，每个线程组都有一个父线程组。这种层次结构有助于高效地管理和组织线程。

示例

基本用法

为展示getParent()的基本用法，我们创建一个简单示例，获取线程组的父线程组。

输出：

结合嵌套组使用getParent()

你也可以使用getParent()方法来获取嵌套线程组的父线程组。

输出：

实际应用案例：在多线程应用程序中管理线程组层次结构

在一个包含多个线程和线程组的大型应用程序中，你可以使用ThreadGroup.getParent()方法来理解和管理线程组的层次结构。这在调试和监控复杂线程组结构中的线程活动时特别有用。

输出：

结论

Java中的ThreadGroup.getParent()方法提供了一种获取线程组父线程组的方式。通过使用此方法，你可以理解和管理应用程序中线程组的层次结构，从而更轻松地监控和控制线程活动。

无论你处理的是简单的线程组还是复杂的线程层次结构，ThreadGroup.getParent()方法都为管理和理解线程组结构提供了可靠的工具。

在Java中，ThreadGroup.interrupt()方法用于中断线程组中的所有线程。本指南将介绍该方法的用法，解释其工作原理，并通过示例展示其功能。

目录

1. 引言
2. interrupt()方法语法
3. 理解interrupt()
4. 示例
   • 基本用法
   • 结合子组使用interrupt()
   • 实际应用案例
5. 结论

引言

ThreadGroup.interrupt()方法用于中断线程组及其子组中的所有线程。这在需要同时停止一组线程时非常有用。

interrupt()方法语法

interrupt()方法的语法如下：

• 参数：该方法不接受任何参数。
• 返回值：该方法不返回任何值。

理解interrupt()

interrupt()方法会遍历线程组及其子组中的所有活动线程，并对每个线程调用interrupt()。该方法不会中断非活动状态的线程。

示例

基本用法

为展示interrupt()的基本用法，我们创建一个简单示例，在一个线程组中添加多个线程，然后中断该线程组。

输出：

结合子组使用interrupt()

你也可以使用interrupt()方法来中断嵌套组中的线程。

输出：

实际应用案例：优雅停止一组工作线程

在多线程应用程序中，可能会有一组工作线程执行任务。使用ThreadGroup.interrupt()，当满足特定条件或应用程序关闭时，你可以优雅地停止所有工作线程。

输出：

结论

Java中的ThreadGroup.interrupt()方法提供了一种中断线程组及其子组中所有线程的方式。通过使用该方法，你可以高效地管理和控制线程的执行，确保在需要时可以优雅地停止线程组。无论你处理的是简单的线程组还是复杂的线程层次结构，ThreadGroup.interrupt()方法都为管理线程执行提供了可靠的工具。

在Java中，ThreadGroup.list()方法用于将线程组的相关信息打印到标准输出。本指南将介绍该方法的用法，解释其工作原理，并通过示例展示其功能。

目录

1. 引言
2. list()方法语法
3. 理解list()
4. 示例
   • 基本用法
   • 结合子组使用list()
   • 实际应用案例
5. 结论

引言

ThreadGroup.list()方法将线程组的相关信息打印到标准输出。这些信息包括线程组及其子组中所有活动线程的详细信息，主要用于调试目的。

list()方法语法

list()方法的语法如下：

• 参数：该方法不接受任何参数。
• 返回值：该方法不返回任何值。

理解list()

list()方法会打印当前线程组及其子组的相关信息，包括：

• 线程组的名称
• 线程组的最大优先级
• 线程组是否为守护线程组
• 线程组中的活动线程列表
• 活动子组列表

示例

基本用法

为展示list()的基本用法，我们创建一个简单示例，在一个线程组中添加多个线程，然后打印该线程组的信息。

输出：

结合子组使用list()

你也可以使用list()方法来打印嵌套线程组的信息。

输出：

实际应用案例：调试线程组活动

在多线程应用程序中，你可能需要调试和监控线程及线程组的活动。使用ThreadGroup.list()，你可以打印线程组及其线程的状态，这有助于识别问题并理解线程的组织方式。

输出：

结论

Java中的ThreadGroup.list()方法提供了一种将线程组及其子组的信息打印到标准输出的方式。通过使用该方法，你可以调试和监控线程活动，从而更轻松地理解应用程序中线程的组织和状态。

无论你处理的是简单的线程组还是复杂的线程层次结构，ThreadGroup.list()方法都为管理和识别线程组提供了可靠的工具。

在 Java 里，ThreadLocal.get() 方法主要用于提供线程局部变量。每个访问该变量的线程都有其独立初始化的变量副本。本指南会详细介绍该方法的使用方式、工作原理，并且通过示例来展示它的功能。

目录

1. 引言
2. get() 方法语法
3. 理解 get() 方法
4. 示例演示
   • 基础使用
   • 多线程环境下的 get()
   • 实际应用场景
5. 总结

1. 引言

ThreadLocal.get() 方法能够返回当前线程在这个线程局部变量中的值。它主要用于为每个线程维护一个独立的值，这样可以避免同步问题，确保线程安全。

2. get() 方法语法

get() 方法的语法如下：

返回值：当前线程在该线程局部变量中的值。

3. 理解 get() 方法

ThreadLocal.get() 方法会获取当前线程与特定 ThreadLocal 实例相关联的值。每个线程都有自己的线程局部变量副本，而 get() 方法就是返回当前线程的这个变量值。

4. 示例演示

基础使用

下面通过一个简单的例子来展示 get() 方法的基础用法，在这个例子中，每个线程都有自己唯一的值。

输出结果：

多线程环境下的 get()

可以在多线程中使用 get() 方法，为每个线程维护不同的值。

输出结果（示例）：

实际应用场景：在 Web 应用中存储用户信息

在 Web 应用里，可以利用 ThreadLocal 为不同线程处理的每个请求存储用户特定信息。

输出结果：

5. 总结

Java 中的 ThreadLocal.get() 方法可以创建和获取线程局部变量。使用这个方法，能够确保每个线程维护自己的变量副本，从而提升线程安全性，避免同步问题。不管是处理简单的线程局部变量，还是处理 Web 应用中复杂的用户特定信息，ThreadLocal.get() 方法都为管理线程特定数据提供了一种可靠的方式。

在 Java 中，ThreadLocal.initialValue() 方法用于设置线程局部变量的初始值。本指南将详细介绍该方法的使用方式、工作原理，并通过示例展示其功能。

目录

1. 引言
2. initialValue() 方法语法
3. 理解 initialValue()
4. 示例演示
   • 基础使用
   • 不同初始值的 initialValue()
   • 实际应用场景
5. 总结

1. 引言

ThreadLocal.initialValue() 方法用于返回当前线程在该线程局部变量中的初始值。该方法可被重写，从而为每个线程提供自定义的初始值。

2. initialValue() 方法语法

initialValue() 方法的语法如下：

返回值：当前线程在该线程局部变量中的初始值。

3. 理解 initialValue()

initialValue() 方法设计为供子类重写。默认情况下，它返回 null。当线程首次访问线程局部变量时，会调用 initialValue() 方法为该线程设置初始值。

4. 示例演示

基础使用

通过以下示例展示 initialValue() 的基础用法，每个线程将获得相同的初始值。

输出结果：

不同初始值的 initialValue()

可以通过 initialValue() 方法为每个线程提供不同的初始值。

输出结果（示例）：

实际应用场景：存储用户会话信息

在 Web 应用中，可以利用 ThreadLocal 为不同线程处理的每个请求存储用户会话信息。

输出结果：

5. 总结

Java 中的 ThreadLocal.initialValue() 方法允许为线程局部变量初始化自定义值。通过重写该方法，可以确保每个线程拥有唯一的初始值，从而提升线程安全性，避免同步问题。无论是处理简单的线程局部变量，还是 Web 应用中复杂的用户特定信息，ThreadLocal.initialValue() 方法都为管理线程特定数据提供了可靠的解决方案。

在 Java 中，ThreadLocal.remove() 方法用于移除当前线程在线程局部变量中的值。本指南将详细介绍该方法的使用方式、工作原理，并通过示例展示其功能。

目录

1. 引言
2. remove() 方法语法
3. 理解 remove()
4. 示例演示
   • 基础使用
   • 多线程环境下的 remove()
   • 实际应用场景
5. 总结

1. 引言

ThreadLocal.remove() 方法用于移除当前线程在线程局部变量中的值，确保该线程的线程局部变量被重置。这有助于防止内存泄漏并保证资源的正确管理。

2. remove() 方法语法

remove() 方法的语法如下：

参数：该方法不接受任何参数。
返回值：该方法不返回任何值。

3. 理解 remove()

ThreadLocal.remove() 方法用于移除当前线程与特定 ThreadLocal 实例相关联的值。调用 remove() 后，线程下次访问该线程局部变量时，它将被重新初始化为初始值；如果未设置初始值，则为 null。

4. 示例演示

基础使用

以下示例展示 remove() 方法的基础用法，每个线程设置并移除其线程局部变量的值。

输出结果：

多线程环境下的 remove()

可以在多线程中使用 remove() 方法，确保每个线程的值被独立移除。

输出结果（示例）：

实际应用场景：清理 Web 应用中的资源

在 Web 应用中，可以使用 ThreadLocal.remove() 在请求处理完成后清理与用户会话相关的资源，防止内存泄漏。

输出结果：

5. 总结

Java 中的 ThreadLocal.remove() 方法允许移除当前线程在线程局部变量中的值。通过使用该方法，可以防止内存泄漏并确保应用程序中的资源正确管理。无论是处理简单的线程局部变量，还是 Web 应用中复杂的用户特定信息，ThreadLocal.remove() 方法都为管理和清理线程特定数据提供了可靠的方式。

在 Java 中，ThreadLocal.set() 方法用于设置当前线程在线程局部变量中的值。本指南将详细介绍该方法的使用方式、工作原理，并通过示例展示其功能。

目录

1. 引言
2. set() 方法语法
3. 理解 set()
4. 示例演示
   • 基础使用
   • 多线程环境下的 set()
   • 实际应用场景
5. 总结

1. 引言

ThreadLocal.set() 方法用于为当前线程设置线程局部变量的值。该方法可确保不同线程维护独立的值，从而在无需同步的情况下保证线程安全。

2. set() 方法语法

set() 方法的语法如下：

参数：
value - 要设置给当前线程的线程局部变量的值。
返回值：该方法不返回任何值。

3. 理解 set()

ThreadLocal.set() 方法用于为当前线程的线程局部变量副本分配新值。每个线程拥有独立的变量副本，set() 方法允许更新当前线程的该值。

4. 示例演示

基础使用

以下示例展示 set() 方法的基础用法，每个线程设置并获取其线程局部变量的值。

输出结果：

多线程环境下的 set()

可以在多线程中使用 set() 方法，确保每个线程拥有唯一的值。

输出结果（示例）：

实际应用场景：管理 Web 应用中的用户会话

在 Web 应用中，可以利用 ThreadLocal 为不同线程处理的每个请求存储用户会话信息。

输出结果：

5. 总结

Java 中的 ThreadLocal.set() 方法允许为当前线程设置线程局部变量的值。通过使用该方法，可以确保每个线程拥有唯一的值，从而提升线程安全性，避免同步问题。无论是处理简单的线程局部变量，还是 Web 应用中复杂的用户特定信息，ThreadLocal.set() 方法都为管理和更新线程特定数据提供了可靠的解决方案。

在本教程中，我们将学习Java平台5.0版本引入的高级并发特性。

这些特性大多通过java.util.concurrent包实现。

一、Executor框架核心优势

Executor框架通过以下特性提升并发编程体验：

1. 任务与执行解耦：只需实现Runnable任务，无需关心线程创建/销毁
2. 线程池管理：
3. Callable接口增强：
   • 支持返回值（替代无返回的Runnable）
   • 通过Future对象管理任务状态

二、Executor接口体系

java.util.concurrent包定义了三级接口：

1. Executor 基础接口

• 核心方法：提交Runnable任务
• 实现类：ThreadPoolExecutor等

2. ExecutorService 扩展接口

• 支持提交Callable任务
• 提供任务生命周期管理（关闭、等待终止等）

3. ScheduledExecutorService 定时任务接口

• 支持延迟执行和周期性任务
• 返回ScheduledFuture对象

三、Future与Callable接口

1. Callable接口

• 替代Runnable的有返回值任务
• 允许抛出受检异常

2. Future接口

• 管理异步任务结果
• 支持取消任务和超时控制

四、Executors工厂类

提供便捷的线程池创建方法：

五、核心实现示例

1. 基础任务提交

2. Callable任务与Future

3. 定时任务示例

六、最佳实践建议

1. 优先使用工厂方法：通过Executors创建线程池，避免直接使用ThreadPoolExecutor构造函数
2. 合理配置线程池参数：
   • CPU密集型任务：线程数≈CPU核心数
   • I/O密集型任务：线程数可适当增加
3. 正确关闭ExecutorService：
4. 监控线程池状态：通过ThreadPoolExecutor的getActiveCount()等方法监控运行状态

通过本教程，您将掌握Java并发编程的核心工具，在保证线程安全的同时提升应用性能。

ExecutorService 是Java并发编程中管理线程池和异步任务执行的核心接口，属于java.util.concurrent包。它将任务提交与具体执行机制解耦，简化了多线程编程的复杂度。

目录

1. ExecutorService概述
2. 创建ExecutorService
3. 提交任务
4. 关闭ExecutorService
5. 完整示例
6. 处理Callable和Future
7. 定时任务示例
8. 总结

1. 概述

ExecutorService 是 Executor 的子接口，提供以下核心功能：

• 任务管理：提交Runnable/Callable任务并获取结果
• 生命周期控制：优雅关闭线程池
• 批量任务处理：invokeAll()、invokeAny()等方法

关键方法：

2. 创建

通过Executors工厂类创建不同类型的线程池：

3. 提交任务

提交Runnable任务

提交Callable任务

4. 关闭服务

优雅关闭流程

5. 完整示例

输出示例：

6. 处理Callable和Future

7. 定时任务

8. 总结

• 优势：线程复用、任务解耦、生命周期管理
• 最佳实践：
  1. 优先使用工厂方法创建线程池
  2. 始终调用shutdown()关闭线程池
  3. 对耗时操作使用Future处理异步结果
  4. 监控线程池状态（getActiveCount()等方法）

通过合理使用ExecutorService，可以显著提升Java应用的并发性能和可维护性。

ScheduledExecutorService 是Java并发编程中用于定时任务调度的核心接口，属于java.util.concurrent包。它扩展了ExecutorService，提供延迟执行和周期性任务的支持。

目录

1. ScheduledExecutorService概述
2. 创建定时任务执行器
3. 延迟执行任务（schedule）
4. 固定速率周期性任务（scheduleAtFixedRate）
5. 固定延迟周期性任务（scheduleWithFixedDelay）
6. 完整示例
7. 关闭执行器
8. 总结

1. 概述

ScheduledExecutorService 提供以下核心方法：

• 延迟执行：任务在指定时间后执行一次
• 周期性执行：任务按固定频率或固定延迟重复执行

关键方法对比：

2. 创建

通过Executors工厂类创建：

3. 延迟执行任务

输出：

4. 固定速率周期性任务

输出示例：

5. 固定延迟周期性任务

输出示例：

6. 完整示例

7. 关闭执行器

8. 总结

• 适用场景：定时任务、心跳检测、周期性数据同步等
• 注意事项：
  • 固定速率任务可能因执行时间过长而并发执行
  • 固定延迟任务的间隔基于任务结束时间计算
  • 始终调用shutdown()释放资源

通过合理使用ScheduledExecutorService，可以轻松实现复杂的定时任务调度需求。

Future 是Java并发编程中用于管理异步任务的核心接口，属于java.util.concurrent包。它代表异步计算的结果，提供检查任务状态、等待结果和取消任务等功能。

目录

1. Future接口概述
2. 核心方法详解
3. 与ExecutorService结合使用示例
4. 取消任务示例
5. 异常处理
6. 总结

1. 概述

Future 接口的核心功能：

• 异步结果管理：通过get()方法获取任务结果
• 任务状态查询：isDone()检查任务是否完成
• 任务控制：cancel()取消任务执行

典型使用场景：

2. 核心方法

3. 使用示例

输出示例：

4. 取消任务

输出示例：

5. 异常处理

输出示例：

6. 总结

• 适用场景：异步计算、非阻塞IO操作
• 最佳实践：
  1. 始终设置get()方法的超时时间
  2. 对可取消任务调用cancel(true)
  3. 使用isDone()避免不必要的阻塞
  4. 优先使用CompletableFuture替代原始Future

通过合理使用Future接口，可以显著提升Java应用的异步编程能力。

Callable 和 Future 是Java并发编程中处理异步任务的核心接口，属于java.util.concurrent包。Callable类似于Runnable，但支持返回结果和抛出受检异常；Future则代表异步计算的结果，提供任务状态管理和结果获取功能。

目录

1. Callable接口详解
2. Future接口详解
3. 与ExecutorService协同使用
4. 基础使用示例
5. 异常处理示例
6. 任务取消示例
7. 总结

1. Callable接口

Callable是一个函数式接口，定义如下：

• 特性：
  • 支持返回泛型结果V
  • 允许抛出受检异常
  • 替代无返回值的Runnable

2. Future接口

Future代表异步任务的结果，核心方法：

3. 与ExecutorService协同使用

通过ExecutorService提交Callable任务：

4. 基础使用示例

输出：

5. 异常处理示例

输出：

6. 任务取消示例

输出：

7. 总结

• Callable优势：支持返回值和异常处理
• Future功能：
  • 异步结果获取
  • 任务状态监控
  • 超时控制与取消
• 最佳实践：
  1. 始终设置get()方法的超时时间
  2. 使用CompletableFuture实现更复杂的异步编排
  3. 对可取消任务调用cancel(true)

通过Callable和Future的组合，开发者可以高效地管理异步任务，提升Java应用的并发性能。

Executors.newSingleThreadExecutor 方法用于创建一个使用单个工作线程的ExecutorService，任务将按提交顺序串行执行。

目录

1. newSingleThreadExecutor概述
2. 创建单线程执行器
3. 提交任务
4. 完整示例
5. 关闭执行器
6. 总结

1. 概述

newSingleThreadExecutor 创建的执行器特点：

• 单线程执行：确保任务按顺序执行
• 无界队列：未执行的任务在队列中等待
• 线程复用：唯一线程自动回收利用

语法：

2. 创建单线程执行器

3. 提交任务

输出示例：

4. 完整示例

输出：

5. 关闭执行器

优雅关闭流程

6. 总结

• 适用场景：
  • 需要保证任务顺序执行
  • 资源敏感型应用（限制线程数量）
• 优势：
  • 自动管理线程生命周期
  • 避免线程频繁创建/销毁开销
• 注意事项：
  • 无界队列可能导致OOM（内存溢出）
  • 单线程可能成为性能瓶颈

通过合理使用newSingleThreadExecutor，可以在需要顺序执行任务的场景中实现高效并发控制。

Executors.newFixedThreadPool 方法用于创建一个固定大小的线程池，适用于需要控制并发线程数量的场景。

目录

1. newFixedThreadPool概述
2. 创建固定线程池
3. 提交任务
4. 完整示例
5. 关闭线程池
6. 总结

1. 概述

newFixedThreadPool 创建的线程池特点：

• 固定线程数：通过参数指定线程数量
• 无界队列：未执行的任务在队列中等待
• 线程复用：线程执行完任务后返回池中

语法：

参数说明：

• nThreads：线程池中线程的数量

2. 创建固定线程池

3. 提交任务

输出示例：

4. 完整示例

输出：

5. 关闭线程池

优雅关闭流程

6. 总结

• 适用场景：
  • 需要控制并发线程数的计算密集型任务
  • 防止资源耗尽的场景
• 优势：
  • 线程数量固定，避免上下文切换开销
  • 无界队列自动缓冲任务
• 注意事项：
  • 无界队列可能导致内存溢出
  • 线程数应根据硬件资源合理配置

通过newFixedThreadPool可以有效管理并发线程，提升Java应用的性能和稳定性。

Executors.newCachedThreadPool 方法用于创建一个缓存型线程池，该线程池会根据任务负载动态调整线程数量，适用于提交大量短期异步任务的场景。

目录

1. newCachedThreadPool概述
2. 创建缓存型线程池
3. 提交任务
4. 完整示例
5. 关闭线程池
6. 总结

1. 概述

newCachedThreadPool 创建的线程池特点：

• 动态扩展：无任务时线程自动回收（60秒空闲后终止）
• 无界队列：提交的任务直接分配给可用线程
• 线程复用：优先使用已存在的线程

语法：

2. 创建缓存型线程池

3. 提交任务

输出示例：

4. 完整示例

输出：

5. 关闭线程池

优雅关闭流程

6. 总结

• 适用场景：
  • 短期异步任务（如HTTP请求处理）
  • 任务数量波动较大的场景
• 优势：
  • 自动适应负载变化
  • 减少线程创建/销毁开销
• 注意事项：
  • 可能因任务激增导致OOM（内存溢出）
  • 长期运行的任务不适合此线程池

通过合理使用newCachedThreadPool，可以在任务数量波动的场景中实现高效并发处理。

Executors.newScheduledThreadPool 方法用于创建一个固定线程数的定时任务执行器，支持延迟执行和周期性任务调度。

目录

1. newScheduledThreadPool概述
2. 创建定时任务执行器
3. 延迟执行任务
4. 固定速率周期性任务
5. 固定延迟周期性任务
6. 完整示例
7. 关闭执行器
8. 总结

1. 概述

newScheduledThreadPool 创建的执行器特点：

• 固定线程数：核心线程数通过参数指定
• 支持定时任务：
  • schedule()：延迟执行
  • scheduleAtFixedRate()：固定速率周期性执行
  • scheduleWithFixedDelay()：固定延迟周期性执行

语法：

参数说明：

• corePoolSize：线程池核心线程数

2. 创建定时任务执行器

3. 延迟执行任务

输出：

4. 固定速率周期性任务

输出示例：

5. 固定延迟周期性任务

输出示例：

6. 完整示例

7. 关闭执行器

8. 总结

• 适用场景：定时任务、心跳检测、周期性数据同步等
• 注意事项：
  • 固定速率任务可能因执行时间过长而并发执行
  • 固定延迟任务的间隔基于任务结束时间计算
  • 始终调用shutdown()释放资源

通过合理使用newScheduledThreadPool，可以轻松实现复杂的定时任务调度需求。

Java中的ThreadGroup类提供了一种将线程分组管理的机制。一个ThreadGroup可以包含多个线程甚至其他线程组，形成树状结构。这使得可以对一组线程进行统一管理和控制。

目录

1. ThreadGroup类概述
2. 创建线程组
3. 向线程组添加线程
4. 管理线程组
5. ThreadGroup方法
6. 示例：创建和管理线程组
7. 线程组层次结构
8. ThreadGroup的优缺点
9. 结论

1. ThreadGroup类概述

ThreadGroup类属于java.lang包，提供以下功能：

• 创建线程组
• 设置组内所有线程的最大优先级
• 处理组内所有线程的未捕获异常
• 中断、挂起或恢复组内所有线程

核心方法：

• activeCount()：返回组内活动线程的估计数量。
• activeGroupCount()：返回组内活动子组的估计数量。
• enumerate(Thread[] list)：将组内所有活动线程复制到指定数组。
• getMaxPriority()：返回组的最大优先级。
• interrupt()：中断组内所有线程。
• setMaxPriority(int pri)：设置组的最大优先级。
• uncaughtException(Thread t, Throwable e)：处理线程未捕获异常。

2. 创建线程组

通过指定名称或父组+名称创建线程组：

3. 向线程组添加线程

创建线程时指定所属线程组：

4. 管理线程组

对组内所有线程进行统一操作：

5. ThreadGroup方法详解

activeCount()

activeGroupCount()

enumerate(Thread[] list)

getMaxPriority()

interrupt()

setMaxPriority(int pri)

uncaughtException(Thread t, Throwable e)

6. 示例：创建和管理线程组

输出：

7. 线程组层次结构

线程组可以嵌套形成层级结构，根节点是系统线程组：

8. 优缺点

优点：

• 集中管理：统一操作组内所有线程
• 组织性强：按功能分组管理线程
• 异常处理：统一处理组内未捕获异常

缺点：

• 部分方法已过时（如suspend()、resume()）
• 功能有限：不如java.util.concurrent包强大

9. 结论

ThreadGroup提供了一种将线程分组管理的机制，适合需要统一控制一组线程的场景。但需注意其局限性，建议优先使用ExecutorService等现代并发工具进行复杂线程管理。

Java中的同步机制是一种强大的工具，用于控制多个线程对共享资源的访问。它确保同一时间只有一个线程可以访问资源，防止数据不一致和竞态条件。这在多线程环境中尤为重要，因为线程经常共享变量、数组或对象等资源。

目录

1. 同步概述
2. 同步方法
3. 同步块
4. 静态同步
5. 示例：同步方法
6. 示例：同步块
7. 可重入同步
8. 同步与性能
9. 结论

1. 同步概述

在Java中，synchronized关键字用于同步对代码临界区的访问。主要有两种同步方式：

• 同步方法：整个方法标记为synchronized，确保同一时间只有一个线程执行该方法。
• 同步块：方法内的特定代码块标记为synchronized，提供更细粒度的同步控制。

2. 同步方法

同步方法确保同一对象实例上的该方法同一时间只能被一个线程执行。锁由调用该方法的对象实例持有。

语法：

3. 同步块

同步块是方法内针对特定对象的同步代码块。它允许只锁定代码的关键部分而非整个方法。

语法：

4. 静态同步

静态同步确保获取的是类级锁，所有类实例共享同一把锁。

语法：

或使用同步块：

5. 示例：同步方法

代码示例：

输出结果：

代码解释：

• Counter类的increment方法被声明为synchronized。
• 两个线程各执行1000次increment操作。
• 最终计数为2000，说明同步机制避免了竞态条件。

6. 示例：同步块

代码示例：

输出结果：

代码解释：

• increment方法使用synchronized (this)同步块。
• 与同步方法示例效果相同，确保线程安全。

7. 可重入同步

Java的同步锁是可重入的。如果线程已持有某个对象的锁，它可以再次进入该对象的任何同步方法或块。

示例代码：

输出结果：

代码解释：

• method1调用synchronized的method2。
• 线程可重入已持有的锁，体现可重入性。

8. 同步与性能

同步虽然是线程安全的关键，但获取和释放锁的开销可能影响性能。为减少竞争，应尽可能缩小同步代码的范围。

9. 结论

Java同步机制用于确保多线程环境下的线程安全，防止竞态条件。通过同步方法、同步块和静态同步，可以控制多线程对共享资源的访问。但需谨慎使用同步，平衡线程安全与性能。

Java中的ThreadLocal类提供了线程本地变量。每个访问该变量的线程（通过get或set方法）都有自己独立初始化的变量副本。ThreadLocal是实现线程封闭的有效机制，确保每个线程拥有独立的变量实例，从而避免同步问题。

目录

1. ThreadLocal类概述
2. 创建ThreadLocal变量
3. 使用ThreadLocal变量
4. 示例：ThreadLocal的使用
5. 设置初始值
6. 可继承的ThreadLocal
7. 移除ThreadLocal变量
8. 使用场景
9. 结论

1. ThreadLocal类概述

ThreadLocal类为每个线程提供独立的变量副本。通常作为类的私有静态字段，用于将状态与线程关联。

核心方法：

• get()：获取当前线程的变量副本。
• set(T value)：设置当前线程的变量值。
• remove()：移除当前线程的变量副本。
• initialValue()：返回变量的初始值。

2. 创建ThreadLocal变量

通过实例化ThreadLocal类创建线程本地变量：

3. 使用ThreadLocal变量

各线程的变量副本相互独立，互不影响：

输出：

4. 完整示例

输出：

5. 设置初始值

通过withInitial或重写initialValue方法设置初始值：

6. 可继承的ThreadLocal

InheritableThreadLocal允许子线程继承父线程的变量值：

输出：

7. 移除变量

使用remove()方法释放资源，避免内存泄漏：

8. 使用场景

• 用户会话：存储线程特定的用户会话信息。
• 数据库连接：管理线程级别的数据库连接。
• 事务管理：处理线程独立的事务上下文。
• 日志上下文：存储日志相关的线程上下文。

9. 结论

ThreadLocal为Java提供了高效的线程本地变量管理方式，确保线程封闭性。通过合理使用ThreadLocal，可以有效避免同步问题，提升多线程程序的可维护性。但需注意及时清理不再使用的线程本地变量。

在Java中，每个线程都有一个用于标识的名称。默认情况下，Java虚拟机（JVM）会为线程分配默认名称（如"Thread-0"、"Thread-1"），但开发者也可以自定义线程名称。设置线程名称对调试和监控非常有用，能帮助快速识别多线程应用中的不同线程。

目录

1. 设置线程名称
2. 获取线程名称
3. 设置与获取线程名称示例
4. 使用Lambda表达式设置线程名称
5. 结论

1. 设置线程名称

通过Thread类的setName(String name)方法设置线程名称：

2. 获取线程名称

通过Thread类的getName()方法获取线程名称：

3. 设置与获取线程名称示例

输出：

4. 使用Lambda表达式设置线程名称

输出：

5. 结论

设置和获取线程名称是Java中简单但强大的功能，对调试和监控多线程应用非常有帮助。通过setName和getName方法，可以轻松识别和管理程序中的线程。本文通过Thread类和Lambda表达式两种方式展示了如何有效设置和获取线程名称。

Java中的interrupt方法用于中断当前运行的线程。该方法将线程的中断状态设置为true。如果线程处于阻塞状态（如等待、睡眠或I/O阻塞），则会抛出InterruptedException。被中断的线程可以捕获该异常并采取相应措施。

目录

1. 如何中断线程
2. 检查中断状态
3. 处理InterruptedException
4. 中断线程示例
5. 处理睡眠线程中断示例
6. 结论

1. 如何中断线程

通过调用线程实例的interrupt方法中断线程：

2. 检查中断状态

使用isInterrupted方法或静态的Thread.interrupted方法检查中断状态：

3. 处理InterruptedException

当线程在阻塞状态下被中断时（如睡眠或等待），会抛出InterruptedException，需使用try-catch块处理。

4. 中断线程示例

输出：

5. 处理睡眠线程中断示例

输出：

6. 结论

Java的interrupt方法用于控制线程执行流程。通过interrupt、isInterrupted和interrupted方法，可以优雅地处理线程中断。正确处理InterruptedException能确保线程在各种条件下可控地响应中断，使应用程序行为符合预期。

在Java中，每个线程都被赋予一个优先级，帮助线程调度器决定线程的执行顺序。线程优先级是一个整数，范围从Thread.MIN_PRIORITY（1）到Thread.MAX_PRIORITY（10）。默认优先级是Thread.NORM_PRIORITY（5）。线程调度器根据这些优先级决定各线程何时运行。但需注意，线程优先级不保证执行顺序，它仅仅是对线程调度器的一个建议。

目录

1. 设置线程优先级
2. 获取线程优先级
3. 示例：设置和获取线程优先级
4. 结论

1. 设置线程优先级

可以通过Thread类的setPriority(int newPriority)方法设置线程优先级。新优先级必须在Thread.MIN_PRIORITY和Thread.MAX_PRIORITY范围内。

语法：

2. 获取线程优先级

可以通过Thread类的getPriority()方法获取线程优先级。该方法返回线程优先级的整数值。

语法：

3. 示例：设置和获取线程优先级

通过以下示例演示如何设置和获取线程优先级：

示例代码：

输出结果：

代码解释：

• MyThread类继承自Thread类，并调用父类构造函数设置线程名。
• run方法打印当前线程的名称和优先级。
• 在main方法中：
  1. 创建三个自定义名称的MyThread对象。
  2. 使用setPriority方法设置线程优先级。
  3. 使用start方法启动线程。
  4. 使用getPriority方法打印线程优先级。

4. 结论

Java线程优先级是一个实用功能，可帮助线程调度器决定线程执行顺序。通过设置和获取线程优先级，您可以影响程序中线程的执行行为。但请记住：线程优先级仅仅是对调度器的建议，并不保证执行顺序。本指南通过示例演示了Java中设置和获取线程优先级的方法。

Java中的isAlive方法用于检查线程是否正在运行。如果线程已启动但尚未终止，返回true；否则返回false。该方法在需要等待线程执行完成后再继续其他任务时非常有用。

目录

1. 使用isAlive方法
2. 示例：检查线程是否存活
3. 示例：使用isAlive等待线程结束
4. 结论

1. 使用isAlive方法

isAlive方法属于Thread类，可在任意线程实例上调用以检查其存活状态。

语法：

2. 示例：检查线程是否存活

以下示例演示如何使用isAlive方法判断线程是否处于运行状态：

示例代码：

输出结果：

代码解释：

• MyThread类继承自Thread类并设置线程名称。
• run方法打印线程名称和迭代次数，每次迭代后休眠500毫秒。
• 在main方法中：
  1. 创建线程实例并检查启动前状态。
  2. 启动线程后再次检查状态。
  3. 使用join方法等待线程执行完毕。
  4. 最终检查线程状态。

3. 示例：使用isAlive等待线程结束

此示例演示如何通过循环调用isAlive方法等待线程执行完成：

示例代码：

输出结果：

代码解释：

• main方法中启动线程后，通过while循环持续检查线程状态。
• 主线程每次循环休眠200毫秒，避免过度占用CPU资源。
• 当线程执行完毕（isAlive返回false）时，循环终止并输出完成信息。

4. 结论

Java的isAlive方法用于检查线程状态。通过该方法，您可以判断线程是否处于运行状态，并在其执行完毕后再继续后续任务。这在多线程应用中协调多个线程时尤为有用。

Java中的sleep方法用于暂停当前线程的执行指定时间。该方法属于Thread类，允许临时挂起线程而不终止它。sleep方法可能抛出InterruptedException，因此必须使用try-catch块处理。

目录

1. sleep方法变体
2. 使用sleep(long millis)方法示例
3. 使用sleep(long millis, int nanos)方法示例
4. 处理InterruptedException
5. 结论

1. sleep方法变体

sleep(long millis)

暂停当前线程执行指定毫秒数。

sleep(long millis, int nanos)

暂停当前线程执行指定毫秒数+纳秒数。

2. 使用sleep(long millis)方法示例

输出：

3. 使用sleep(long millis, int nanos)方法示例

输出：

4. 处理InterruptedException

输出：

5. 结论

Java的sleep方法用于控制线程执行流程。通过sleep(long millis)和sleep(long millis, int nanos)方法，可精确控制线程暂停时间。处理InterruptedException至关重要，确保程序能优雅处理中断。

Java中的join方法用于暂停当前线程的执行，直到指定线程完成执行。当需要确保某个线程完成任务后再继续程序时，这个方法特别有用。join方法可以在线程实例上调用，有三种重载形式：join()、join(long millis)和join(long millis, int nanos)。

目录

1. join方法变体
2. 使用join()方法示例
3. 使用join(long millis)方法示例
4. 使用join(long millis, int nanos)方法示例
5. 结论

1. join方法变体

join()

暂停当前线程，直到指定线程执行完毕。

join(long millis)

暂停当前线程，等待指定毫秒数或线程完成（以先发生者为准）。

join(long millis, int nanos)

暂停当前线程，等待指定毫秒数+纳秒数或线程完成（以先发生者为准）。

2. 使用join()方法示例

输出：

3. 使用join(long millis)方法示例

输出：

4. 使用join(long millis, int nanos)方法示例

输出：

5. 结论

Java的join方法用于控制线程执行流程。通过join()、join(long millis)和join(long millis, int nanos)方法，可以确保某个线程完成后再继续其他线程的执行。这有助于协调任务，确保程序在必要条件满足后再继续运行。

Java中的Thread类是创建和管理线程的主要机制。每个线程代表程序中的一个独立执行路径，允许并发操作并提高应用程序的性能和响应能力。

目录

1. Thread类概述
2. 创建线程
   • 继承Thread类
   • 实现Runnable接口
3. 线程生命周期
4. 线程方法
5. 示例：继承Thread类
6. 示例：实现Runnable接口
7. 线程优先级
8. 线程同步
9. 线程间通信
10. 线程状态
11. 守护线程
12. 结论

1. Thread类概述

Java中的Thread类属于java.lang包，提供构造方法和管理线程的方法。线程通过同时执行多个任务，使程序运行更高效。

Thread类的关键方法：

• start()：启动线程执行
• run()：包含线程执行的代码
• sleep(long millis)：使线程休眠指定时间
• join()：等待线程结束
• interrupt()：中断线程
• isAlive()：检查线程是否存活
• getName()：获取线程名称
• setName(String name)：设置线程名称
• getPriority()：获取线程优先级
• setPriority(int priority)：设置线程优先级

2. 创建线程

继承Thread类

通过继承Thread类并重写run()方法创建线程：

实现Runnable接口

通过实现Runnable接口创建线程（推荐用于已继承其他类的情况）：

3. 线程生命周期

线程在生命周期中会经历以下状态：

• 新建（New）：线程已创建但未启动
• 可运行（Runnable）：线程准备运行，等待CPU调度
• 运行（Running）：线程正在执行
• 阻塞（Blocked）：线程等待监视器锁
• 等待（Waiting）：线程无限期等待其他线程操作
• 限时等待（Timed Waiting）：线程在指定时间内等待其他线程操作
• 终止（Terminated）：线程执行完毕

4. 线程方法

• start()：启动线程，JVM调用run()方法
• run()：线程执行体（用户自定义逻辑）
• sleep()：暂停当前线程指定时间
• join()：等待线程结束
• interrupt()：中断线程
• isAlive()：检查线程是否存活
• getName()/setName()：获取/设置线程名称
• getPriority()/setPriority()：获取/设置线程优先级（1-10，默认5）

5. 示例：继承Thread类

输出：

6. 示例：实现Runnable接口

7. 线程优先级

线程优先级决定执行顺序（1-10，默认5）：

输出：

8. 线程同步

通过synchronized关键字控制共享资源访问：

9. 线程间通信

使用wait()、notify()、notifyAll()实现协作：

输出：

10. 守护线程

守护线程是后台运行的低优先级线程（如垃圾回收）：

输出：

12. 结论

Java的Thread类提供了强大的多线程管理机制。通过继承Thread类或实现Runnable接口，开发者可以创建并发任务。理解线程生命周期、同步机制、线程间通信和守护线程等概念，是编写高效健壮多线程应用的关键。

Java中的多线程允许多个线程并发运行，从而能够同时执行多个任务。线程是程序中的轻量级进程，它们共享相同的内存空间。本指南将介绍在Java中使用两种主要方法创建和启动线程的基础知识：扩展Thread类和实现Runnable接口。

目录

1. 线程简介
2. 通过扩展Thread类创建线程
3. 通过实现Runnable接口创建线程
4. 使用Lambda表达式创建线程
5. 常用线程方法
6. 示例程序
7. 结论

1. 线程简介

线程是可以与其他线程并发运行的轻量级进程。Java通过java.lang.Thread类和java.lang.Runnable接口提供了对多线程的内置支持。多线程可以通过更好地利用系统资源来提高应用程序的性能。

2. 通过扩展Thread类创建线程

在Java中创建线程的一种方法是扩展Thread类并覆盖其run方法。

示例：

解释：

• MyThread类扩展了Thread类。
• run方法包含将由线程执行的代码。
• 在main方法中，创建了一个MyThread对象，并调用start方法来启动线程。

3. 通过实现Runnable接口创建线程

在Java中创建线程的另一种方法是实现Runnable接口，并将实现类的实例传递给Thread对象。

示例：

解释：

• MyRunnable类实现了Runnable接口。
• run方法包含将由线程执行的代码。
• 在main方法中，创建了一个MyRunnable对象，将其传递给Thread对象，并调用start方法来启动线程。

4. 使用Lambda表达式创建线程

从Java 8开始，您可以使用Lambda表达式以更简洁的方式创建线程。

示例：

解释：

• Lambda表达式用于定义Runnable接口的run方法。
• Lambda表达式被传递给Thread对象，并调用start方法来启动线程。

5. 常用线程方法

• start()：启动线程的执行。run方法由Java虚拟机（JVM）调用。
• run()：包含将由线程执行的代码。此方法由线程的start方法调用。
• sleep(long millis)：暂停当前线程的执行指定的毫秒数。
• join()：等待线程终止。此方法用于确保一个线程在另一个线程开始之前完成其执行。
• isAlive()：如果线程仍在运行或未终止，则返回true。

6. 示例程序

示例1：扩展Thread类

示例2：实现Runnable接口

示例3：使用Lambda表达式

7. 结论

在Java中创建和启动线程可以通过多种方法完成，包括扩展Thread类、实现Runnable接口以及使用Lambda表达式。每种方法都有其特定的用例和优势。了解这些方法和常见的线程操作可以帮助您在Java应用程序中有效地利用多线程。

Java中的Runnable接口是一个函数式接口，用于定义可被线程执行的任务。它提供了一种定义并发执行任务的方式，常与Thread类或java.util.concurrent包中的执行器结合使用。

目录

1. Runnable接口概述
2. 实现Runnable
3. 运行Runnable
4. 示例：实现并运行Runnable
5. 结合Executor使用Runnable
6. 使用Lambda表达式简化Runnable
7. 使用Runnable的优势
8. 结论

1. Runnable接口概述

Runnable接口是一个单方法接口，仅定义了run()方法，该方法包含线程要执行的任务代码。

2. 实现Runnable

要创建Runnable任务，需定义一个类实现Runnable接口并实现run()方法。

示例：

3. 运行Runnable

运行Runnable任务有两种常见方式：

• 通过Thread类
• 通过java.util.concurrent包中的执行器

通过Thread类运行：

4. 示例：实现并运行Runnable

完整示例：

输出：

说明：

• MyRunnable类实现Runnable接口并覆盖run()方法。
• 创建两个Thread对象，共享同一个MyRunnable实例。
• 两个线程并发执行run()方法。

5. 结合Executor使用Runnable

java.util.concurrent包提供ExecutorService接口和线程池实现，能更灵活高效地管理线程。

示例：

输出：

说明：

• 创建一个包含2个线程的固定线程池。
• 提交两个MyRunnable任务到执行器。
• 线程池中的线程并发执行run()方法。

6. 使用Lambda表达式简化Runnable

Java 8引入Lambda表达式后，可更简洁地创建Runnable实例。

示例：

输出：

说明：

• 使用Lambda表达式直接定义Runnable的run()方法。
• 创建两个Thread对象执行同一任务。

7. 使用Runnable的优势

• 任务与执行解耦：任务逻辑与执行线程分离。
• 设计灵活性：类可在实现Runnable的同时继承其他类。
• 支持线程池：可与Executor框架结合，优化线程管理。
• 代码简洁性：结合Lambda表达式减少冗余代码。

8. 结论

Runnable接口是Java多线程编程的核心工具，通过实现该接口，可定义能被线程或线程池执行的任务。结合Java 8的Lambda表达式，代码更简洁高效。掌握Runnable接口的使用对编写并发应用至关重要。

做个日常记录，今天调试一个使用Flux和R2DBC的应用，发现使用IDEA启动的时候报了下面的红色警告：

处理这个警告的方法有两个：

第一个方法：添加VM参数-Xshare:off

如何配置vm参数，之前在Java新特性中的Preview功能如何运行和调试一文中提过，具体参考下面的图，记得修改参数：

第二个方法：在IDEA的Setting中做如下配置

参考资料

• https://stackoverflow.com/questions/54205486/how-to-avoid-sharing-is-only-supported-for-boot-loader-classes-because-bootstra

有段时间没有更新IDEA了，早上看到 IntelliJ IDEA 2024.1 EAP 5发布的邮件提示，瞄了一眼，发现真的是越来越强了，其中不少功能对我来说还是非常有用的。也许这些能力对关注DD的小伙伴也有帮助，所以搞篇博客介绍和推荐一下。

Spring、Quarkus等主流框架的支持增强

1. Search Everywhere功能中增加Endpoints选项卡

具体如下图所示：

开发者可以在这里直接搜索通过Spring、Quarkus、Micronaut、Ktor实现的接口来找到具体的代码实现位置。这个功能非常实用，尤其是对于接手老项目的开发者来说，可以快速的定位接口实现来完成开发任务或问题排查。

2. 增强Spring Bean的自动补全和自动装配

IntelliJ IDEA 现在为应用程序上下文中的所有 Bean 提供自动补全功能，并自动连接它们。

如果 bean 通过构造函数具有自动装配依赖项，则相关字段也会通过构造函数自动装配。

同样，如果通过字段或 Lombok 的 @RequiredArgsConstructor 注释注入依赖项，则新 bean 会自动通过字段连接。

3. 增强 Spring 模型图

在该版本中用户访问Spring模型图变得更加容易，可以如下图这样点击Spring标识的行标记直接跳转：

也可以使用快捷键 ⌥⏎ (MacOS) 或 Alt+Enter（Windows）来生成和跳转。

同时，该版本还引入了新的图标，增强了 Spring 模型图的可视化内容，如：Components、Controllers、Repositories。此外，您现在可以方便地切换库中 Bean 的可见性（默认情况下是隐藏的）。

HTTP Client的改进

HTTP Client现在提供更多身份验证选项，包括 PKCE 授权代码和设备授予流程。它还支持令牌和身份验证请求的额外参数。

现在它可以自动处理 code_challenge 和 passes code_verifier 的生成，以便在 PKCE 请求中检索令牌。

这个版本的HTTP Client 可以使用 Netty 作为其低级网络库。通过支持 SSL、代理和 HTTP/2，使我们能够在 HTTP 客户端中实现 HTTP/2 的支持。

此外，HTTP Client的工具栏外观，也与新的 UI 风格保持一致，提供更加美观的用户体验。

GitHub Action的支持增强

1. Workflow 上下文的支持

现在可以为各种 GitHub Action上下文引入了广泛的自动完成支持，包括github.*、env.*、steps.*和inputs.*。

这个优化非常有用，可以有效的降低编写复杂工作流脚本的过程，开发人员不用再去频繁的搜索上下文中涉及的参数了。

该优化在YAML文件配置中也同样有效：

在YAML文件中，开发者还可以使用 branding 功能使用特定图标和颜色指示器自定义 GitHub 上操作的外观。

此功能使操作创建者能够在 GitHub Marketplace 和工作流程中直观地区分他们的操作，使它们更易于识别和用户友好。通过在 action.yml 文件中指定图标和颜色，开发人员可以一目了然地传达其操作的目的，从而增强整体用户体验。这种可视化定制有助于对操作进行分类，并帮助用户快速识别 CI/CD 管道所需的工具。

2. Docker 镜像自动补全

此增强功能在 GitHub 工作流程文件中提供image和tag建议，从而更轻松地将 Docker 容器集成到您的操作中。

3. JavaScript 文件路径补全

文件路径完成功能会自动建议文件路径，从而简化 JavaScript 操作的配置并简化工作流程执行。

其他更新

• 优化JSON schema的处理： 优化了 JSON 模式验证和完成背后的代码。因此，IDE 现在可以更快地处理此任务并减少内存消耗。在使用 Azure Pipelines 的现实文件中，架构检查现在速度提高了 10 倍。

• 现在可以在所有常见场景中轻松完成 HTTP Header，例如使用 Spring WebClient 和 RestAssured 测试。当遇到预期值时，会自动出现完成弹出窗口。

另外，DD最近把博客重新增加了板块，正在维护几个有意思的长期连载专栏，其中一个就是《玩转IDEA》，这次换了工具，直接采用电子文档的形式，阅读体验更好，​对这些内容感兴趣的，可以关注起来！

今早看到，IntelliJ IDEA 2024.2 发布的邮件提示，看了一眼这个版本更新的新特性真的太适合我了！也许这些能力对关注DD的小伙伴也有帮助，所以搞篇博客介绍和推荐一下。下面就来一起看看这个版本中推出的几个强大新特性。

Spring Data JPA 的即时查询

在2024.2 Ultimate版本中，对 Spring Data JPA 的支持做了增强。新功能允许您在不运行应用程序和分析日志文件的情况下查看方法将生成的查询。现在，开发者可以直接在 JPA 控制台中执行任何仓库的方法来快速验证数据库操作是否正确。

cron表达式的自动补全

相信每个Spring开发者都用过@Schedule来定义一些简单的定时任务，对于执行规则的定义使用CRON表达式是非常常用的，但是很多人对于编写CRON表达式并不那么熟悉。现在，2024.2 Ultimate版本可以解决这个问题了，当开发者在写好cron属性的时候，会弹出自动补全来给出提示，你可以看到各种基础模版，太方便了！

GraalJS 作为 HTTP 客户端的执行引擎

现在 HTTP 客户端中使用的 JavaScript 执行引擎升级为 GraalJS。 这将使得开发者可以在使用 IntelliJ IDEA 的 HTTP 客户端测试端点以及在 .http 文件中使用 JavaScript 处理结果时使用所有 GraalJS 功能，包括对 ECMAScript 2023 规范的完全支持。

日志管理增强

IntelliJ IDEA 2024.2 为 Java 和 Kotlin 引入了增强的日志管理。

新功能包括字符串文字和实参解析的高亮显示，让您可以从占位符无缝导航到对应实参，同时IDEA还可以检查出不匹配的log占位符和参数量：

对于 System.out.println 语句，现在支持一键转换成log形式：

运行时的性能图表

在 Run 工具窗口中实现了新的 Performance 标签页。 新的标签页提供实时 CPU 和内存图表，并允许您捕获代码的执行时间并直接在编辑器中查看来查明性能瓶颈。 此外，您还可以捕获内存快照来检查对象并找出内存泄漏的根本原因。

JSON、XML 和其他格式的字符串变量可视化工具

现在，调试和浏览复杂数据格式变得容易多了。更新后的调试器可以可视化 JSON、XML、HTML、JWT 和 URL 编码的字符串变量只需点击变量旁边的 View 链接，相关的可视化器便会根据变量的内容自动选择。

其他更新

• 更快开始编码：优化了IDEA的启动体验。开发者可以在IDEA没有完全启动完成的情况下，也能进行关键功能的访问和编码操作。

• Markdown支持数学语法，现在可以使用$插入内联数学表达式，使用$$插入包含数学内容的代码块。

• K2模式稳定性改进和性能提升：这种新的 Kotlin 支持机制为未来的 Kotlin 语言功能奠定了基础，也增强了 IDE 的稳定性和性能。 在 2024.2 版本中，K2 模式现在支持 gradle.kts 脚本、Kotlin Multiplatform (KMP) 项目、所有主要重构、代码高亮显示、调试等。 基准测试表明，K2 模式使 IntelliJ IDEA Ultimate 源库上的代码高亮显示性能几乎翻了一番。

更多关于本版本的更新内容，还可以查阅官方信息：https://www.jetbrains.com/idea/whatsnew/

如果您关注IDEA的内容，还可以查看近期整理的《玩转IDEA》专栏，这次换了工具，直接采用电子文档的形式，阅读体验更好，​对这些内容感兴趣的，可以关注起来！

早上给大家介绍了IDEA官方宣布正在开发一套全新的UI，但目前是预览版需要申请才能体验。

随后马上就有网友分享了，不需要申请直接就能激活体验的方法。

本期视频：https://www.bilibili.com/video/BV165411X7u7

只需要下面几步：

1. 下载最新的IDEA版本（DD尝试了2022.1版本，后面的版本应该都会包含，之前的版本不确定）

下载地址：https://www.jetbrains.com/zh-cn/idea/nextversion/

2. shift键连续按两次，搜索registry：

3. 找到ide.experimental.ui选项，勾选上

4. 重启IDE，成功切换！

5. 最后DD又折腾了一下主题，这下舒坦了！欢迎关注我的公众号：程序猿DD，后面继续分享下配置！

另外，给大家提一下，我最近把博客重新增加了板块，正在维护几个有意思的长期连载专栏，其中一个就是《玩转IDEA》，这次换了工具，直接采用电子文档的形式，阅读体验更好，​对这些内容感兴趣的，可以关注起来！点击直达：《玩转IDEA》

5月23日，JetBrains发布了一篇博文，透露他们正在实现一套全新的界面界面。

他们认为目前行业中的用户界面趋势已经发生了演变，很多新用户认为JetBrains IDE的界面过于笨重，而且过时。所以，团队做出了大胆的决定，将以全新的眼光来重新设计IntelliJ IDEA和相关IDE的外观和感觉。

而这次重新设计的核心目标就是降低视觉复杂性，提供对基本功能的轻松访问，并根据需要逐步展开复杂的功能，这就是目前JetBrains团队认为的干净、现代和强大的外观和感觉。

根据官博中的描述，新UI中的主要变更包括以下四个方面：

• 简化主工具栏：使用新VCS、Project以及Run小部件
• 新的工具窗口布局
• 新的浅色和深色主题
• 全新的图标

文章开头给出的预览对于这一核心设计理念的初步体现还是很明显，整体界面相比目前的IDEA是要简洁、干净很多的，那么根据需要逐步展开的强大功能会怎么样实现呢？可能还得真正用上了才有所体会吧。

目前因为还只是预览版本，如果要使用的话，可以通过官方给出了这个申请链接提交申请后试用，DD已经提交申请了，不知道什么时候可以通过，期待一下！

申请链接：https://www.jetbrains.com/lp/intellij-new-ui-preview/

当然了，如果你懒的申请也不要紧，关注我等我后续体验后给大家分享也是ok的。

另外，给大家提一下，我最近把博客重新增加了板块，正在维护几个有意思的长期连载专栏，其中一个就是《玩转IDEA》，这次换了工具，直接采用电子文档的形式，阅读体验更好，​对这些内容感兴趣的，可以关注起来！点击直达：《玩转IDEA》

在DD长期更新的Java新特性专栏中，已经介绍过Java 16中开始支持的新特性：record的使用。

之前只是做了介绍，但没有结合之前的编码习惯或规范来聊聊未来的应用变化。最近正好因为互相review一些合作伙伴的代码，产生了一些讨论话题，主要正针对于有了record之后，其实之前有些用Lombok的场景，是可以替换掉了。

今天我们就来小小的总结下，我们可以在哪些地方，利用record来替换Lombok。

Lombok的威力

Lombok是我一直都喜欢使用的工具，因为它可以让我们的代码变的更加整洁。比如：当我们要写一个User对象的时候，如果不使用Lombok，往往需要写这么多内容：

在有了Lombok之后呢，通过使用@Data注解，可以将以上内容缩减到只需要下面这几行即可：

@Data注解涵盖了@Getter、@Setter、@EqualsAndHashCode 和 @toString，所以一个注解就可以实现成员变量的Getter和Setter，equals和hashcode方法的重写，以及toString的重写。大大降低了代码量，让代码看上去更加整洁。

Lombok的问题

虽然Lombok可以帮助我们少些很多代码，但它依然有一些缺点，比如：

1. Lombok并非Java官方提供，而是第三方依赖，依靠社区维护。对于较新的Java版本通常都会存在兼容性问题，容易产生一些不可预知的奇怪错误。
2. IDE的兼容限制，并不是所有的IDE都可以完美兼容Lombok，所以可能也会因此产生一些奇怪的错误。

使用record来替代

在之前的Java 新特性：record一文中，已经提到过record类可以根据类的字段自动生成：构造函数、equals()、hashCode() 和 toString()。这个功能就跟上面我们演示的Lombok中的@Data非常类似。

写法的话也非常简单，只需要这样一行即可搞定：

可以看到该代码的整洁度比Lombok的实现更加干净。同时，最关键的一点，这是Java原生支持的，不需要引入任何第三方依赖！

record类定义完成了，具体使用的话就跟平时使用其他类一样，去创建实例和调用方法即可，比如下面这样：

只是，我们在使用的时候需要了解record自动生成的代码与Lombok的区别，就能马上上手。

比如，从上面的例子中我们可以看到一个区别：获取成员变量email的时候，这里并不想传统getter那样以getEmail()的形式生成。

哪些情况替代不了？

record类已经很强大，但目前并不能完全替代Lombok。主要原因如下：

1. record中定义的成员变量是final类型的，初始化后就不能修改了
2. record类不能被继承，所以也无法进一步扩展

因此，在用record替代Lombok的时候，更多用来定义静态变量，而不是可能会变化的实例变量。但是，由于record中也可以定义函数，所以对于一些对成员计算获得的内容，也可以实现和使用。

总结

Lombok和record都可以帮助我们编写更加整洁的代码。前者是第三方库，可能存在一些不可预知的问题和IDE兼容问题，但功能更加全面和强大；后者属于Java原生的能力，功能虽弱一些，但用好它也能帮助我们减少很多代码的编写，且IDE兼容性更好。

好了，今天的分享就到这里。如果您学习过程中如遇困难？可以加入我们超高质量的技术交流群，参与交流与讨论，更好的学习与进步！更多Java新特性教程可以点击直达！，欢迎收藏与转发支持！

之前，在Java新特性专栏中，我们简单介绍了Java 21正式发布的虚拟线程。

昨天，正好看到一个讲解此内容的视频，非常不错，所以DD这里给大家翻译好了，感兴趣的可以看看。可以进一步了解虚拟线程。

G1垃圾回收器是在Java7 update 4之后引入的一个新垃圾回收器，主要目的是用来替代CMS。

G1最大的特点是引入分区的思路，弱化了分代的概念，合理利用垃圾收集各个周期的资源，解决了其他收集器甚至CMS的众多缺陷。从而实现进一步降低暂停时间的同时，兼顾良好的吞吐量。

那么G1垃圾回收器的细节是怎么样的呢？

这里DD找到一个不错的视频，里面包含想的图示说明和代码案例，可以帮助您更好的理解G1垃圾回收器：

读取文件内容，然后进行处理，在Java中我们通常利用 Files 类中的方法，将可以文件内容加载到内存，并流顺利地进行处理。但是，在一些场景下，我们需要处理的文件可能比我们机器所拥有的内存要大。此时，我们则需要采用另一种策略：部分读取它，并具有其他结构来仅编译所需的数据。

接下来，我们就来说说这一场景：当遇到大文件，无法一次载入内存时候要如何处理。

模拟场景

假设，当前我们需要开发一个程序来分析来自服务器的日志文件，并生成一份报告，列出前 10 个最常用的应用程序。

每天，都会生成一个新的日志文件，其中包含时间戳、主机信息、持续时间、服务调用等信息，以及可能与我们的特定方案无关的其他数据。

我们的代码将收到日志文件列表，我们的目标是编制一份报告，列出最常用的 10 个服务。但是，要包含在报告中，服务必须在提供的每个日志文件中至少有一个条目。简而言之，一项服务必须每天使用才有资格包含在报告中。

基础实现

解决这个问题的最初方法是考虑业务需求并创建以下代码：

该方法接收文件列表作为参数，核心流程如下：

• 创建一个包含每个文件条目的映射，其中Key是 LocalDate，Value是文件行列表。
• 使用所有文件中的唯一服务名称创建字符串列表。
• 生成所有服务的统计信息列表，将文件中的数据组织到结构化地图中。
• 筛选统计信息，获取排名前 10 的服务调用。
• 打印结果。

可以注意到，这种方法将太多数据加载到内存中，不可避免地会导致 OutOfMemoryError

改进实现

就如文章开头说的，我们需要采用另一种策略：逐行处理文件的模式。

• 首先，它声明一个Map（compiledMap），其中一个String作为键，代表服务名称，以及一个Counter对象（稍后解释），它将存储统计信息。
• 接下来，它逐一处理这些文件并相应地更新compileMap。
• 然后，它利用流功能来： 仅过滤具有全天数据的计数器；按调用次数排序；最后，检索前 10 名。

在看整个处理的核心processFile方法之前，我们先来分析一下Counter类，它在这个过程中也起到了至关重要的作用：

• 它包含三个属性：serviceName、numberOfCalls 和 daysWithCalls
• numberOfCalls 属性通过 add 方法递增，该方法为 serviceName 的每个处理行调用。
• daysWithCalls 属性是一个 Java BitSet，一种用于存储布尔属性的内存高效结构。它使用要处理的天数进行初始化，每个位代表一天，初始化为 false。
• setDay 方法将 BitSet 中与给定日期位置相对应的位设置为 true。

allDaysSet 方法负责检查 BitSet 中的所有日期是否都设置为 true。它通过将 BitSet 转换为布尔流，然后使用逻辑 AND 运算符减少它来实现此目的。

• 该过程使用Files类的lines方法逐行读取文件，并将其转换为流。这里的关键特征是lines方法是惰性的，这意味着它不会立即读取整个文件；相反，它会在流被消耗时读取文件。
• toLogLine 方法将每个字符串文件行转换为具有用于访问日志行信息的属性的对象。
• 处理文件行的主要过程比预期的要简单。它从与serviceName关联的compileMap中检索（或创建）Counter，然后调用Counter的add和setDay方法。

正如我们所看到的，在 Java 中处理大文件而不将整个文件加载到内存中并不是什么复杂的事情。 Files类提供了逐行处理文件的方法，我们还可以在文件处理过程中利用哈希来存储数据，这有助于节省内存。

分享8个开箱即用的API，方便日常处理集合。

1. 快速过滤空值：Stream.ofNullable

该方法是在 Java 9 中引入的，有助于过滤集合中的所有空值，从而可能使我们避免空指针异常。

在下面的示例中，有一个包含 null 的List。此时，我们可以使用Stream.ofNullable方法对其进行过滤。

执行上述代码，将输出：

2. 流式迭代：Stream.iterate()

Stream.iterate()方法用于创建无限的序列流。它采用种子和一元函数，将函数应用于前一个元素。

在下面的例子中，我们的种子是0，一元运算函数是 n -> n+2。

执行上述代码，将输出：

注意：由于Stream.iterate()生成的是无限序列流。因此我们应该定义终止条件，例如：limit、findFirst 或 findAny 等，以避免无限循环。

3. 集合转换：collectingAndThen()

collectingAndThen()方法是在 Java 8 中引入的。它是一种特殊的收集器，允许您对另一个收集器的结果执行特殊类型的转换。

在下面的示例中，我们的收集器通过首先使用索引到大写操作进行映射，然后使该映射成为不可修改的Map进行转换。

执行上述代码，将输出：

4. 删除和截取：dropWhile()、takeWhile()

dropWhile()和takeWhile()方法是在 java9 中引入的，用于连续处理流。

• takeWhile()：返回符合条件的元素流
• dropWhile()：从元素流中删除符合条件的元素

在下面的示例中，我们删除小于3的元素，然后返回元素小于6的元素流。

执行上述代码，将输出：

5. 整数流：IntStream

IntStream 在 Java 8 中引入，用于快速生成整数流，常用有的以下两个方法：

• IntStream.range() 方法生成一个整数流，该整数流不包含结尾数字
• IntStream.rangeClosed() 方法生成一个整数流，该整数流包含结尾数字

下面的例子，可以清晰的看到区别：

6. 应用多个收集器：teeing()

Java 12 中引入的teeing()方法是为了我们可以在元素流上一起应用两个单独的收集器而创建的。

在下面的示例中，我们使用teeing()计算元素流的最大值和最小值，然后将结果以Map形式返回。

执行上述代码，将输出：

7. 合并流：Stream.concat()

Stream.concat()方法可以用来连接两个流并生成一个新流。

执行上述代码，将输出：

8. 分组：Collectors.partitioningBy

Collectors.partitioningBy可以用来对流进行分组。

在下面的示例中，我们根据元素的字符串长度分为两个不同的组。

执行上述代码，将输出：

今天的分享就到这里。如果您学习过程中如遇困难？可以加入我们超高质量的技术交流群，参与交流与讨论，更好的学习与进步！

IDEA是目前Java体系最为强大的开发工具，但也因为强大，有很多功能可能你并不知道。

所以，本文档讲帮助你了解IDEA更多牛x的功能、还会给你推荐很多有意思的插件！

今天一大早，群里（点击加群）有小伙伴问了这样的一个问题：

在我们使用IDEA开发项目的时候，通常都会有很多配置项需要去设置，比如对于Java项目来说，一般就包含：JDK配置、Maven配置等。那么如果想要设置一个默认的项目配置的话，要如何做呢？

先来找到入口，在File菜单中找到New Projects Setup菜单项，细节如下图所示：

这里的几个功能都是用来配置新建项目时要做的一些默认选项。

新建项目的基础默认配置

通过Preferences for New Projects...可以配置新建项目的基础默认配置，包括外观、编辑器、版本控制、构建、执行、部署等一系列的基础内容：

这里也包括群友（点击加群）问的，如何设置默认Maven版本的配置，就可以在这里通过搜索Maven来找到配置的地方：

新建项目的运行模版

第二个菜单项Run Configuration Templates...可以用来配置我们常用的运行配置模版，比如：如果你也用一些agent来辅助开发调试的话，就可以在下图VM options输入框中加入启动参数，这样你就不需要为每个新项目手工配置了。

默认SDK的设置

第三个菜单项Structure...可以用来配置新建项目的默认SDK：

项目模版的管理

上面的所有配置主要是作为默认配置来使用，但默认配置只能有一种，可以视为最常用的配置，其他配置只是偶尔使用的时候，还比较有效。但有时候我们又有可能有多种不同的常用配置，这个时候仅仅依靠默认配置就不太够了。

此时下面的两个菜单项Save Project as Template和Manage Project Templates功能则提供了更好的支持。我们可以通过Save Project as Template将一个现存的项目报错为模版，而在Manage Project Templates里可以对模版进行管理。

然后当我们要新建项目的时候，就可以在左侧最下方找到我们创建的各种项目模板来实现新项目的创建：

好了，今天的分享就到这里，如果这个小技巧对你有用，那就帮忙点赞、在看、分享、关注，四连支持一下吧！如果你觉得这个系列还不错，可以关注我在连载的这个专栏：玩转IDEA。