Java 性能优化技能

高级 Java 性能优化技术，专注于 JVM 应用性能提升、内存管理、并发处理和系统调优。

性能优化策略

1. 缓存策略 (Caching)

使用 Spring Cache 或 Caffeine 实现高效缓存：

java
// ✅ 使用 Caffeine 本地缓存
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import java.time.Duration;

public class MaterialService {
private final Cache cache = Caffeine.newBuilder()
.maximumSize(10_000)
.expireAfterWrite(Duration.ofMinutes(10))
.recordStats()
.build();

public Material getMaterial(String code) {
return cache.get(code, key -> repository.findByCode(code));
}
}

java
// ✅ 使用 Spring Cache + Redis
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class FormulaService {

@Cacheable(value = formulas, key = #id,
condition = #id != null,
unless = #result == null)
public Formula getFormula(Long id) {
return formulaRepository.findById(id).orElse(null);
}
}

何时使用缓存：

• - 频繁访问的数据库查询结果
• 计算成本高的数据
• 不经常变化的配置数据
• 第三方 API 调用结果

2. 并行处理 (Parallel Processing)

使用 Stream API 和 Fork/Join 框架：

java
import java.util.stream.Collectors;

// ✅ 并行流处理 CPU 密集型任务
public List calculateBatch(List materials) {
return materials.parallelStream()
.map(this::calculateNutrition)
.collect(Collectors.toList());
}

java
// ✅ 使用 CompletableFuture 异步处理
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class AsyncCalculator {
private final ExecutorService executor = Executors.newFixedThreadPool(
Runtime.getRuntime().availableProcessors()
);

public CompletableFuture calculateAsync(Material material) {
return CompletableFuture.supplyAsync(() -> {
return calculateNutrition(material);
}, executor);
}

// ✅ 批量异步处理
public CompletableFuture> batchCalculate(List materials) {
List> futures = materials.stream()
.map(m -> calculateAsync(m))
.collect(Collectors.toList());

return CompletableFuture.allOf(
futures.toArray(new CompletableFuture[0]))
.thenApply(v -> futures.stream()
.map(CompletableFuture::join)
.collect(Collectors.toList()));
}
}

最佳实践：

• - 并行流适合大数据量和 CPU 密集型操作
• 小数据集使用顺序流（避免线程切换开销）
• 使用 @Async 进行异步方法调用
• 合理设置线程池大小

3. 内存优化 (Memory Optimization)

避免不必要的对象创建

// ✅ 正确 - 循环外创建
StringBuilder sb = new StringBuilder(items.size() * 10);
for (String item : items) {
sb.append(item);
}

使用基本类型而非包装类