总结了 50 条 Java 性能优化建议，涵盖代码编写、JVM 调优、并发编程、IO 网络及数据库交互等方面。内容涉及局部变量使用、对象池、字符串处理、正则预编译、集合选择、线程池配置、内存映射文件、日志级别控制、序列化方式、缓存策略、异步编程、SQL 优化及索引设计等具体实践。旨在通过减少 GC 压力、降低锁竞争、优化资源利用及避免常见陷阱，提升系统整体运行效率与稳定性。
Java 性能优化是一个永恒的话题。无论是构建高并发的 Web 服务，还是处理海量数据的离线任务，性能始终是衡量系统质量的核心指标之一。然而，优化并非盲目地堆砌技巧，而是需要深入理解 JVM 原理、操作系统特性以及编程语言的底层实现。
本文整理了 50 个 Java 性能优化的细节，涵盖代码编写、JVM 调优、并发编程、IO 网络等多个维度。每个细节都力求讲清原理、提供可操作的实践建议，并辅以代码示例。
问题：在方法内部频繁创建的对象如果逃逸出方法作用域，会被分配到堆上，增加 GC 压力。
优化：尽可能使用局部变量，让对象在栈上分配（如果 JIT 支持逃逸分析）。即使没有逃逸分析，局部变量的生命周期短，也能减轻年轻代 GC 的负担。
// 不推荐：每次调用都创建新对象
public void process() {
Date d = new Date();
// 使用 d
}
// 推荐：如果对象可以复用，作为方法参数传入
public void process(Date d) {
// 使用传入的 d
}
问题：创建和销毁对象的成本较高，尤其是重量级对象（如数据库连接、线程、Socket）。
优化：使用对象池技术，如数据库连接池、线程池。对于轻量级对象，如果创建开销小，则不必池化，以免增加管理成本。
// 使用 Apache Commons Pool 实现对象池
// 或直接使用 HikariCP 作为数据库连接池
问题：包装类型（如 Integer、Double）是对象，占用更多内存，且涉及自动装箱/拆箱会有性能开销。
优化：在局部变量、成员变量等场景，尽量使用基本类型（int、double），除非必须使用泛型或集合。
// 不推荐
Integer sum = 0;
for (int i = 0; i < 100000; i++) {
sum += i; // 每次都会创建新的 Integer 对象
}
// 推荐
int sum = 0;
for (int i = 0; i < 100000; i++) {
sum += i;
}
问题：正则表达式的编译非常耗时，如果重复使用相同的正则，每次调用 String.matches() 都会重新编译。
优化：将正则表达式预编译为 Pattern 对象，并复用。
// 不推荐
for (String line : lines) {
if (line.matches("\\d+")) {
...
}
}
// 推荐
private static final Pattern DIGIT_PATTERN = Pattern.compile("\\d+");
for (String line : lines) {
if (DIGIT_PATTERN.matcher(line).matches()) {
...
}
}
问题：使用 + 拼接字符串，在循环中会产生大量临时 String 对象，导致 GC 压力。
优化：在循环或复杂拼接中使用 StringBuilder（非线程安全，性能更高）或 StringBuffer（线程安全）。
// 不推荐
String s = "";
for (int i = 0; i < 1000; i++) {
s += i; // 每次循环都会创建新的 StringBuilder 和 String
}
// 推荐
StringBuilder sb = new StringBuilder(1000 * 5); // 预分配容量
for (int i = 0; i < 1000; i++) {
sb.append(i);
}
String s = sb.toString();
原理：String.intern() 可以将字符串放入常量池，重复的字符串可以共享同一个字符数组，从而节省内存。
适用场景：有大量重复字符串且生命周期较长，如缓存的业务数据中的枚举值。但注意常量池的垃圾回收在 JDK 7+ 已支持，但 intern 本身有代价（查找和可能扩容）。
// 例如，从数据库读取大量重复的城市名
String city = rs.getString("city").intern();
问题：在循环体内创建对象，如果对象作用域仅在循环内，可以考虑将对象移到循环外部复用。
优化：但要注意，如果对象需要每次重置，复用的代价可能高于创建。需要权衡。
// 不推荐
for (int i = 0; i < 100000; i++) {
List<String> list = new ArrayList<>();
list.add("item" + i);
// ...
}
// 推荐：如果每次需要清空，用 clear()
List<String> list = new ArrayList<>();
for (int i = 0; i < 100000; i++) {
list.clear();
list.add("item" + i);
// ...
}
问题：有些对象的创建成本较高，且不一定每次都会被使用，提前初始化浪费资源。
优化：使用延迟加载（Lazy Initialization），直到第一次使用时才创建。注意并发环境下的线程安全。
public class LazyHolder {
private static final HeavyObject INSTANCE = new HeavyObject();
public static HeavyObject getInstance() {
return INSTANCE; // 类加载时初始化，线程安全且高效
}
}
// 或者使用双重检查锁定（需要 volatile）
private volatile HeavyObject instance;
public HeavyObject getInstance() {
if (instance == null) {
synchronized (this) {
if (instance == null) {
instance = new HeavyObject();
}
}
}
return instance;
}
问题：过度使用 synchronized 会导致线程阻塞，降低并发性能。
优化：缩小同步块的范围，优先使用 java.util.concurrent 包中的并发集合（如 ConcurrentHashMap、CopyOnWriteArrayList）替代手动同步。
// 不推荐
Map<String, String> map = new HashMap<>();
synchronized (map) {
map.put(key, value);
}
// 推荐
ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();
map.put(key, value); // 内部已实现高效并发
场景：如果某个变量每个线程都需要有自己的独立副本，可以使用 ThreadLocal，避免加锁。
private static final ThreadLocal<SimpleDateFormat> DATE_FORMAT = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd"));
public String formatDate(Date date) {
return DATE_FORMAT.get().format(date); // 每个线程有自己的 SimpleDateFormat
}
原理：java.util.concurrent.atomic 包下的类（如 AtomicInteger、AtomicReference）基于 CAS 操作，无锁但能保证线程安全，性能优于加锁。
// 不推荐
private int count;
public synchronized void increment() {
count++;
}
// 推荐
private AtomicInteger count = new AtomicInteger();
public void increment() {
count.incrementAndGet();
}
问题：每次任务都新建线程，线程创建销毁开销大，且过多线程会导致上下文切换频繁，甚至耗尽系统资源。
优化：使用 ThreadPoolExecutor 创建线程池，合理设置核心线程数、最大线程数、队列等参数。
ExecutorService executor = new ThreadPoolExecutor(
10, // 核心线程数
50, // 最大线程数
60L, TimeUnit.SECONDS,
new LinkedBlockingQueue<>(1000) // 有界队列
);
executor.submit(() -> { ... });
原理：传统 BIO 是阻塞 IO，每个连接需要一个线程处理；NIO 基于 Selector 多路复用，一个线程可管理多个连接，适合高并发。
优化：对于网络通信，优先使用 NIO 框架（如 Netty）而非自己编写 Socket 循环。
问题：不带缓冲的读写（如 FileInputStream.read()）每次调用都会触发系统调用，性能极低。
优化：使用 BufferedInputStream、BufferedReader 等包装流，减少实际 IO 次数。
// 不推荐
try (FileInputStream fis = new FileInputStream("file.txt")) {
int b;
while ((b = fis.read()) != -1) {
...
}
}
// 推荐
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("file.txt"))) {
byte[] buffer = new byte[8192];
int len;
while ((len = bis.read(buffer)) != -1) {
...
}
}
原理：MappedByteBuffer 将文件直接映射到内存，读写操作相当于内存操作，速度极快，适合大文件。
try (RandomAccessFile file = new RandomAccessFile("large.dat", "rw"); FileChannel channel = file.getChannel()) {
MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, file.length());
// 直接操作 buffer
}
问题：生产环境打印过多日志（特别是 DEBUG 级别）会严重影响性能，磁盘 IO 和字符串拼接开销不容忽视。
优化：设置合适的日志级别（如 INFO），并使用占位符避免字符串拼接的浪费。
// 不推荐
logger.debug("User " + userId + " login at " + System.currentTimeMillis());
// 推荐
if (logger.isDebugEnabled()) {
logger.debug("User {} login at {}", userId, System.currentTimeMillis());
}
问题：Java 原生序列化（Serializable）性能差、体积大，且存在安全漏洞。
优化：对于内部通信，可选用 Protobuf、Kryo、Avro 等高性能序列化框架；对于跨语言场景，Protobuf 或 JSON 是更好的选择。
场景：实现缓存时，如果缓存对象过多可能导致内存溢出，可以使用 SoftReference（内存不足时回收）或 WeakReference（下次 GC 即回收）。
Map<String, SoftReference<BigImage>> cache = new HashMap<>();
// 获取图片
SoftReference<BigImage> ref = cache.get(key);
BigImage image = (ref == null) ? null : ref.get();
if (image == null) {
image = loadBigImage(key);
cache.put(key, new SoftReference<>(image));
}
问题：堆过小会导致频繁 GC，过大则单次 GC 时间长。GC 器的选择也至关重要。
优化：根据应用特点选择 GC 器（如 G1、ZGC），并设置初始堆大小（-Xms）和最大堆大小（-Xmx）一致，避免动态调整。监控 GC 日志以调优。
原理：finalize() 由 Finalizer 线程执行，执行时间不确定，且会导致对象复活等问题，严重影响 GC 性能。
优化：使用 Cleaner（Java 9+）或显式释放资源（如 try-with-resources）。
原理：JVM 局部变量表在方法调用时分配，方法内局部变量复用可以减少栈帧大小，但更重要的是避免不必要的对象引用。
实践：合理声明变量，不要在循环内重复声明引用变量（但现代 JIT 会优化，可读性更重要）。
问题：Lambda 表达式如果捕获外部变量，会生成匿名内部类，且捕获的变量必须实际 final。捕获大量变量可能增加内存占用。
优化：尽量将外部变量作为参数传递，或使用静态方法。
原理：Stream API 提供了声明式编程，但自动装箱、中间操作（如 filter、map）可能产生额外开销。parallelStream 未必总是更快，需数据量大且操作可并行。
// 对于简单循环，传统 for 循环可能更快
// 但对于复杂操作，Stream 可读性高，性能也可接受
int sum = list.parallelStream().filter(x -> x > 0).mapToInt(i -> i).sum();
问题：反射涉及动态解析，性能远低于直接调用。尤其是在高频调用的方法中。
优化：如果必须使用，可缓存 Method 对象，或者使用 MethodHandle（比反射略快）。更优方案是使用编译时代码生成（如 LambdaMetafactory）。
// 缓存 Method
private static final Method method = getMethod();
method.invoke(obj, args);
原理：MethodHandle 是 Java 7 引入的，类似于反射，但具有更好的性能，因为它由 JIT 直接支持，可以进行内联优化。
场景：计算密集型或 IO 密集型操作，如果输入相同输出相同，可以考虑缓存结果（如 Guava Cache、Caffeine）。
LoadingCache<Key, Graph> graphs = Caffeine.newBuilder()
.maximumSize(10000)
.expireAfterWrite(10, TimeUnit.MINUTES)
.build(key -> createExpensiveGraph(key));
原理：将耗时操作异步化，可以释放当前线程处理其他请求。Java 中可以使用 CompletableFuture 或响应式框架（如 Reactor）。
CompletableFuture.supplyAsync(() -> fetchData())
.thenApply(data -> process(data))
.thenAccept(result -> send(result));
原理：CPU 上下文切换开销较大。多线程竞争锁、系统调用过多都会导致上下文切换。
优化：减少锁竞争、使用无锁数据结构、减少线程数量（合理配置线程池）、避免频繁的线程阻塞。
问题：每次数据库操作都创建连接、关闭连接，开销巨大。
优化：使用 HikariCP、Druid 等连接池，复用连接。
原理：网络往返（RTT）是性能杀手。批量提交 SQL（如 JDBC batch）可大幅提升性能。
Connection conn = dataSource.getConnection();
PreparedStatement ps = conn.prepareStatement("INSERT INTO user (name) VALUES (?)");
for (User user : userList) {
ps.setString(1, user.getName());
ps.addBatch();
}
ps.executeBatch();
原理：慢 SQL 往往是性能瓶颈。通过 EXPLAIN 分析执行计划，建立合适的索引，避免全表扫描。
优化：避免 SELECT *，只查需要的列；避免在索引列上使用函数；合理使用覆盖索引等。
原理：PreparedStatement 会预编译 SQL，减少数据库解析开销，同时防止 SQL 注入。
PreparedStatement ps = conn.prepareStatement("SELECT * FROM user WHERE id = ?");
ps.setInt(1, id);
ResultSet rs = ps.executeQuery();
场景：对于读多写少的应用，可以将读操作分发到从库，写操作在主库，通过主从复制减轻主库压力。
原理：静态资源（图片、CSS、JS）放在 CDN 上，减少服务器带宽和响应时间。
原理：对于文本类响应（JSON、HTML），启用 GZIP 压缩可减少 70% 以上传输量，但会增加 CPU 开销。需权衡。
原理：简单的代码更容易被 JIT 优化，也更容易维护。复杂的模式可能会引入不必要的间接层和性能损耗。
工具：JProfiler、VisualVM、Arthas、JMH 等。不要猜测性能问题，用数据说话。
问题：循环中调用远程 HTTP 或 RPC，会导致累积延迟，且可能因网络抖动导致整体超时。
优化：批量请求或异步并发调用。
// 使用 CompletableFuture 并发调用
List<CompletableFuture<Result>> futures = ids.stream()
.map(id -> CompletableFuture.supplyAsync(() -> remoteCall(id)))
.collect(Collectors.toList());
List<Result> results = futures.stream().map(CompletableFuture::join).collect(Collectors.toList());
原理：本地缓存（如 Caffeine）速度远快于分布式缓存（如 Redis），因为没有网络开销。但需要注意数据一致性。
场景：网络请求、数据库连接等必须设置超时，避免线程无限等待。超时时间不宜过长或过短，需根据业务容忍度调整。
原理：HTTP 1.1 默认支持 Keep-Alive，TCP 连接复用，减少握手开销。数据库连接池也是长连接的体现。
原理：CompletableFuture 提供了丰富的异步编排能力，可以避免回调地狱，同时利用 ForkJoinPool 提高并行度。
CompletableFuture<Double> future = CompletableFuture.supplyAsync(this::getPrice)
.thenApply(price -> price * 0.9)
.thenApply(this::convertCurrency);
原理：ArrayList 基于数组，随机访问快，但插入删除慢（除非在末尾）；LinkedList 基于双向链表，插入删除快，但随机访问慢。根据实际场景选择。
优化：如果需要频繁在列表中间插入删除，且不经常随机访问，用 LinkedList；否则用 ArrayList。
原理：HashMap 默认容量 16，负载因子 0.75。如果已知数据量，指定初始容量可避免频繁扩容（rehash），提高性能。
Map<String, Object> map = new HashMap<>(1024); // 假设大概有 1000 个元素
原理：EnumMap 内部用数组实现，根据枚举 ordinal 索引，性能比 HashMap 更高，内存更省。
Map<Color, String> map = new EnumMap<>(Color.class);
原理：位运算直接操作二进制，比算术运算快。适用于权限组合、状态标志等场景。
// 例如权限组合
int READ = 1 << 0; // 1
int WRITE = 1 << 1; // 2
int EXECUTE = 1 << 2; // 4
int permissions = READ | WRITE;
boolean canRead = (permissions & READ) != 0;
问题：异常处理需要构建异常栈，开销极大。不要用 try-catch 包裹正常流程。
// 不推荐
try {
int result = Integer.parseInt(str);
} catch (NumberFormatException e) {
// 处理非数字
}
// 推荐
if (str != null && str.matches("\\d+")) {
int result = Integer.parseInt(str);
}
原理：传统文件读取需要从内核拷贝到用户空间再写回内核，零拷贝（如 FileChannel.transferTo）直接在内核空间传输，减少拷贝次数。
FileChannel source = new FileInputStream("source.txt").getChannel();
WritableByteChannel dest = ...;
source.transferTo(0, source.size(), dest);
原理：JMH（Java Microbenchmark Harness）是 JVM 认可的基准测试工具，能避免 JIT 优化对测试结果的影响。
示例：编写测试代码，比较不同实现方式的性能。
原理：GraalVM 可以将 Java 应用编译为本地可执行文件，启动速度极快，内存占用低，适合微服务场景。但可能不支持所有 Java 特性。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online