超级会员免费看
Java 应用性能优化指南：剖析、陷阱与池化策略
1. 性能分析与负载测试
在开发应用程序时，性能是一个关键考量因素。性能分析工具能帮助我们过滤非自身编写的代码，如 Servlet 引擎、数据库驱动和第三方框架代码，从而快速聚焦应用中的特定热点，找出可优化的部分。这是市面上商业性能分析工具的常见功能。
负载测试工具与性能分析工具相辅相成。它模拟大量用户访问 Web 应用的页面，以此测试应用在负载下的性能表现。为了让性能分析工具更准确地反映应用在真实环境中的表现，我们需要进行超出单个开发者能力范围的压力测试。曾经有个团队通过内部通讯系统通知大量开发者同时访问网站，但这只是让前台接待员不胜其烦，并非合理的性能测试方式。
市面上有许多商业负载测试产品，Mercury Interactive 的 Load Runner 通常被认为是其中的佼佼者，但它价格昂贵，大多数面向企业开发的工具都是如此。而开源的负载测试工具 JMeter 提供了一些类似的功能。
JMeter 是一个基于 Swing 的应用程序，可模拟向应用（包括 Web 应用）发起的各种请求。开发者可以设置线程组，每个线程组有特定的用途。例如，可以设置一个线程组定期向特定页面发起 HTTP 请求并发送特定请求参数。此外，JMeter 还支持建立 FTP、JDBC 等多种负载测试请求。
JMeter 包含用于展示负载测试结果的图表和表格。开发者可以设置测试计划并自定义其中的各种负载测试。以下是 JMeter 中一个展示吞吐量的图表示例：
在这个图表中：
| 线条位置 | 含义 |
| — | — |
| 顶线 | 2000 个独立样本随时间的吞吐量 |
| 底线 | 与平均值的偏差 |
| 倒数第二线 | 数据吞吐量 |
| 从上往下第二条线 | 平均吞吐量 |
所有这些数据都可自定义并保存到文件中，测试计划以特定文件格式保存，可重复使用。
JMeter 还提供了众多监听器，用于报告正在进行的负载测试结果。监听器是附加到特定测试的报告工具，上述图表就是一个例子，另一个例子是展示平均吞吐量随时间变化的样条图，它能揭示应用在性能开始下降前可处理的用户（线程）数量。JMeter 不要求以特定格式展示测试结果，监听器的存在是为了让开发者能将所需的结果类型附加到给定测试中。
JMeter 包含大量预建的测试工件，也允许开发者构建自己的测试。它高度可定制，还提供非可视化模式以实现测试自动化。由于它是开源的，使用成本主要在于学习如何使用它。掌握之后，如果需求允许，可以考虑转向更昂贵但功能更强大的商业产品。
2. 性能分析框架的性能表现
框架的性能特征在很大程度上取决于其相对大小。一般来说，轻量级框架（如 Struts）比重量级框架（如 Tapestry 或 Cocoon）使用更少的内存和其他资源。然而，这种衡量方式具有欺骗性。虽然 Struts 看起来更高效，但它完成的工作不如 Tapestry 多。Tapestry 已经包含了许多性能增强技术，例如它对应用中的许多资源进行了池化处理，这使得对这两个框架进行“公平”比较变得困难。
不过，我们可以对两个框架进行合理的负载测试，因为负载测试更能反映应用在运行时的性能。在这种情况下，Tapestry 中的额外代码应该能使其在高负载下表现更好，毕竟这些额外代码就是为此而存在的。
但这种策略不适用于像 Cocoon 这样的框架，它不仅仅是一个 Web 框架，还包含发布框架代码，因此通常运行速度较慢，因为它需要完成更多的工作。最终，我们需要根据使用框架的目的和方式来评判其性能。
3. 常见性能陷阱
在开发过程中，我们应尽量避免引入性能瓶颈。以下是一些常见的性能陷阱及应对策略。
3.1 对象创建
在面向对象语言中，对象的构造是一项开销较大的操作。它需要虚拟机分配内存，并且在对象可用之前可能涉及多个链式构造函数调用。优化对象创建是提高应用性能的简单方法之一。
-
无状态类
：避免创建新对象的一种方法是将所有类设计为无状态类。无状态类具有以下特点：
- 非静态成员变量不保存状态信息。
- 构造函数不能设置任何信息（但静态初始化器是允许的）。
- 所有方法必须是静态的。
- 不能进行序列化（因为没有可序列化的内容）。
通常，通过将所有方法设为静态，可将类转变为相关方法的容器。同时，应将类的构造函数设为私有，以防止误创建实例。需要注意的是，不定义构造函数是不够的，因为如果没有其他构造函数，Java 会生成一个无参构造函数，将其设为私有可避免实例化。
无状态类不会占用过多内存，但也无法利用 Java 的一些面向对象特性。是否将类设计为无状态类需要根据具体情况决定。边界类最适合设计为无状态类，因为它们的方法通常相互独立，不需要内部保存状态信息。例如，作为从数据库检索实体的通道的边界类，每个方法将实体作为参数并进行相应操作，此时唯一的状态信息（实体）局限于方法内部，无需在各方法间共享。
如果部分业务规则将以无状态会话 EJB 的形式实现，将类设计为无状态也是一个不错的策略。若项目有可能迁移到使用 EJB，那么额外努力创建无状态方法将有助于更轻松地完成过渡。
许多开发者更喜欢使用单例对象而非无状态类，这被认为是处理无状态的更面向对象的方式。单例对象相对于无状态类具有以下优势：
- 单例是对象实例，便于进行线程同步，因为单例对象可作为同步点。
- 单例可以设计为创建有限数量的对象实例，使其兼具工厂的功能。
- 一些设计模式（如策略模式）依赖实现特定接口的对象实例，不允许使用非对象实例的无状态类。
- 对象重用 ：控制对象构造数量的另一种技术是重用对象而非创建新对象。使用这种策略时，在使用完对象后，不让其超出作用域，而是保持对象引用并通过为属性提供新值来重用它。
以下是一个示例类
ScheduleItem
，其中的
reset()
方法可将对象恢复到构造后的初始状态：
package com.nealford.art.objects;
import java.io.Serializable;
public class ScheduleItem implements Serializable {
private int duration;
private String description;
public ScheduleItem(int dureation, String description) {
this.duration = duration;
this.description = description;
}
public void setDuration(int duration) {
this.duration = duration;
}
public int getDuration() {
return duration;
}
public void setDescription(String description) {
this.description = description;
}
public String getDescription() {
return description;
}
public void reset() {
this.duration = -1;
this.description = "";
}
}
重用现有对象引用比创建新对象更高效，这种方法适用于实体类，因为实体类通常是轻量级的，包含访问器、修改器和一些业务规则方法。例如，Struts 的 ActionForm 就包含
reset()
方法，用于重用对象引用而非重新创建。
在重用对象引用时，需要考虑将其放置的位置。不能让对象超出作用域，否则会被虚拟机垃圾回收。一个明显的选择是将它们放入对象池，如同从连接池获取数据库连接一样。
3.2 多余的对象引用
许多 Java 开发者会遇到保留多余对象引用的问题。Java 的垃圾回收机制设计用于自动处理内存释放，但如果保留了对象的“额外”引用，它就无法正常工作。这是 Java 中看似内存泄漏的根源。在 C 和 C++ 等语言中，内存泄漏是一个严重问题，因为开发者需要负责内存的分配和释放，可能会出现分配内存后在回收前让变量超出作用域的情况。而在 Java 中，所有未被引用的内存会自动回收，但我们仍可能忘记释放对象引用。
开发者通常不会创建两个指向同一内存位置的独立变量，然后忘记让其中一个超出作用域。但常见的情况是在集合中创建变量引用，却忘记集合中保留的第二个引用。例如，在 Web 开发中，很容易将对象放入用户会话中，然后忘记它的存在。如果有大量用户，且每个用户的会话中都有多余的对象引用，就会导致性能问题。虽然会话引用在会话超时时会消失，但默认情况下，我们可能会浪费 30 分钟的内存和性能。
一旦对象在任何集合中不再需要，应手动将其移除。如果整个集合消失（如请求集合），则无需担心，因为集合会带走额外的引用。但对于会话和应用集合，我们必须认真清理，否则会无意中使用额外内存，可能损害应用性能。
一个好的做法是在用户不再需要会话时手动使其失效，这通常在注销页面完成，这也是设置注销页面的一个重要原因。但用户并不总是可靠地注销，我们只能希望有足够多的用户配合，以防止会话内存增长过快。如果用户未注销，内存回收将在会话超时后才会发生。
3.3 字符串使用
在几乎所有 Java 性能相关的书籍中，字符串的使用都是一个重要话题。在 Web 应用中，字符串的使用非常广泛，因为用户最终看到的是格式化后的 HTML 长字符串。正确使用字符串对有效利用内存有巨大影响，明智地使用字符串可以显著提高应用的运行速度。
Java 中
String
类的不可变性以及使用
+
运算符构建字符串的影响已有详细记载。尽管开发者都知道过多使用
+
会影响性能，但仍有许多人使用字符串来构建动态内容，而非更具性能优势的
StringBuffer
。过多对象创建带来的性能损失在前面已有提及，而
+
是其中的“重灾区”。
例如以下代码：
String s = "<BODY>" + someObj.someValue() + "</BODY>";
根据编译器的智能程度，可能会有两种不同的翻译。第一种使用
String
的
concat()
运算符，效率非常低：
String s = "<BODY>".concat(someObj.someValue()).concat("</BODY>");
这种实现会创建两个中间字符串对象，在该行代码结束时被丢弃。更好的实现是使用
StringBuffer
：
String s = (new StringBuffer()).append("<BODY>").append(someObj.someValue()).append("</BODY").toString();
无论进行多少次连接操作，只创建两个对象是最优解决方案。编译器如何处理这一问题并没有统一规定，因此编译器开发者可以自由选择实现方式。为了避免这个问题，从一开始就使用
StringBuffer
是明智的选择。
使用
StringBuffer
时，应始终指定初始大小。Java 集合和
StringBuffer
在需要增长时会非常耗时，因为它们需要分配内存。所有集合 API 类在需要增长时默认会将大小翻倍，
StringBuffer
也类似。如果为
StringBuffer
指定一个合理的默认大小，可以减少其多次增长的可能性。即使无法确定确切大小，至少也要尽量猜测，因为我们的猜测通常比编译器更准确。
StringBuffer
的
append()
方法（以及其他方法）会返回正在操作的
StringBuffer
对象，这意味着可以将多个
append
语句链式调用：
StringBuffer sb = new StringBuffer(80);
sb.append("<body>").append(duration).append('\t').append(description).append('\n').append("</body>");
这种方式与将代码分行编写的效率相同，但可以减少输入量。是否使用这种链式调用风格取决于个人喜好。
4. 对象池化
如果有可重用的对象引用，就需要为它们找一个合适的存放位置。对象池是一个通常带有键的内存集合，对象引用可以在其中等待，直到需要执行任务时被取出。通过预先创建大量对象并从对象池中重用它们，可以减少应用运行时的构造函数调用次数。应用服务器利用对象池来加速对象操作，实际上，它们对各种资源（如数据库连接、线程、消息、对象、EJB 等）都进行了池化处理。高性能的秘诀之一就是批量创建资源，而不是等到需要时再创建。
简单的对象池可以由 SDK 中的集合类实现。例如，可以创建一个栈或队列来存储预先构造的实体集合。在 Web 应用中，这个对象池在应用启动时进行初始化，并放置在应用上下文中，供需要这些对象的资源使用。对象池的使用流程如下：
graph LR
A[应用启动] --> B[初始化对象池]
B --> C{需要对象?}
C -- 是 --> D[从对象池获取对象]
D --> E[使用对象]
E --> F[对象使用完毕]
F --> G[将对象放回对象池]
G --> C
C -- 否 --> H[应用继续运行]
通过合理运用性能分析工具、避免常见性能陷阱以及使用对象池化技术，可以显著提高 Java 应用的性能，为用户提供更流畅的使用体验。在实际开发中，我们应根据具体需求和场景，灵活选择和应用这些技术。
5. 不同类型对象池的应用场景与实现思路
除了简单的对象池，在实际开发中，根据不同的应用场景和需求，还会有更复杂和特定用途的对象池。以下为大家详细介绍几种常见的对象池及其应用场景和实现思路。
5.1 数据库连接池
数据库连接的创建和销毁是非常消耗资源的操作。频繁地打开和关闭数据库连接会严重影响应用的性能。数据库连接池可以在应用启动时创建一定数量的数据库连接，并将它们放入池中。当应用需要与数据库交互时，直接从池中获取连接，使用完毕后再将连接放回池中，而不是销毁它。
实现数据库连接池的步骤如下：
1.
初始化连接池
：在应用启动时，创建一定数量的数据库连接，并将它们存储在一个集合中，如
List
或
Queue
。
2.
获取连接
：当应用需要数据库连接时，从连接池中取出一个可用的连接。如果连接池为空，则根据配置决定是等待一段时间还是创建新的连接。
3.
使用连接
：应用使用获取到的数据库连接执行 SQL 操作。
4.
归还连接
：使用完毕后，将连接放回连接池，而不是关闭它。
5.
连接池管理
：定期检查连接池中的连接状态，关闭无效的连接，并根据需要补充新的连接。
以下是一个简单的数据库连接池示例代码：
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class DatabaseConnectionPool {
private static final String URL = "jdbc:mysql://localhost:3306/mydb";
private static final String USER = "root";
private static final String PASSWORD = "password";
private static final int INITIAL_SIZE = 5;
private List<Connection> pool;
public DatabaseConnectionPool() {
pool = new ArrayList<>();
for (int i = 0; i < INITIAL_SIZE; i++) {
try {
Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
pool.add(connection);
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public synchronized Connection getConnection() {
if (pool.isEmpty()) {
try {
return DriverManager.getConnection(URL, USER, PASSWORD);
} catch (SQLException e) {
e.printStackTrace();
return null;
}
}
return pool.remove(0);
}
public synchronized void releaseConnection(Connection connection) {
pool.add(connection);
}
}
5.2 线程池
在多线程应用中，线程的创建和销毁也会带来较大的开销。线程池可以预先创建一定数量的线程，并将任务分配给这些线程执行。当任务完成后，线程不会被销毁，而是等待下一个任务。
线程池的使用步骤如下：
1.
创建线程池
：根据应用的需求，创建一个线程池，并设置线程池的大小、任务队列的大小等参数。
2.
提交任务
：将需要执行的任务提交给线程池。
3.
线程池调度
：线程池会根据线程的空闲状态和任务队列的情况，将任务分配给合适的线程执行。
4.
任务执行
：线程执行任务。
5.
任务完成
：任务完成后，线程会等待下一个任务。
Java 提供了
ExecutorService
接口和
ThreadPoolExecutor
类来实现线程池。以下是一个简单的线程池示例代码：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ThreadPoolExample {
public static void main(String[] args) {
// 创建一个固定大小的线程池，包含 5 个线程
ExecutorService executor = Executors.newFixedThreadPool(5);
// 提交 10 个任务给线程池
for (int i = 0; i < 10; i++) {
final int taskId = i;
executor.submit(() -> {
System.out.println("Task " + taskId + " is being executed by " + Thread.currentThread().getName());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Task " + taskId + " is completed.");
});
}
// 关闭线程池
executor.shutdown();
}
}
6. 优化对象池性能的技巧
为了充分发挥对象池的优势，提高应用的性能，我们还可以采用一些优化技巧。
6.1 动态调整对象池大小
在应用运行过程中，根据实际的负载情况动态调整对象池的大小。当负载较高时，增加对象池中的对象数量；当负载较低时，减少对象池中的对象数量，以避免资源的浪费。
实现动态调整对象池大小的步骤如下：
1.
监控负载
：定期监控应用的负载情况，如请求的数量、响应时间等。
2.
判断调整策略
：根据监控结果，判断是否需要调整对象池的大小。例如，如果请求数量持续增加，且对象池中的对象经常处于忙碌状态，则可以考虑增加对象池的大小；如果请求数量减少，且对象池中有大量空闲对象，则可以考虑减少对象池的大小。
3.
调整对象池大小
：根据判断结果，增加或减少对象池中的对象数量。
6.2 对象池的预热
在应用启动时，提前创建一定数量的对象并放入对象池，让对象池在应用开始处理请求之前就处于一个相对稳定的状态。这样可以避免在应用刚启动时，由于对象池为空而导致的性能问题。
对象池预热的实现步骤如下：
1.
配置预热参数
：在应用的配置文件中或代码中设置对象池的预热数量和预热时间。
2.
预热对象池
：在应用启动时，根据预热参数创建一定数量的对象，并将它们放入对象池。
7. 性能优化的综合实践案例
下面通过一个具体的综合实践案例，展示如何将前面介绍的性能优化技术应用到实际开发中。
假设我们正在开发一个 Web 应用，该应用需要处理大量的用户请求，并与数据库进行频繁的交互。为了提高应用的性能，我们可以采取以下措施：
-
使用对象池
：
- 数据库连接池 ：使用数据库连接池来管理数据库连接，减少连接的创建和销毁开销。
- 线程池 ：使用线程池来处理用户请求，提高多线程处理的效率。
-
避免常见性能陷阱
：
- 对象创建优化 ：将一些频繁使用的类设计为无状态类或使用对象重用技术，减少对象的创建。
- 避免多余对象引用 ：及时清理不再使用的对象引用，特别是在集合和会话中。
-
合理使用字符串
：使用
StringBuffer或StringBuilder来构建动态字符串，避免使用+运算符。
-
性能分析与负载测试
：
- 使用性能分析工具 ：定期使用性能分析工具，如 VisualVM 或 YourKit，找出应用中的性能瓶颈。
- 进行负载测试 ：使用 JMeter 等负载测试工具，模拟大量用户请求，测试应用在高负载下的性能表现，并根据测试结果进行优化。
以下是一个简单的代码示例，展示了如何在 Web 应用中使用数据库连接池和线程池：
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class WebAppExample {
private static final DatabaseConnectionPool connectionPool = new DatabaseConnectionPool();
private static final ExecutorService executor = Executors.newFixedThreadPool(10);
public static void main(String[] args) {
// 模拟 20 个用户请求
for (int i = 0; i < 20; i++) {
executor.submit(() -> {
Connection connection = connectionPool.getConnection();
try {
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("SELECT * FROM users");
while (resultSet.next()) {
System.out.println(resultSet.getString("username"));
}
resultSet.close();
statement.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
connectionPool.releaseConnection(connection);
}
});
}
// 关闭线程池
executor.shutdown();
}
}
通过以上综合实践案例可以看出，通过合理运用性能分析工具、避免常见性能陷阱、使用对象池化技术以及进行性能优化的综合实践，可以显著提高 Java 应用的性能，为用户提供更流畅、高效的使用体验。在实际开发中，我们需要根据具体的应用场景和需求，灵活选择和应用这些技术，不断优化应用的性能。
总之，Java 应用的性能优化是一个系统工程，需要我们从多个方面进行考虑和实践。通过深入理解和掌握性能分析、常见性能陷阱、对象池化等技术，并将它们应用到实际开发中，我们可以打造出高性能、高稳定性的 Java 应用。希望本文介绍的内容能对大家在 Java 应用性能优化方面有所帮助。
扫一扫
612
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
