掌握Java性能优化：从内存泄漏到并发问题
发表时间: 2024-02-09 11:18
【CSDN 编者按】文章分享了作者在使用 Digma 工具和其他方法优化一个 Java 项目的性能问题时的经验和技巧。文章介绍了六种常见的 Java 性能问题，分别是内存泄漏、线程死锁、过度垃圾回收、依赖库过多、代码效率低下和并发问题，并提供了相应的解决方案和建议。文章的目的是帮助 Java 开发者提高代码的性能和质量。
public class StaticFieldsMemoryTestExample { public static List<Double> list = new ArrayList<>(); public void addToList() { for (int i = 0; i < 10000000; i++) { list.add(Math.random()); } Log.info("Debug Point 2"); } public static void main(String[] args) { new StaticFieldsDemo().addToList(); }}public class Person { public String name; public Person(String name) { this.name = name; } public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Person)) { return false; } Person person = (Person) o; return person.name.equals(name); } public int hashCode() { int result = 17; result = 31 * result + name.hashCode(); return result; }}当你的代码中涉及外部资源使用，例如文件句柄、数据库连接或网络套接字时，务必在这些资源不再被需要时，明确地进行释放。 利用内存分析工具，比如 VisualVM 或 YourKit，对你的应用程序进行分析，以便发现和定位潜在的内存泄漏问题。 在实现单例模式时，推荐采用懒加载方式而非饿汉式加载，这样可以防止在单例实际被需要之前，进行不必要的资源分配。 当代码中使用到外部资源时，如文件句柄、数据库连接或网络套接字，确保在不需要时明确释放这些资源，以避免内存泄漏。
public class DeadlockExample { private static final Object lock1 = new Object(); private static final Object lock2 = new Object(); public static void main(String[] args) { Thread thread1 = new Thread(() -> { synchronized (lock1) { System.out.println("Thread 1: Holding lock 1"); // Introducing a delay to increase the likelihood of deadlock try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lock2) { System.out.println("Thread 1: Holding lock 1 and lock 2"); } } }); Thread thread2 = new Thread(() -> { synchronized (lock2) { System.out.println("Thread 2: Holding lock 2"); // Introducing a delay to increase the likelihood of deadlock try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lock1) { System.out.println("Thread 2: Holding lock 2 and lock 1"); } } }); thread1.start(); thread2.start(); }}public class DeadlockSolution { private static final Object lock1 = new Object(); private static final Object lock2 = new Object(); public static void main(String[] args) { Thread thread1 = new Thread(() -> { synchronized (lock1) { System.out.println("Thread 1: Holding lock 1"); // Introducing a delay to increase the likelihood of deadlock try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lock2) { System.out.println("Thread 1: Holding lock 2"); } } }); Thread thread2 = new Thread(() -> { synchronized (lock1) { System.out.println("Thread 2: Holding lock 1"); // Introducing a delay to increase the likelihood of deadlock try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (lock2) { System.out.println("Thread 2: Holding lock 2"); } } }); thread1.start(); thread2.start(); }}
锁排序 — 通过确保所有线程在尝试获取多个锁时遵循相同的顺序，从而避免循环等待的发生。 实现锁超时 — 在尝试获取锁时引入超时机制。如果线程在指定的时间内无法获取到锁，那么它应该释放它已经持有的所有锁并重试，以减少死锁的风险。 避免嵌套锁 — 尽量避免在持有其他锁的情况下再去获取新的锁。嵌套锁定会增加发生死锁的可能性，因为它增加了多个锁同时被不同线程请求的复杂度。
日志分析与调优 —— 分析日志以识别垃圾回收过程中出现的模式，例如完整的垃圾回收周期或较长的暂停时间。 选择合适的垃圾回收算法 —— 根据你的应用需求，在不同的垃圾回收算法之间做出选择，比如 Serial、Parallel、G1、Z GC 等。根据应用的工作负载和性能需求选择最合适的算法，可以有效减少 CPU 的消耗。 代码优化减少对象创建 —— 通过使用内存分析工具，如 HeapHero 或 YourKit ，识别出产生大量对象的代码区域，并对其进行优化。实现对象池可以复用对象，从而减少对象的频繁创建和分配开销。 调整堆大小 —— 通过修改堆的大小来调整垃圾回收对 CPU 的消耗。根据应用的内存需求，适当增加堆的大小可以降低垃圾回收频率，或者对于内存使用量较小的应用，减少堆的大小以节约资源。 在云环境中分散工作负载 —— 如果应用运行在云平台上，可以考虑通过增加容器或 EC2 实例的数量来分散工作负载。这样不仅可以更有效地利用资源，还可以减轻单个实例上的负担。
依赖审计 —— 定期执行依赖审计，以识别项目中未使用或过时的库。利用工具如 Maven 依赖插件或 Gradle 的 dependencyInsight 进行依赖分析，有助于审计过程。 版本控制 —— 保持依赖项的最新状态，使用版本控制系统来跟踪依赖项变化，并有系统地管理它们的更新。 依赖范围管理 —— 有效地使用依赖范围（如编译、运行时、测试等），尽量减少编译范围内的依赖项数量，以降低最终产品的大小，从而避免臃肿。
String result = "";for (int i = 0; i < 1000; i++) { result += "example";}StringBuilder sb = new StringBuilder();for (int i = 0; i < 1000; i++) { sb.append("example");}String result = sb.toString();重构和模块化代码：避免不必要的代码重复，使代码更加清晰高效。 优化 I/O 操作：采用异步或并行 I/O 操作，避免阻塞主线程，提升性能。 避免不必要的对象创建：在关键性能部分避免创建不必要的对象。尽可能复用对象，并考虑采用对象池技术。 使用 StringBuilder 构建字符串：相比于使用+操作符连接字符串，StringBuilder 可以避免额外的对象创建。
采用原子变量：通过 java.util.concurrent.atomic 包中的类，如 AtomicInteger 和 AtomicLong，可以在无需显式同步的情况下执行原子操作。 避免共享可变状态：设计不可变的类，以消除对同步的需求，确保线程安全。 最小化锁争用：通过细粒度锁定或锁分段等技术，减少对同一把锁的竞争，从而降低锁争用。 使用 **synchronized**** 关键字**：通过 synchronized 关键字创建同步块或方法，保证同一时间只有一个线程能访问该代码块。 使用线程安全的数据结构：利用 java.util.concurrent 包提供的线程安全数据结构，如 ConcurrentHashMap、CopyOnWriteArrayList 和 BlockingQueue，处理并发访问，无需额外的同步措施。
鲁公网安备37020202000738号